@onekeyfe/hwk-trezor-connector-electron-ble 1.1.27-alpha.100

package/dist/chunk-KNBLSVDP.mjs

@@ -0,0 +1,37 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/constants.ts
+var TREZOR_BLE_CHANNELS = {
+  scan: "$onekey-trezor-ble-scan",
+  stopScan: "$onekey-trezor-ble-stop-scan",
+  connect: "$onekey-trezor-ble-connect",
+  disconnect: "$onekey-trezor-ble-disconnect",
+  write: "$onekey-trezor-ble-write",
+  subscribe: "$onekey-trezor-ble-subscribe",
+  unsubscribe: "$onekey-trezor-ble-unsubscribe",
+  availability: "$onekey-trezor-ble-availability",
+  getDevice: "$onekey-trezor-ble-get-device",
+  readRssi: "$onekey-trezor-ble-read-rssi",
+  cancelPairing: "$onekey-trezor-ble-cancel-pairing",
+  /** push event: main → renderer with assembled BLE notification payload */
+  notification: "$onekey-trezor-ble-notification",
+  /** push event: main → renderer when device disconnects unexpectedly */
+  disconnected: "$onekey-trezor-ble-disconnected"
+};
+var TREZOR_BLE_SCAN_DURATION_MS = 5e3;
+var TREZOR_BLE_POWER_ON_TIMEOUT_MS = 1e4;
+var TREZOR_BLE_WRITE_CHUNK_DELAY_MS = 5;
+
+export {
+  __require,
+  TREZOR_BLE_CHANNELS,
+  TREZOR_BLE_SCAN_DURATION_MS,
+  TREZOR_BLE_POWER_ON_TIMEOUT_MS,
+  TREZOR_BLE_WRITE_CHUNK_DELAY_MS
+};
+//# sourceMappingURL=chunk-KNBLSVDP.mjs.map

package/dist/chunk-KNBLSVDP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constants.ts"],"sourcesContent":["/**\n * IPC channel names exchanged between renderer and main process.\n * Namespaced under `$onekey-trezor-ble-…` to avoid clashing with the\n * existing OneKey BLE handler (`$onekey-noble-ble-…`) when both run in\n * the same Electron app.\n */\nexport const TREZOR_BLE_CHANNELS = {\n  scan: '$onekey-trezor-ble-scan',\n  stopScan: '$onekey-trezor-ble-stop-scan',\n  connect: '$onekey-trezor-ble-connect',\n  disconnect: '$onekey-trezor-ble-disconnect',\n  write: '$onekey-trezor-ble-write',\n  subscribe: '$onekey-trezor-ble-subscribe',\n  unsubscribe: '$onekey-trezor-ble-unsubscribe',\n  availability: '$onekey-trezor-ble-availability',\n  getDevice: '$onekey-trezor-ble-get-device',\n  readRssi: '$onekey-trezor-ble-read-rssi',\n  cancelPairing: '$onekey-trezor-ble-cancel-pairing',\n  /** push event: main → renderer with assembled BLE notification payload */\n  notification: '$onekey-trezor-ble-notification',\n  /** push event: main → renderer when device disconnects unexpectedly */\n  disconnected: '$onekey-trezor-ble-disconnected',\n} as const;\n\nexport type TrezorBleChannel = (typeof TREZOR_BLE_CHANNELS)[keyof typeof TREZOR_BLE_CHANNELS];\n\n/** Default scan window — same as OneKey's `enumerate`. */\nexport const TREZOR_BLE_SCAN_DURATION_MS = 5_000;\n\n/** Time we'll wait for noble to reach `poweredOn` before failing init. */\nexport const TREZOR_BLE_POWER_ON_TIMEOUT_MS = 10_000;\n\n/** Inter-chunk delay during write, matches OneKey's `UNIFIED_WRITE_DELAY`. */\nexport const TREZOR_BLE_WRITE_CHUNK_DELAY_MS = 5;\n"],"mappings":";;;;;;;;AAMO,IAAM,sBAAsB;AAAA,EACjC,MAAM;AAAA,EACN,UAAU;AAAA,EACV,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,WAAW;AAAA,EACX,aAAa;AAAA,EACb,cAAc;AAAA,EACd,WAAW;AAAA,EACX,UAAU;AAAA,EACV,eAAe;AAAA;AAAA,EAEf,cAAc;AAAA;AAAA,EAEd,cAAc;AAChB;AAKO,IAAM,8BAA8B;AAGpC,IAAM,iCAAiC;AAGvC,IAAM,kCAAkC;","names":[]}

