edilkamin 1.7.4 → 1.9.0

package/dist/cjs/src/library.test.js

@@ -187,9 +187,35 @@ describe("library", () => {
             "setPowerOff",
             "setPowerOn",
             "getPower",
+            "setPowerLevel",
+            "getPowerLevel",
+            "setFan1Speed",
+            "setFan2Speed",
+            "setFan3Speed",
+            "getFan1Speed",
+            "getFan2Speed",
+            "getFan3Speed",
+            "setAirkare",
+            "setRelax",
+            "setStandby",
+            "getStandby",
+            "setStandbyTime",
+            "getStandbyTime",
+            "setAuto",
+            "getAuto",
             "getEnvironmentTemperature",
             "getTargetTemperature",
             "setTargetTemperature",
+            "setEnvironment2Temperature",
+            "getEnvironment2Temperature",
+            "setEnvironment3Temperature",
+            "getEnvironment3Temperature",
+            "setMeasureUnit",
+            "getMeasureUnit",
+            "setLanguage",
+            "getLanguage",
+            "getPelletInReserve",
+            "getPelletAutonomyTime",
         ];
         it("should create API methods with the correct baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
             const baseURL = "https://example.com/api/";
@@ -220,10 +246,27 @@ describe("library", () => {
                 temperatures: {
                     enviroment: 19,
                 },
+                flags: {
+                    is_pellet_in_reserve: false,
+                },
+                pellet: {
+                    autonomy_time: 180,
+                },
             },
             nvm: {
                 user_parameters: {
                     enviroment_1_temperature: 22,
+                    enviroment_2_temperature: 18,
+                    enviroment_3_temperature: 20,
+                    manual_power: 3,
+                    fan_1_ventilation: 2,
+                    fan_2_ventilation: 3,
+                    fan_3_ventilation: 4,
+                    is_standby_active: true,
+                    standby_waiting_time: 30,
+                    is_auto: true,
+                    is_fahrenheit: false,
+                    language: 2,
                 },
             },
         };
@@ -279,6 +322,26 @@ describe("library", () => {
                 call: (api, token, mac) => api.getPower(token, mac),
                 expectedResult: true,
             },
+            {
+                method: "getPowerLevel",
+                call: (api, token, mac) => api.getPowerLevel(token, mac),
+                expectedResult: 3,
+            },
+            {
+                method: "getFan1Speed",
+                call: (api, token, mac) => api.getFan1Speed(token, mac),
+                expectedResult: 2,
+            },
+            {
+                method: "getFan2Speed",
+                call: (api, token, mac) => api.getFan2Speed(token, mac),
+                expectedResult: 3,
+            },
+            {
+                method: "getFan3Speed",
+                call: (api, token, mac) => api.getFan3Speed(token, mac),
+                expectedResult: 4,
+            },
             {
                 method: "getEnvironmentTemperature",
                 call: (api, token, mac) => api.getEnvironmentTemperature(token, mac),
@@ -289,6 +352,51 @@ describe("library", () => {
                 call: (api, token, mac) => api.getTargetTemperature(token, mac),
                 expectedResult: 22,
             },
+            {
+                method: "getStandby",
+                call: (api, token, mac) => api.getStandby(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getStandbyTime",
+                call: (api, token, mac) => api.getStandbyTime(token, mac),
+                expectedResult: 30,
+            },
+            {
+                method: "getAuto",
+                call: (api, token, mac) => api.getAuto(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getEnvironment2Temperature",
+                call: (api, token, mac) => api.getEnvironment2Temperature(token, mac),
+                expectedResult: 18,
+            },
+            {
+                method: "getEnvironment3Temperature",
+                call: (api, token, mac) => api.getEnvironment3Temperature(token, mac),
+                expectedResult: 20,
+            },
+            {
+                method: "getMeasureUnit",
+                call: (api, token, mac) => api.getMeasureUnit(token, mac),
+                expectedResult: false,
+            },
+            {
+                method: "getLanguage",
+                call: (api, token, mac) => api.getLanguage(token, mac),
+                expectedResult: 2,
+            },
+            {
+                method: "getPelletInReserve",
+                call: (api, token, mac) => api.getPelletInReserve(token, mac),
+                expectedResult: false,
+            },
+            {
+                method: "getPelletAutonomyTime",
+                call: (api, token, mac) => api.getPelletAutonomyTime(token, mac),
+                expectedResult: 180,
+            },
         ];
         getterTests.forEach(({ method, call, expectedResult }) => {
             it(`should call fetch and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
@@ -306,6 +414,38 @@ describe("library", () => {
         });
         // Setter tests
         const setterTests = [
+            {
+                method: "setPowerLevel",
+                call: (api, token, mac, value) => api.setPowerLevel(token, mac, value),
+                payload: {
+                    name: "power_level",
+                    value: 4,
+                },
+            },
+            {
+                method: "setFan1Speed",
+                call: (api, token, mac, value) => api.setFan1Speed(token, mac, value),
+                payload: {
+                    name: "fan_1_speed",
+                    value: 3,
+                },
+            },
+            {
+                method: "setFan2Speed",
+                call: (api, token, mac, value) => api.setFan2Speed(token, mac, value),
+                payload: {
+                    name: "fan_2_speed",
+                    value: 4,
+                },
+            },
+            {
+                method: "setFan3Speed",
+                call: (api, token, mac, value) => api.setFan3Speed(token, mac, value),
+                payload: {
+                    name: "fan_3_speed",
+                    value: 5,
+                },
+            },
             {
                 method: "setTargetTemperature",
                 call: (api, token, mac, value) => api.setTargetTemperature(token, mac, value),
@@ -314,6 +454,38 @@ describe("library", () => {
                     value: 20,
                 },
             },
+            {
+                method: "setStandbyTime",
+                call: (api, token, mac, value) => api.setStandbyTime(token, mac, value),
+                payload: {
+                    name: "standby_time",
+                    value: 45,
+                },
+            },
+            {
+                method: "setEnvironment2Temperature",
+                call: (api, token, mac, value) => api.setEnvironment2Temperature(token, mac, value),
+                payload: {
+                    name: "enviroment_2_temperature",
+                    value: 21,
+                },
+            },
+            {
+                method: "setEnvironment3Temperature",
+                call: (api, token, mac, value) => api.setEnvironment3Temperature(token, mac, value),
+                payload: {
+                    name: "enviroment_3_temperature",
+                    value: 23,
+                },
+            },
+            {
+                method: "setLanguage",
+                call: (api, token, mac, value) => api.setLanguage(token, mac, value),
+                payload: {
+                    name: "language",
+                    value: 2,
+                },
+            },
         ];
         setterTests.forEach(({ method, call, payload }) => {
             it(`should call fetch and send the correct payload for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
@@ -332,6 +504,69 @@ describe("library", () => {
                 });
             }));
         });
+        // Boolean setter tests (for mode controls)
+        const booleanSetterTests = [
+            {
+                method: "setAirkare",
+                call: (api, token, mac, enabled) => api.setAirkare(token, mac, enabled),
+                truePayload: { name: "airkare_function", value: 1 },
+                falsePayload: { name: "airkare_function", value: 0 },
+            },
+            {
+                method: "setRelax",
+                call: (api, token, mac, enabled) => api.setRelax(token, mac, enabled),
+                truePayload: { name: "relax_mode", value: true },
+                falsePayload: { name: "relax_mode", value: false },
+            },
+            {
+                method: "setStandby",
+                call: (api, token, mac, enabled) => api.setStandby(token, mac, enabled),
+                truePayload: { name: "standby_mode", value: true },
+                falsePayload: { name: "standby_mode", value: false },
+            },
+            {
+                method: "setAuto",
+                call: (api, token, mac, enabled) => api.setAuto(token, mac, enabled),
+                truePayload: { name: "auto_mode", value: true },
+                falsePayload: { name: "auto_mode", value: false },
+            },
+            {
+                method: "setMeasureUnit",
+                call: (api, token, mac, enabled) => api.setMeasureUnit(token, mac, enabled),
+                truePayload: { name: "measure_unit", value: true },
+                falsePayload: { name: "measure_unit", value: false },
+            },
+        ];
+        booleanSetterTests.forEach(({ method, call, truePayload, falsePayload }) => {
+            it(`should call fetch with correct payload for ${method}(true)`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = (0, library_1.configure)("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", true);
+                assert_1.strict.ok(fetchStub.calledOnce);
+                assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, truePayload)),
+                });
+            }));
+            it(`should call fetch with correct payload for ${method}(false)`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = (0, library_1.configure)("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", false);
+                assert_1.strict.ok(fetchStub.calledOnce);
+                assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, falsePayload)),
+                });
+            }));
+        });
     });
     describe("registerDevice", () => {
         it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
@@ -520,6 +755,37 @@ describe("library", () => {
             const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
             assert_1.strict.equal(result, 22);
         }));
+        it("should work with getPelletInReserve on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19 },
+                flags: { is_pellet_in_reserve: true },
+                pellet: { autonomy_time: 120 },
+            };
+            const mockResponseData = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.getPelletInReserve(expectedToken, "mockMacAddress");
+            assert_1.strict.equal(result, true);
+        }));
+        it("should work with getPelletAutonomyTime on response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponseData = {
+                status: {
+                    commands: { power: true },
+                    temperatures: { enviroment: 19 },
+                    flags: { is_pellet_in_reserve: false },
+                    pellet: { autonomy_time: 240 },
+                },
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.getPelletAutonomyTime(expectedToken, "mockMacAddress");
+            assert_1.strict.equal(result, 240);
+        }));
     });
     describe("Error Handling", () => {
         const errorTests = [

package/dist/cjs/src/types.d.ts

@@ -13,9 +13,17 @@ interface TemperaturesType {
     board: number;
     enviroment: number;
 }
+interface GeneralFlagsType {
+    is_pellet_in_reserve: boolean;
+}
+interface PelletAutonomyType {
+    autonomy_time: number;
+}
 interface StatusType {
     commands: CommandsType;
     temperatures: TemperaturesType;
+    flags: GeneralFlagsType;
+    pellet: PelletAutonomyType;
 }
 interface UserParametersType {
     enviroment_1_temperature: number;
@@ -23,6 +31,14 @@ interface UserParametersType {
     enviroment_3_temperature: number;
     is_auto: boolean;
     is_sound_active: boolean;
+    manual_power: number;
+    fan_1_ventilation: number;
+    fan_2_ventilation: number;
+    fan_3_ventilation: number;
+    is_standby_active: boolean;
+    standby_waiting_time: number;
+    is_fahrenheit: boolean;
+    language: number;
 }
 interface DeviceInfoType {
     status: StatusType;
@@ -70,4 +86,17 @@ interface DeviceAssociationResponse {
     deviceRoom: string;
     serialNumber: string;
 }
-export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, EditDeviceAssociationBody, StatusType, TemperaturesType, UserParametersType, };
+/**
+ * Represents a discovered Edilkamin device from Bluetooth scanning.
+ */
+interface DiscoveredDevice {
+    /** BLE MAC address as discovered */
+    bleMac: string;
+    /** WiFi MAC address (BLE MAC - 2), used for API calls */
+    wifiMac: string;
+    /** Device name (typically "EDILKAMIN_EP") */
+    name: string;
+    /** Signal strength in dBm (optional, not all platforms provide this) */
+    rssi?: number;
+}
+export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, DiscoveredDevice, EditDeviceAssociationBody, GeneralFlagsType, PelletAutonomyType, StatusType, TemperaturesType, UserParametersType, };

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "edilkamin",
-    "version": "1.7.4",
+    "version": "1.9.0",
     "description": "",
     "main": "dist/cjs/src/index.js",
     "module": "dist/esm/src/index.js",
@@ -15,6 +15,16 @@
                 "types": "./dist/cjs/src/index.d.ts",
                 "default": "./dist/cjs/src/index.js"
             }
+        },
+        "./bluetooth": {
+            "import": {
+                "types": "./dist/esm/src/bluetooth.d.ts",
+                "default": "./dist/esm/src/bluetooth.js"
+            },
+            "require": {
+                "types": "./dist/cjs/src/bluetooth.d.ts",
+                "default": "./dist/cjs/src/bluetooth.js"
+            }
         }
     },
     "scripts": {
@@ -60,9 +70,10 @@
         "@eslint/eslintrc": "^3.2.0",
         "@eslint/js": "^9.16.0",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^25.0.2",
+        "@types/node": "^24",
         "@types/pako": "^2.0.4",
-        "@types/sinon": "^17.0.3",
+        "@types/sinon": "^21.0.0",
+        "@types/web-bluetooth": "^0.0.21",
         "@typescript-eslint/eslint-plugin": "^8.17.0",
         "@typescript-eslint/parser": "^8.17.0",
         "esbuild": "^0.27.1",
@@ -73,12 +84,12 @@
         "mocha": "^11.7.5",
         "nyc": "^17.1.0",
         "prettier": "^3.7.4",
-        "sinon": "^19.0.2",
+        "sinon": "^21.0.1",
         "ts-node": "^10.9.1",
         "typedoc": "^0.28.15",
         "typescript": "^5.7.2"
     },
     "optionalDependencies": {
-        "commander": "^12.1.0"
+        "commander": "^14.0.2"
     }
 }