package/dist/constants-D7zVXklG.d.mts

@@ -0,0 +1,104 @@
+/**
+ * Shape of the API the renderer process talks to. In a real Electron app
+ * this is normally exposed via `contextBridge.exposeInMainWorld('desktopApi',
+ * { trezorBle: ... })`, but the transport accepts the bridge directly so
+ * non-Electron hosts (and unit tests) can plug in their own implementation.
+ */
+interface TrezorBleDeviceInfo {
+    /** Stable id (noble peripheral.id) used as connectId. */
+    id: string;
+    name?: string;
+    rssi?: number;
+    advertisedServiceUuids?: string[];
+    /** Same as `name`, kept explicit to mirror noble's `advertisement.localName`. */
+    localName?: string;
+    /** Whether the peripheral advertised itself as connectable. */
+    isConnectable?: boolean | null;
+    serviceSolicitationUuids?: string[];
+    txPowerLevel?: number;
+    /** Manufacturer-specific advertisement data, hex-encoded (may embed a serial). */
+    manufacturerDataHex?: string;
+    /** Per-service advertisement data, each hex-encoded. */
+    serviceData?: Array<{
+        uuid: string;
+        dataHex: string;
+    }>;
+    /** BLE MAC/address when the OS exposes it separately from `id`. */
+    address?: string;
+    addressType?: string;
+    /** noble peripheral connection state at scan time. */
+    state?: string;
+}
+interface TrezorBleAvailability {
+    available: boolean;
+    /** noble state: `poweredOn` / `poweredOff` / `unauthorized` / `unsupported` / `resetting` / `unknown`. */
+    state: string;
+    initialized: boolean;
+}
+interface TrezorBleScanOptions {
+    /** Service UUIDs advertised by target devices. Omit for default (Trezor). */
+    serviceUuids?: string[];
+    durationMs?: number;
+}
+interface TrezorBleApi {
+    scan(options?: TrezorBleScanOptions): Promise<TrezorBleDeviceInfo[]>;
+    stopScan(): Promise<void>;
+    connect(id: string): Promise<{
+        id: string;
+        name?: string;
+    }>;
+    disconnect(id: string): Promise<void>;
+    /** Subscribe to the BLE notify characteristic for `id`. */
+    subscribe(id: string): Promise<void>;
+    unsubscribe(id: string): Promise<void>;
+    /**
+     * Write a payload (already-framed if Trezor v1, or a single 244-byte chunk
+     * for THP). The main process is responsible for splitting it into BLE-MTU
+     * chunks before handing it to noble.
+     */
+    write(id: string, hexData: string): Promise<void>;
+    checkAvailability(): Promise<TrezorBleAvailability>;
+    /** Look up a previously-scanned device by id without re-scanning. */
+    getDevice(id: string): Promise<TrezorBleDeviceInfo | null>;
+    /** Read current RSSI (dBm) of a *connected* peripheral. */
+    readRssi(id: string): Promise<number>;
+    /** Stop scan + disconnect every in-flight connection. */
+    cancelPairing(): Promise<void>;
+    /** Register a listener for incoming BLE notifications. Returns an unsubscribe fn. */
+    onNotification(handler: (id: string, hexData: string) => void): () => void;
+    /** Register a listener for unexpected disconnects. Returns an unsubscribe fn. */
+    onDeviceDisconnected(handler: (id: string) => void): () => void;
+}
+
+/**
+ * IPC channel names exchanged between renderer and main process.
+ * Namespaced under `$onekey-trezor-ble-…` to avoid clashing with the
+ * existing OneKey BLE handler (`$onekey-noble-ble-…`) when both run in
+ * the same Electron app.
+ */
+declare const TREZOR_BLE_CHANNELS: {
+    readonly scan: "$onekey-trezor-ble-scan";
+    readonly stopScan: "$onekey-trezor-ble-stop-scan";
+    readonly connect: "$onekey-trezor-ble-connect";
+    readonly disconnect: "$onekey-trezor-ble-disconnect";
+    readonly write: "$onekey-trezor-ble-write";
+    readonly subscribe: "$onekey-trezor-ble-subscribe";
+    readonly unsubscribe: "$onekey-trezor-ble-unsubscribe";
+    readonly availability: "$onekey-trezor-ble-availability";
+    readonly getDevice: "$onekey-trezor-ble-get-device";
+    readonly readRssi: "$onekey-trezor-ble-read-rssi";
+    readonly cancelPairing: "$onekey-trezor-ble-cancel-pairing";
+    /** push event: main → renderer with assembled BLE notification payload */
+    readonly notification: "$onekey-trezor-ble-notification";
+    /** push event: main → renderer when device disconnects unexpectedly */
+    readonly disconnected: "$onekey-trezor-ble-disconnected";
+};
+type TrezorBleChannel = (typeof TREZOR_BLE_CHANNELS)[keyof typeof TREZOR_BLE_CHANNELS];
+/** Default scan window — same as OneKey's `enumerate`. */
+declare const TREZOR_BLE_SCAN_DURATION_MS = 5000;
+/** Time we'll wait for noble to reach `poweredOn` before failing init. */
+declare const TREZOR_BLE_POWER_ON_TIMEOUT_MS = 10000;
+/** Inter-chunk delay during write, matches OneKey's `UNIFIED_WRITE_DELAY`. */
+declare const TREZOR_BLE_WRITE_CHUNK_DELAY_MS = 5;
+
+export { type TrezorBleApi as T, type TrezorBleDeviceInfo as a, TREZOR_BLE_CHANNELS as b, TREZOR_BLE_POWER_ON_TIMEOUT_MS as c, TREZOR_BLE_SCAN_DURATION_MS as d, TREZOR_BLE_WRITE_CHUNK_DELAY_MS as e, type TrezorBleAvailability as f, type TrezorBleChannel as g };