package/dist/esm/src/bluetooth-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts a BLE MAC address to WiFi MAC address.
+ * The WiFi MAC is the BLE MAC minus 2 in hexadecimal.
+ *
+ * @param bleMac - BLE MAC address (with or without colons/dashes)
+ * @returns WiFi MAC address in lowercase without separators
+ *
+ * @example
+ * bleToWifiMac("A8:03:2A:FE:D5:0A") // returns "a8032afed508"
+ * bleToWifiMac("a8032afed50a")      // returns "a8032afed508"
+ */
+declare const bleToWifiMac: (bleMac: string) => string;
+export { bleToWifiMac };

package/dist/esm/src/bluetooth-utils.js

@@ -0,0 +1,25 @@
+/**
+ * Converts a BLE MAC address to WiFi MAC address.
+ * The WiFi MAC is the BLE MAC minus 2 in hexadecimal.
+ *
+ * @param bleMac - BLE MAC address (with or without colons/dashes)
+ * @returns WiFi MAC address in lowercase without separators
+ *
+ * @example
+ * bleToWifiMac("A8:03:2A:FE:D5:0A") // returns "a8032afed508"
+ * bleToWifiMac("a8032afed50a")      // returns "a8032afed508"
+ */
+const bleToWifiMac = (bleMac) => {
+    // Remove colons, dashes, and convert to lowercase
+    const normalized = bleMac.replace(/[:-]/g, "").toLowerCase();
+    // Validate MAC address format (12 hex characters)
+    if (!/^[0-9a-f]{12}$/.test(normalized)) {
+        throw new Error(`Invalid MAC address format: ${bleMac}`);
+    }
+    // Convert to number, subtract 2, convert back to hex
+    const bleValue = BigInt(`0x${normalized}`);
+    const wifiValue = bleValue - BigInt(2);
+    // Pad to 12 characters and return lowercase
+    return wifiValue.toString(16).padStart(12, "0");
+};
+export { bleToWifiMac };

package/dist/esm/src/bluetooth-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/bluetooth-utils.test.js

@@ -0,0 +1,33 @@
+import { strict as assert } from "assert";
+import { bleToWifiMac } from "./bluetooth-utils";
+describe("bleToWifiMac", () => {
+    it("converts BLE MAC with colons to WiFi MAC", () => {
+        assert.equal(bleToWifiMac("A8:03:2A:FE:D5:0A"), "a8032afed508");
+    });
+    it("converts BLE MAC without separators", () => {
+        assert.equal(bleToWifiMac("a8032afed50a"), "a8032afed508");
+    });
+    it("converts BLE MAC with dashes", () => {
+        assert.equal(bleToWifiMac("A8-03-2A-FE-D5-0A"), "a8032afed508");
+    });
+    it("handles lowercase input", () => {
+        assert.equal(bleToWifiMac("a8:03:2a:fe:d5:0a"), "a8032afed508");
+    });
+    it("handles edge case where subtraction crosses byte boundary", () => {
+        // FF:FF:FF:FF:FF:01 - 2 = FF:FF:FF:FF:FE:FF
+        assert.equal(bleToWifiMac("FF:FF:FF:FF:FF:01"), "fffffffffeff");
+    });
+    it("handles minimum value edge case", () => {
+        // 00:00:00:00:00:02 - 2 = 00:00:00:00:00:00
+        assert.equal(bleToWifiMac("00:00:00:00:00:02"), "000000000000");
+    });
+    it("throws on invalid MAC format - too short", () => {
+        assert.throws(() => bleToWifiMac("A8:03:2A"), /Invalid MAC address format/);
+    });
+    it("throws on invalid MAC format - invalid characters", () => {
+        assert.throws(() => bleToWifiMac("G8:03:2A:FE:D5:0A"), /Invalid MAC address format/);
+    });
+    it("throws on empty string", () => {
+        assert.throws(() => bleToWifiMac(""), /Invalid MAC address format/);
+    });
+});