package/dist/constants-D7zVXklG.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Shape of the API the renderer process talks to. In a real Electron app
+ * this is normally exposed via `contextBridge.exposeInMainWorld('desktopApi',
+ * { trezorBle: ... })`, but the transport accepts the bridge directly so
+ * non-Electron hosts (and unit tests) can plug in their own implementation.
+ */
+interface TrezorBleDeviceInfo {
+    /** Stable id (noble peripheral.id) used as connectId. */
+    id: string;
+    name?: string;
+    rssi?: number;
+    advertisedServiceUuids?: string[];
+    /** Same as `name`, kept explicit to mirror noble's `advertisement.localName`. */
+    localName?: string;
+    /** Whether the peripheral advertised itself as connectable. */
+    isConnectable?: boolean | null;
+    serviceSolicitationUuids?: string[];
+    txPowerLevel?: number;
+    /** Manufacturer-specific advertisement data, hex-encoded (may embed a serial). */
+    manufacturerDataHex?: string;
+    /** Per-service advertisement data, each hex-encoded. */
+    serviceData?: Array<{
+        uuid: string;
+        dataHex: string;
+    }>;
+    /** BLE MAC/address when the OS exposes it separately from `id`. */
+    address?: string;
+    addressType?: string;
+    /** noble peripheral connection state at scan time. */
+    state?: string;
+}
+interface TrezorBleAvailability {
+    available: boolean;
+    /** noble state: `poweredOn` / `poweredOff` / `unauthorized` / `unsupported` / `resetting` / `unknown`. */
+    state: string;
+    initialized: boolean;
+}
+interface TrezorBleScanOptions {
+    /** Service UUIDs advertised by target devices. Omit for default (Trezor). */
+    serviceUuids?: string[];
+    durationMs?: number;
+}
+interface TrezorBleApi {
+    scan(options?: TrezorBleScanOptions): Promise<TrezorBleDeviceInfo[]>;
+    stopScan(): Promise<void>;
+    connect(id: string): Promise<{
+        id: string;
+        name?: string;
+    }>;
+    disconnect(id: string): Promise<void>;
+    /** Subscribe to the BLE notify characteristic for `id`. */
+    subscribe(id: string): Promise<void>;
+    unsubscribe(id: string): Promise<void>;
+    /**
+     * Write a payload (already-framed if Trezor v1, or a single 244-byte chunk
+     * for THP). The main process is responsible for splitting it into BLE-MTU
+     * chunks before handing it to noble.
+     */
+    write(id: string, hexData: string): Promise<void>;
+    checkAvailability(): Promise<TrezorBleAvailability>;
+    /** Look up a previously-scanned device by id without re-scanning. */
+    getDevice(id: string): Promise<TrezorBleDeviceInfo | null>;
+    /** Read current RSSI (dBm) of a *connected* peripheral. */
+    readRssi(id: string): Promise<number>;
+    /** Stop scan + disconnect every in-flight connection. */
+    cancelPairing(): Promise<void>;
+    /** Register a listener for incoming BLE notifications. Returns an unsubscribe fn. */
+    onNotification(handler: (id: string, hexData: string) => void): () => void;
+    /** Register a listener for unexpected disconnects. Returns an unsubscribe fn. */
+    onDeviceDisconnected(handler: (id: string) => void): () => void;
+}
+
+/**
+ * IPC channel names exchanged between renderer and main process.
+ * Namespaced under `$onekey-trezor-ble-…` to avoid clashing with the
+ * existing OneKey BLE handler (`$onekey-noble-ble-…`) when both run in
+ * the same Electron app.
+ */
+declare const TREZOR_BLE_CHANNELS: {
+    readonly scan: "$onekey-trezor-ble-scan";
+    readonly stopScan: "$onekey-trezor-ble-stop-scan";
+    readonly connect: "$onekey-trezor-ble-connect";
+    readonly disconnect: "$onekey-trezor-ble-disconnect";
+    readonly write: "$onekey-trezor-ble-write";
+    readonly subscribe: "$onekey-trezor-ble-subscribe";
+    readonly unsubscribe: "$onekey-trezor-ble-unsubscribe";
+    readonly availability: "$onekey-trezor-ble-availability";
+    readonly getDevice: "$onekey-trezor-ble-get-device";
+    readonly readRssi: "$onekey-trezor-ble-read-rssi";
+    readonly cancelPairing: "$onekey-trezor-ble-cancel-pairing";
+    /** push event: main → renderer with assembled BLE notification payload */
+    readonly notification: "$onekey-trezor-ble-notification";
+    /** push event: main → renderer when device disconnects unexpectedly */
+    readonly disconnected: "$onekey-trezor-ble-disconnected";
+};
+type TrezorBleChannel = (typeof TREZOR_BLE_CHANNELS)[keyof typeof TREZOR_BLE_CHANNELS];
+/** Default scan window — same as OneKey's `enumerate`. */
+declare const TREZOR_BLE_SCAN_DURATION_MS = 5000;
+/** Time we'll wait for noble to reach `poweredOn` before failing init. */
+declare const TREZOR_BLE_POWER_ON_TIMEOUT_MS = 10000;
+/** Inter-chunk delay during write, matches OneKey's `UNIFIED_WRITE_DELAY`. */
+declare const TREZOR_BLE_WRITE_CHUNK_DELAY_MS = 5;
+
+export { type TrezorBleApi as T, type TrezorBleDeviceInfo as a, TREZOR_BLE_CHANNELS as b, TREZOR_BLE_POWER_ON_TIMEOUT_MS as c, TREZOR_BLE_SCAN_DURATION_MS as d, TREZOR_BLE_WRITE_CHUNK_DELAY_MS as e, type TrezorBleAvailability as f, type TrezorBleChannel as g };