package/dist/esm/src/bluetooth.d.ts

@@ -0,0 +1,40 @@
+import { DiscoveredDevice } from "./types";
+/** Device name broadcast by Edilkamin stoves */
+declare const EDILKAMIN_DEVICE_NAME = "EDILKAMIN_EP";
+/** GATT Service UUID for Edilkamin devices (0xABF0) */
+declare const EDILKAMIN_SERVICE_UUID = 44016;
+/**
+ * Check if Web Bluetooth API is available in the current browser.
+ *
+ * @returns true if Web Bluetooth is supported
+ */
+declare const isWebBluetoothSupported: () => boolean;
+/**
+ * Scan for nearby Edilkamin stoves using the Web Bluetooth API.
+ *
+ * This function triggers the browser's Bluetooth device picker dialog,
+ * filtered to show only devices named "EDILKAMIN_EP".
+ *
+ * Note: Web Bluetooth requires:
+ * - HTTPS or localhost
+ * - User gesture (button click)
+ * - Chrome/Edge/Opera (not Firefox/Safari)
+ *
+ * @returns Promise resolving to array of discovered devices
+ * @throws Error if Web Bluetooth is not supported or user cancels
+ *
+ * @example
+ * const devices = await scanForDevices();
+ * console.log(devices[0].wifiMac); // Use this for API calls
+ */
+declare const scanForDevices: () => Promise<DiscoveredDevice[]>;
+/**
+ * Scan for devices with a custom filter.
+ * Advanced function for users who need more control over device selection.
+ *
+ * @param options - Web Bluetooth requestDevice options
+ * @returns Promise resolving to the selected BluetoothDevice
+ */
+declare const scanWithOptions: (options: RequestDeviceOptions) => Promise<BluetoothDevice>;
+export { EDILKAMIN_DEVICE_NAME, EDILKAMIN_SERVICE_UUID, isWebBluetoothSupported, scanForDevices, scanWithOptions, };
+export type { DiscoveredDevice } from "./types";