package/dist/index.d.mts

@@ -0,0 +1,64 @@
+import { TrezorConnectorBase, TrezorConnectorBaseOptions, TrezorConnectorByteTransport } from '@onekeyfe/hwk-trezor-connector';
+import { T as TrezorBleApi, a as TrezorBleDeviceInfo } from './constants-D7zVXklG.mjs';
+export { b as TREZOR_BLE_CHANNELS, c as TREZOR_BLE_POWER_ON_TIMEOUT_MS, d as TREZOR_BLE_SCAN_DURATION_MS, e as TREZOR_BLE_WRITE_CHUNK_DELAY_MS, f as TrezorBleAvailability, g as TrezorBleChannel } from './constants-D7zVXklG.mjs';
+import { ConnectorDevice } from '@onekeyfe/hwk-adapter-core';
+
+interface TrezorElectronBleTransportOptions {
+    /** The IPC bridge exposed by the main process (typically `window.desktopApi.trezorBle`). */
+    bridge?: TrezorBleApi;
+    logger?: (entry: {
+        level: 'debug' | 'info' | 'warn' | 'error';
+        scope: string;
+        event: string;
+        data?: Record<string, unknown>;
+    }) => void;
+}
+/**
+ * Renderer-side wrapper around the main process's BLE handler. Buffers
+ * notifications into a per-device read queue so callers can `read()`
+ * sequentially without missing chunks that arrive between reads.
+ */
+declare class TrezorElectronBleTransport {
+    private readonly _bridge;
+    private readonly _connected;
+    private readonly _readQueues;
+    private readonly _pendingReads;
+    private readonly _disconnectHandlers;
+    private _disposeNotificationListener?;
+    private _disposeDisconnectListener?;
+    private readonly _logger?;
+    constructor(options?: TrezorElectronBleTransportOptions);
+    scan(durationMs?: number): Promise<TrezorBleDeviceInfo[]>;
+    stopScan(): Promise<void>;
+    connect(connectId: string): Promise<void>;
+    disconnect(connectId: string): Promise<void>;
+    write(connectId: string, data: Uint8Array): Promise<void>;
+    read(connectId: string): Promise<Uint8Array>;
+    onDisconnect(connectId: string, handler: () => void): () => void;
+    /** Tear down global listeners — called by the connector's `reset()`. */
+    reset(): void;
+    private _wireGlobalListeners;
+    private _failPendingReads;
+    private _log;
+}
+declare function createTrezorElectronBleTransport(options?: TrezorElectronBleTransportOptions): TrezorElectronBleTransport;
+
+interface TrezorElectronBleConnectorOptions {
+    transport?: TrezorElectronBleTransport;
+    transportOptions?: TrezorElectronBleTransportOptions;
+    thp?: TrezorConnectorBaseOptions['thp'];
+    deviceSessionFactory?: TrezorConnectorBaseOptions['deviceSessionFactory'];
+}
+declare class TrezorElectronBleConnector extends TrezorConnectorBase {
+    private _transport;
+    private readonly _transportOptions?;
+    constructor(options?: TrezorElectronBleConnectorOptions);
+    protected enumerateDevices(): Promise<ConnectorDevice[]>;
+    protected createByteTransport(device: ConnectorDevice): Promise<TrezorConnectorByteTransport>;
+    protected resolveUnlistedDevice(deviceId: string): ConnectorDevice | undefined;
+    reset(): void;
+    private _ensureTransport;
+}
+declare function createTrezorElectronBleConnector(options?: TrezorElectronBleConnectorOptions): TrezorElectronBleConnector;
+
+export { TrezorBleApi, TrezorBleDeviceInfo, TrezorElectronBleConnector, type TrezorElectronBleConnectorOptions, TrezorElectronBleTransport, type TrezorElectronBleTransportOptions, createTrezorElectronBleConnector, createTrezorElectronBleTransport };

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import { TrezorConnectorBase, TrezorConnectorBaseOptions, TrezorConnectorByteTransport } from '@onekeyfe/hwk-trezor-connector';
+import { T as TrezorBleApi, a as TrezorBleDeviceInfo } from './constants-D7zVXklG.js';
+export { b as TREZOR_BLE_CHANNELS, c as TREZOR_BLE_POWER_ON_TIMEOUT_MS, d as TREZOR_BLE_SCAN_DURATION_MS, e as TREZOR_BLE_WRITE_CHUNK_DELAY_MS, f as TrezorBleAvailability, g as TrezorBleChannel } from './constants-D7zVXklG.js';
+import { ConnectorDevice } from '@onekeyfe/hwk-adapter-core';
+
+interface TrezorElectronBleTransportOptions {
+    /** The IPC bridge exposed by the main process (typically `window.desktopApi.trezorBle`). */
+    bridge?: TrezorBleApi;
+    logger?: (entry: {
+        level: 'debug' | 'info' | 'warn' | 'error';
+        scope: string;
+        event: string;
+        data?: Record<string, unknown>;
+    }) => void;
+}
+/**
+ * Renderer-side wrapper around the main process's BLE handler. Buffers
+ * notifications into a per-device read queue so callers can `read()`
+ * sequentially without missing chunks that arrive between reads.
+ */
+declare class TrezorElectronBleTransport {
+    private readonly _bridge;
+    private readonly _connected;
+    private readonly _readQueues;
+    private readonly _pendingReads;
+    private readonly _disconnectHandlers;
+    private _disposeNotificationListener?;
+    private _disposeDisconnectListener?;
+    private readonly _logger?;
+    constructor(options?: TrezorElectronBleTransportOptions);
+    scan(durationMs?: number): Promise<TrezorBleDeviceInfo[]>;
+    stopScan(): Promise<void>;
+    connect(connectId: string): Promise<void>;
+    disconnect(connectId: string): Promise<void>;
+    write(connectId: string, data: Uint8Array): Promise<void>;
+    read(connectId: string): Promise<Uint8Array>;
+    onDisconnect(connectId: string, handler: () => void): () => void;
+    /** Tear down global listeners — called by the connector's `reset()`. */
+    reset(): void;
+    private _wireGlobalListeners;
+    private _failPendingReads;
+    private _log;
+}
+declare function createTrezorElectronBleTransport(options?: TrezorElectronBleTransportOptions): TrezorElectronBleTransport;
+
+interface TrezorElectronBleConnectorOptions {
+    transport?: TrezorElectronBleTransport;
+    transportOptions?: TrezorElectronBleTransportOptions;
+    thp?: TrezorConnectorBaseOptions['thp'];
+    deviceSessionFactory?: TrezorConnectorBaseOptions['deviceSessionFactory'];
+}
+declare class TrezorElectronBleConnector extends TrezorConnectorBase {
+    private _transport;
+    private readonly _transportOptions?;
+    constructor(options?: TrezorElectronBleConnectorOptions);
+    protected enumerateDevices(): Promise<ConnectorDevice[]>;
+    protected createByteTransport(device: ConnectorDevice): Promise<TrezorConnectorByteTransport>;
+    protected resolveUnlistedDevice(deviceId: string): ConnectorDevice | undefined;
+    reset(): void;
+    private _ensureTransport;
+}
+declare function createTrezorElectronBleConnector(options?: TrezorElectronBleConnectorOptions): TrezorElectronBleConnector;
+
+export { TrezorBleApi, TrezorBleDeviceInfo, TrezorElectronBleConnector, type TrezorElectronBleConnectorOptions, TrezorElectronBleTransport, type TrezorElectronBleTransportOptions, createTrezorElectronBleConnector, createTrezorElectronBleTransport };