package/dist/esm/src/bluetooth.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { bleToWifiMac } from "./bluetooth-utils";
+/** Device name broadcast by Edilkamin stoves */
+const EDILKAMIN_DEVICE_NAME = "EDILKAMIN_EP";
+/** GATT Service UUID for Edilkamin devices (0xABF0) */
+const EDILKAMIN_SERVICE_UUID = 0xabf0;
+/**
+ * Check if Web Bluetooth API is available in the current browser.
+ *
+ * @returns true if Web Bluetooth is supported
+ */
+const isWebBluetoothSupported = () => {
+    return typeof navigator !== "undefined" && "bluetooth" in navigator;
+};
+/**
+ * Scan for nearby Edilkamin stoves using the Web Bluetooth API.
+ *
+ * This function triggers the browser's Bluetooth device picker dialog,
+ * filtered to show only devices named "EDILKAMIN_EP".
+ *
+ * Note: Web Bluetooth requires:
+ * - HTTPS or localhost
+ * - User gesture (button click)
+ * - Chrome/Edge/Opera (not Firefox/Safari)
+ *
+ * @returns Promise resolving to array of discovered devices
+ * @throws Error if Web Bluetooth is not supported or user cancels
+ *
+ * @example
+ * const devices = await scanForDevices();
+ * console.log(devices[0].wifiMac); // Use this for API calls
+ */
+const scanForDevices = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isWebBluetoothSupported()) {
+        throw new Error("Web Bluetooth API is not supported in this browser. " +
+            "Use Chrome, Edge, or Opera on desktop/Android. " +
+            "On iOS, use the Bluefy browser app.");
+    }
+    try {
+        // Request device - this opens the browser's device picker
+        const device = yield navigator.bluetooth.requestDevice({
+            filters: [{ name: EDILKAMIN_DEVICE_NAME }],
+            optionalServices: [EDILKAMIN_SERVICE_UUID],
+        });
+        // Extract BLE MAC from device ID if available
+        // Note: device.id format varies by platform, may need adjustment
+        const bleMac = device.id || "";
+        const name = device.name || EDILKAMIN_DEVICE_NAME;
+        // Calculate WiFi MAC for API calls
+        let wifiMac = "";
+        if (bleMac && /^[0-9a-f:-]{12,17}$/i.test(bleMac)) {
+            try {
+                wifiMac = bleToWifiMac(bleMac);
+            }
+            catch (_a) {
+                // device.id may not be a valid MAC format on all platforms
+                wifiMac = "";
+            }
+        }
+        const discoveredDevice = {
+            bleMac,
+            wifiMac,
+            name,
+            // RSSI not directly available from requestDevice
+        };
+        return [discoveredDevice];
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === "NotFoundError") {
+                // User cancelled the device picker
+                return [];
+            }
+            throw error;
+        }
+        throw new Error("Unknown error during Bluetooth scan");
+    }
+});
+/**
+ * Scan for devices with a custom filter.
+ * Advanced function for users who need more control over device selection.
+ *
+ * @param options - Web Bluetooth requestDevice options
+ * @returns Promise resolving to the selected BluetoothDevice
+ */
+const scanWithOptions = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isWebBluetoothSupported()) {
+        throw new Error("Web Bluetooth API is not supported in this browser.");
+    }
+    return navigator.bluetooth.requestDevice(options);
+});
+export { EDILKAMIN_DEVICE_NAME, EDILKAMIN_SERVICE_UUID, isWebBluetoothSupported, scanForDevices, scanWithOptions, };