package/dist/index.js

@@ -0,0 +1,284 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TREZOR_BLE_CHANNELS: () => TREZOR_BLE_CHANNELS,
+  TREZOR_BLE_POWER_ON_TIMEOUT_MS: () => TREZOR_BLE_POWER_ON_TIMEOUT_MS,
+  TREZOR_BLE_SCAN_DURATION_MS: () => TREZOR_BLE_SCAN_DURATION_MS,
+  TREZOR_BLE_WRITE_CHUNK_DELAY_MS: () => TREZOR_BLE_WRITE_CHUNK_DELAY_MS,
+  TrezorElectronBleConnector: () => TrezorElectronBleConnector,
+  TrezorElectronBleTransport: () => TrezorElectronBleTransport,
+  createTrezorElectronBleConnector: () => createTrezorElectronBleConnector,
+  createTrezorElectronBleTransport: () => createTrezorElectronBleTransport
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/TrezorElectronBleConnector.ts
+var import_buffer = require("buffer");
+var import_hwk_trezor_adapter2 = require("@onekeyfe/hwk-trezor-adapter");
+var import_hwk_trezor_connector = require("@onekeyfe/hwk-trezor-connector");
+
+// src/TrezorElectronBleTransport.ts
+var import_hwk_adapter_core = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_trezor_adapter = require("@onekeyfe/hwk-trezor-adapter");
+var disconnectError = (message) => Object.assign(new Error(message), { code: import_hwk_adapter_core.HardwareErrorCode.DeviceDisconnected });
+var notConnectedError = (id) => disconnectError(`Trezor Electron BLE device is not connected: ${id}`);
+var resolveBridge = (options) => {
+  if (options?.bridge) return options.bridge;
+  const win = typeof window !== "undefined" ? window : void 0;
+  const bridge = win?.desktopApi?.trezorBle;
+  if (!bridge) {
+    throw new Error(
+      "TrezorElectronBleTransport: no bridge found \u2014 pass `bridge` or expose `window.desktopApi.trezorBle` from your Electron preload script"
+    );
+  }
+  return bridge;
+};
+var TrezorElectronBleTransport = class {
+  constructor(options = {}) {
+    this._connected = /* @__PURE__ */ new Set();
+    this._readQueues = /* @__PURE__ */ new Map();
+    this._pendingReads = /* @__PURE__ */ new Map();
+    this._disconnectHandlers = /* @__PURE__ */ new Map();
+    this._bridge = resolveBridge(options);
+    this._logger = options.logger;
+    this._wireGlobalListeners();
+  }
+  async scan(durationMs) {
+    return this._bridge.scan({
+      serviceUuids: [import_hwk_trezor_adapter.TREZOR_BLE_UUIDS.service],
+      durationMs
+    });
+  }
+  async stopScan() {
+    await this._bridge.stopScan();
+  }
+  async connect(connectId) {
+    if (this._connected.has(connectId)) return;
+    await this._bridge.connect(connectId);
+    await this._bridge.subscribe(connectId);
+    this._connected.add(connectId);
+    this._readQueues.set(connectId, []);
+    this._pendingReads.set(connectId, []);
+  }
+  async disconnect(connectId) {
+    this._connected.delete(connectId);
+    this._failPendingReads(connectId, notConnectedError(connectId));
+    this._readQueues.delete(connectId);
+    try {
+      await this._bridge.unsubscribe(connectId);
+    } catch (error) {
+      this._log("warn", "unsubscribe.error", { connectId, error: String(error) });
+    }
+    await this._bridge.disconnect(connectId);
+  }
+  async write(connectId, data) {
+    if (!this._connected.has(connectId)) throw notConnectedError(connectId);
+    const hex = Buffer.from(data).toString("hex");
+    await this._bridge.write(connectId, hex);
+  }
+  async read(connectId) {
+    if (!this._connected.has(connectId)) throw notConnectedError(connectId);
+    const queue = this._readQueues.get(connectId);
+    if (queue && queue.length > 0) {
+      return queue.shift();
+    }
+    return new Promise((resolve, reject) => {
+      const pending = this._pendingReads.get(connectId);
+      if (!pending) {
+        reject(notConnectedError(connectId));
+        return;
+      }
+      pending.push({ resolve, reject });
+    });
+  }
+  onDisconnect(connectId, handler) {
+    const handlers = this._disconnectHandlers.get(connectId) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this._disconnectHandlers.set(connectId, handlers);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this._disconnectHandlers.delete(connectId);
+      }
+    };
+  }
+  /** Tear down global listeners — called by the connector's `reset()`. */
+  reset() {
+    this._disposeNotificationListener?.();
+    this._disposeDisconnectListener?.();
+    this._disposeNotificationListener = void 0;
+    this._disposeDisconnectListener = void 0;
+    for (const handlers of this._disconnectHandlers.values()) handlers.clear();
+    this._disconnectHandlers.clear();
+    for (const id of this._connected) this._failPendingReads(id, notConnectedError(id));
+    this._connected.clear();
+    this._readQueues.clear();
+    this._pendingReads.clear();
+  }
+  _wireGlobalListeners() {
+    this._disposeNotificationListener = this._bridge.onNotification((id, hex) => {
+      const data = new Uint8Array(Buffer.from(hex, "hex"));
+      const pending = this._pendingReads.get(id);
+      if (pending && pending.length > 0) {
+        pending.shift().resolve(data);
+        return;
+      }
+      const queue = this._readQueues.get(id);
+      if (queue) queue.push(data);
+    });
+    this._disposeDisconnectListener = this._bridge.onDeviceDisconnected((id) => {
+      this._connected.delete(id);
+      this._failPendingReads(id, disconnectError(`Trezor BLE device disconnected: ${id}`));
+      this._readQueues.delete(id);
+      this._disconnectHandlers.get(id)?.forEach((handler) => {
+        try {
+          handler();
+        } catch (error) {
+          this._log("error", "disconnect.handler.threw", { id, error: String(error) });
+        }
+      });
+    });
+  }
+  _failPendingReads(connectId, error) {
+    const pending = this._pendingReads.get(connectId);
+    if (!pending) return;
+    for (const item of pending) item.reject(error);
+    this._pendingReads.set(connectId, []);
+  }
+  _log(level, event, data) {
+    this._logger?.({ level, scope: "trezor-electron-ble", event, data });
+  }
+};
+function createTrezorElectronBleTransport(options) {
+  return new TrezorElectronBleTransport(options);
+}
+
+// src/TrezorElectronBleConnector.ts
+var TrezorElectronBleConnector = class extends import_hwk_trezor_connector.TrezorConnectorBase {
+  constructor(options) {
+    super({
+      connectionType: "ble",
+      chunkSize: import_hwk_trezor_adapter2.TREZOR_BLE_PACKET_SIZE,
+      thp: options?.thp,
+      deviceSessionFactory: options?.deviceSessionFactory
+    });
+    this._transport = options?.transport;
+    this._transportOptions = options?.transportOptions;
+  }
+  async enumerateDevices() {
+    const transport = this._ensureTransport();
+    const devices = await transport.scan();
+    return devices.map((d) => ({
+      connectId: d.id,
+      deviceId: d.id,
+      name: d.name ?? d.localName ?? "Trezor Safe 7",
+      model: import_hwk_trezor_adapter2.TREZOR_SAFE_7_MODEL,
+      connectionType: "ble",
+      // Promote the typed BLE fields the device surface already has slots for.
+      rssi: d.rssi ?? null,
+      isConnectable: d.isConnectable ?? null,
+      capabilities: { persistentDeviceIdentity: false },
+      // Stash the FULL scan-time advertisement so the app/debug layer sees
+      // everything the OS BLE stack exposed (mirrors the WebUSB connector's
+      // `raw.descriptor`). This is where a cross-transport identity, if any,
+      // would surface (manufacturerData / serviceData / localName).
+      raw: {
+        transport: "electron-ble",
+        descriptor: d
+      }
+    }));
+  }
+  async createByteTransport(device) {
+    const transport = this._ensureTransport();
+    await transport.connect(device.connectId);
+    return {
+      write: async (chunk) => {
+        await transport.write(device.connectId, Uint8Array.from(chunk));
+      },
+      read: async () => {
+        const data = await transport.read(device.connectId);
+        return import_buffer.Buffer.from(data);
+      },
+      close: () => transport.disconnect(device.connectId),
+      onDisconnect: (handler) => transport.onDisconnect(device.connectId, handler)
+    };
+  }
+  resolveUnlistedDevice(deviceId) {
+    const connectId = deviceId.trim();
+    if (!connectId) return void 0;
+    return {
+      connectId,
+      deviceId: connectId,
+      name: "Trezor Safe 7",
+      model: import_hwk_trezor_adapter2.TREZOR_SAFE_7_MODEL,
+      capabilities: { persistentDeviceIdentity: false }
+    };
+  }
+  reset() {
+    super.reset();
+    this._transport?.reset();
+    this._transport = void 0;
+  }
+  _ensureTransport() {
+    if (!this._transport) {
+      this._transport = new TrezorElectronBleTransport(this._transportOptions);
+    }
+    return this._transport;
+  }
+};
+function createTrezorElectronBleConnector(options) {
+  return new TrezorElectronBleConnector(options);
+}
+
+// src/constants.ts
+var TREZOR_BLE_CHANNELS = {
+  scan: "$onekey-trezor-ble-scan",
+  stopScan: "$onekey-trezor-ble-stop-scan",
+  connect: "$onekey-trezor-ble-connect",
+  disconnect: "$onekey-trezor-ble-disconnect",
+  write: "$onekey-trezor-ble-write",
+  subscribe: "$onekey-trezor-ble-subscribe",
+  unsubscribe: "$onekey-trezor-ble-unsubscribe",
+  availability: "$onekey-trezor-ble-availability",
+  getDevice: "$onekey-trezor-ble-get-device",
+  readRssi: "$onekey-trezor-ble-read-rssi",
+  cancelPairing: "$onekey-trezor-ble-cancel-pairing",
+  /** push event: main → renderer with assembled BLE notification payload */
+  notification: "$onekey-trezor-ble-notification",
+  /** push event: main → renderer when device disconnects unexpectedly */
+  disconnected: "$onekey-trezor-ble-disconnected"
+};
+var TREZOR_BLE_SCAN_DURATION_MS = 5e3;
+var TREZOR_BLE_POWER_ON_TIMEOUT_MS = 1e4;
+var TREZOR_BLE_WRITE_CHUNK_DELAY_MS = 5;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TREZOR_BLE_CHANNELS,
+  TREZOR_BLE_POWER_ON_TIMEOUT_MS,
+  TREZOR_BLE_SCAN_DURATION_MS,
+  TREZOR_BLE_WRITE_CHUNK_DELAY_MS,
+  TrezorElectronBleConnector,
+  TrezorElectronBleTransport,
+  createTrezorElectronBleConnector,
+  createTrezorElectronBleTransport
+});
+//# sourceMappingURL=index.js.map