node-red-contrib-ble-scanner 0.0.1 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # node-red-contrib-ble-scanner
 
-Strict TypeScript Node.js library, CLI, and Node-RED nodes for collecting raw Bluetooth LE notification messages.
+Strict TypeScript Node.js library, CLI, and Node-RED nodes for collecting raw Bluetooth LE advertisement manufacturer data.
 
 The package supports two BLE backend implementations:
 
@@ -8,47 +8,40 @@ The package supports two BLE backend implementations:
 - `bluez`: uses Linux BlueZ over D-Bus
 - `noble`: uses `@abandonware/noble`
 
+The scanner does not connect to BLE devices and does not parse or decrypt device-specific payloads. It listens for BLE advertisements and returns the raw manufacturer data bytes.
+
 ## Library
 
 The package exports a typed ESM API from `dist/index.js`:
 
 - `discoverDevices(options)` returns matching BLE devices
-- `readDevices(options)` discovers, connects, subscribes, and collects raw notifications
-- `readDevice(device, options)` reads one discovered device
-- `connectReaders(options)` discovers and connects once, then returns persistent readers with `read()` and `disconnect()`
-- `shutdownBluetooth()` stops active BLE sessions
+- `readDevices(options)` listens for matching advertisements and collects raw manufacturer data
+- `readDevice(device, options)` reads advertisements for one discovered device
+- `shutdownBluetooth()` stops active BLE scans
 
-Each reading contains device metadata, a timestamp, the subscribed notification characteristic UUID, and a `messages` array. Every raw message includes the original Buffer as `data` plus `hex`, `base64`, `bytes`, `length`, and `timestamp`.
+Each reading contains device metadata, a timestamp, and a `messages` array. Every raw message includes the company id, original Buffer as `data`, plus `hex`, `base64`, `bytes`, `length`, and `timestamp`.
 
 ```js
-import { connectReaders } from 'node-red-contrib-ble-scanner';
+import { readDevices } from 'node-red-contrib-ble-scanner';
 
-const readers = await connectReaders({
+const readings = await readDevices({
   deviceName: 'My BLE Device',
-  scanServiceUuid: 'fff0',
-  matchServiceUuid: 'fff0',
-  notifyUuid: 'fff1',
   listenMs: 5000
 });
 
-try {
-  const reading = await readers[0].read();
-  console.log(reading.messages.map((message) => message.hex));
-} finally {
-  await Promise.all(readers.map((reader) => reader.disconnect()));
-}
+console.log(readings.flatMap((reading) => reading.messages.map((message) => message.hex)));
 ```
 
 ## Nodes
 
-- `ble-reader-device`: config node for BLE discovery, device selection, and notification UUID
-- `ble-reader-read`: input node that collects raw notifications
+- `ble-reader-device`: config node for BLE advertisement scanning, device selection, and filters
+- `ble-reader-read`: input node that collects raw manufacturer data
 
 Use the config node's search button to discover devices from the Node-RED editor. Select one exact advertised device name, or keep "All discovered devices".
 
 The output is placed in `msg.payload` as an array with zero, one, or multiple readings.
 
-Incoming `msg.payload` may contain `{ deviceName, listenMs, serviceUuid, notifyUuid }` to override the configured values for one read.
+Incoming `msg.payload` may contain `{ deviceName, listenMs, serviceUuid }` to override the configured values for one read.
 
 ## CLI
 
@@ -65,12 +58,12 @@ Useful options:
 node ./bin/ble-reader.js discover
 node ./bin/ble-reader.js discover --name-prefix SK
 node ./bin/ble-reader.js discover --service-uuid fff0
-node ./bin/ble-reader.js read "My BLE Device" --notify-uuid fff1 --listen-ms 5000
+node ./bin/ble-reader.js read "My BLE Device" --listen-ms 5000
 node ./bin/ble-reader.js read --bluetooth bluez --debug
 node ./bin/ble-reader.js read "My BLE Device" --interval 5
 ```
 
-`read --interval 5` keeps the BLE session open and collects notifications every five seconds until stopped.
+`read --interval 5` repeats an advertisement scan every five seconds until stopped.
 
 ## Development
 

package/dist/ble/backend.d.ts

@@ -1,27 +1,36 @@
 export type BluetoothBackendName = 'auto' | 'bluez' | 'noble';
 export type ResolvedBluetoothBackendName = Exclude<BluetoothBackendName, 'auto'>;
 export type Logger = (message: string) => void;
+export interface BleManufacturerData {
+    companyId: string;
+    companyIdHex: string;
+    length: number;
+    data: Buffer;
+    hex: string;
+    base64: string;
+    bytes: number[];
+}
 export interface BleDiscoveredDevice {
     id: string;
     name: string | null;
     address: string | null;
     addressType?: string | null;
     rssi: number | null;
+    serviceUuids?: string[];
+    manufacturerData?: BleManufacturerData[];
     backend: ResolvedBluetoothBackendName;
 }
-export interface RawBleMessage {
+export interface RawBleMessage extends BleManufacturerData {
     timestamp: string;
-    uuid: string;
-    length: number;
-    data: Buffer;
-    hex: string;
-    base64: string;
-    bytes: number[];
+    source: 'manufacturerData';
+}
+export interface BleAdvertisement {
+    device: BleDiscoveredDevice;
+    message: RawBleMessage;
 }
 export interface BleReading {
     device: BleDiscoveredDevice;
     timestamp: string;
-    notifyUuid: string;
     messages: RawBleMessage[];
 }
 export interface ReadOptions {
@@ -30,8 +39,6 @@ export interface ReadOptions {
     deviceName?: string;
     timeoutMs?: number;
     listenMs?: number;
-    connectTimeoutMs?: number;
-    notifyUuid?: string;
     scanServiceUuid?: string | null;
     matchServiceUuid?: string | null;
     logger?: Logger;
@@ -53,30 +60,14 @@ export interface ResolvedDiscoverOptions {
     matchServiceUuid: string | null;
     logger: Logger;
 }
-export interface ResolvedConnectOptions {
-    device: BleDiscoveredDevice;
-    timeoutMs: number;
-    connectTimeoutMs: number;
-    notifyUuid: string;
-    logger: Logger;
-}
-export interface BleCharacteristic {
-    uuid: string;
-    properties: string[];
-    write(data: Buffer, withoutResponse?: boolean): Promise<void>;
-    subscribe(): Promise<void>;
-    onData(listener: (data: Buffer) => void): void;
-    removeDataListener(listener: (data: Buffer) => void): void;
-}
-export interface BleSession {
-    device: BleDiscoveredDevice;
-    notify: BleCharacteristic;
-    disconnect(): Promise<void>;
+export interface ResolvedScanOptions extends ResolvedDiscoverOptions {
+    listenMs: number;
+    onAdvertisement(advertisement: BleAdvertisement): void;
 }
 export interface BluetoothBackend {
     name: ResolvedBluetoothBackendName;
     isAvailable(logger?: Logger): Promise<boolean>;
     discover(options: ResolvedDiscoverOptions): Promise<BleDiscoveredDevice[]>;
-    connect(options: ResolvedConnectOptions): Promise<BleSession>;
+    scanAdvertisements(options: ResolvedScanOptions): Promise<void>;
     shutdown(): Promise<void>;
 }

package/dist/ble/bluez.d.ts

@@ -6,5 +6,5 @@ interface BluezAdapter {
     SetDiscoveryFilter(filter: Record<string, unknown>): Promise<void>;
 }
 export declare const bluezBackend: BluetoothBackend;
-export declare function setBluezDiscoveryFilter(adapter: BluezAdapter, Variant: BluezVariantConstructor, serviceUuid: string | null, logger: Logger): Promise<void>;
+export declare function setBluezDiscoveryFilter(adapter: BluezAdapter, Variant: BluezVariantConstructor, serviceUuid: string | null, duplicateData: boolean, logger: Logger): Promise<void>;
 export {};

package/dist/ble/bluez.js

@@ -1,15 +1,19 @@
 import { createRequire } from 'node:module';
 import { setTimeout as delay } from 'node:timers/promises';
-import { errorMessage, formatCanonicalUuid, matchesBleDevice, normalizeUuid, nullableNumber, nullableString, unboxBluezValue, uniqueDevices } from './utils.js';
+import { createManufacturerData, createRawManufacturerMessage, errorMessage, formatCanonicalUuid, matchesBleDevice, nullableNumber, nullableString, normalizeUuid, unboxBluezValue, uniqueDevices } from './utils.js';
 const requireOptional = createRequire(import.meta.url);
+const BLUEZ_SERVICE = 'org.bluez';
+const DBUS_OBJECT_MANAGER = 'org.freedesktop.DBus.ObjectManager';
+const DBUS_PROPERTIES = 'org.freedesktop.DBus.Properties';
+const BLUEZ_ADAPTER = 'org.bluez.Adapter1';
+const BLUEZ_DEVICE = 'org.bluez.Device1';
 const DISCOVERY_POLL_MS = 500;
-let activeSessions = new Set();
 export const bluezBackend = {
     name: 'bluez',
     isAvailable: isBluezAvailable,
     discover: discoverBluezDevices,
-    connect: connectBluezDevice,
-    shutdown: shutdownBluez
+    scanAdvertisements: scanBluezAdvertisements,
+    shutdown: async () => { }
 };
 async function isBluezAvailable(logger = () => { }) {
     if (process.platform !== 'linux')
@@ -18,8 +22,8 @@ async function isBluezAvailable(logger = () => { }) {
         const { systemBus } = loadDbusNext();
         const bus = systemBus();
         try {
-            const object = await bus.getProxyObject('org.bluez', '/');
-            const objectManager = object.getInterface('org.freedesktop.DBus.ObjectManager');
+            const object = await bus.getProxyObject(BLUEZ_SERVICE, '/');
+            const objectManager = object.getInterface(DBUS_OBJECT_MANAGER);
             const objects = await objectManager.GetManagedObjects();
             return findBluezAdapterPath(objects) !== null;
         }
@@ -33,207 +37,152 @@ async function isBluezAvailable(logger = () => { }) {
     }
 }
 async function discoverBluezDevices(options) {
+    const devices = new Map();
+    await runBluezScan({
+        timeoutMs: options.timeoutMs,
+        scanServiceUuid: options.scanServiceUuid,
+        logger: options.logger,
+        onDevice: (device) => {
+            if (matchesDiscoveredDevice(device, options))
+                devices.set(deviceKey(device), device);
+        }
+    });
+    return uniqueDevices([...devices.values()]);
+}
+async function scanBluezAdvertisements(options) {
+    await runBluezScan({
+        timeoutMs: options.listenMs,
+        scanServiceUuid: options.scanServiceUuid,
+        logger: options.logger,
+        onAdvertisement: (device, payload) => {
+            if (!matchesDiscoveredDevice(device, options))
+                return;
+            options.onAdvertisement({
+                device,
+                message: createRawManufacturerMessage(payload.companyId, payload.data)
+            });
+        }
+    });
+}
+async function runBluezScan({ timeoutMs, scanServiceUuid, logger, onDevice, onAdvertisement }) {
     if (process.platform !== 'linux')
         throw new Error('BlueZ backend is only available on Linux.');
     const { systemBus, Variant } = loadDbusNext();
     const bus = systemBus();
-    try {
-        const { objectManager, adapter } = await openBluezAdapter(bus);
-        const canonicalScanServiceUuid = options.scanServiceUuid ? formatCanonicalUuid(options.scanServiceUuid) : null;
-        if (options.deviceName) {
-            const cachedMatches = uniqueDevices(findBluezDevices(await objectManager.GetManagedObjects(), options));
-            if (cachedMatches.length > 0) {
-                options.logger(`BlueZ found ${cachedMatches[0].name || cachedMatches[0].address || cachedMatches[0].id} in managed objects.`);
-                return cachedMatches;
-            }
+    const deviceProperties = new Map();
+    const deviceWatchers = new Map();
+    const lastManufacturerData = new Map();
+    let pollTimer = null;
+    let polling = false;
+    const processDeviceProperties = (path, properties) => {
+        const merged = { ...(deviceProperties.get(path) || {}), ...properties };
+        deviceProperties.set(path, merged);
+        const device = toDiscoveredDevice(path, merged, 'bluez');
+        onDevice?.(device);
+        for (const payload of readManufacturerData(merged.ManufacturerData)) {
+            const key = `${path}:${payload.companyId}`;
+            const hex = payload.data.toString('hex');
+            if (lastManufacturerData.get(key) === hex)
+                continue;
+            lastManufacturerData.set(key, hex);
+            const advertisedDevice = toDiscoveredDevice(path, { ...merged, ManufacturerData: new Map([[payload.companyId, payload.data]]) }, 'bluez');
+            onAdvertisement?.(advertisedDevice, payload);
         }
-        await setBluezDiscoveryFilter(adapter, Variant, canonicalScanServiceUuid, options.logger);
-        await adapter.StartDiscovery();
-        options.logger(`BlueZ discovery started. Waiting ${options.timeoutMs}ms.`);
-        const devices = [];
-        const startedAt = Date.now();
+    };
+    const watchDeviceProperties = async (path) => {
+        if (deviceWatchers.has(path))
+            return;
         try {
-            while (Date.now() - startedAt < options.timeoutMs) {
+            const object = await bus.getProxyObject(BLUEZ_SERVICE, path);
+            const properties = object.getInterface(DBUS_PROPERTIES);
+            const listener = (interfaceName, changed) => {
+                if (interfaceName === BLUEZ_DEVICE)
+                    processDeviceProperties(path, changed);
+            };
+            properties.on('PropertiesChanged', listener);
+            deviceWatchers.set(path, { properties, listener });
+        }
+        catch (error) {
+            logger(`Warning: could not watch BlueZ properties for ${path}: ${errorMessage(error)}.`);
+        }
+    };
+    const processInterfaces = (path, interfaces) => {
+        const device = interfaces[BLUEZ_DEVICE];
+        if (!device)
+            return;
+        void watchDeviceProperties(path);
+        processDeviceProperties(path, device);
+    };
+    try {
+        const { objectManager, adapter } = await openBluezAdapter(bus);
+        const onInterfacesAdded = (path, interfaces) => processInterfaces(path, interfaces);
+        objectManager.on?.('InterfacesAdded', onInterfacesAdded);
+        const pollManagedObjects = async () => {
+            if (polling)
+                return;
+            polling = true;
+            try {
                 const objects = await objectManager.GetManagedObjects();
-                devices.push(...findBluezDevices(objects, options));
-                if (options.deviceName && devices.length > 0)
-                    break;
-                await delay(DISCOVERY_POLL_MS);
+                for (const [path, interfaces] of Object.entries(objects))
+                    processInterfaces(path, interfaces);
             }
+            finally {
+                polling = false;
+            }
+        };
+        try {
+            await setBluezDiscoveryFilter(adapter, Variant, scanServiceUuid, true, logger);
+            await adapter.StartDiscovery();
+            logger(`BlueZ advertisement scan started. Listening ${timeoutMs}ms.`);
+            await pollManagedObjects();
+            pollTimer = setInterval(() => {
+                void pollManagedObjects().catch((error) => logger(`Warning: could not poll BlueZ devices: ${errorMessage(error)}.`));
+            }, DISCOVERY_POLL_MS);
+            await delay(timeoutMs);
         }
         finally {
-            await adapter.StopDiscovery().catch((error) => options.logger(`Warning: could not stop BlueZ discovery: ${errorMessage(error)}.`));
+            if (pollTimer)
+                clearInterval(pollTimer);
+            objectManager.removeListener?.('InterfacesAdded', onInterfacesAdded);
+            for (const { properties, listener } of deviceWatchers.values())
+                properties.removeListener('PropertiesChanged', listener);
+            await adapter.StopDiscovery().catch((error) => logger(`Warning: could not stop BlueZ discovery: ${errorMessage(error)}.`));
         }
-        return uniqueDevices(devices);
     }
     finally {
         bus.disconnect();
     }
 }
-async function connectBluezDevice({ device, timeoutMs, connectTimeoutMs, notifyUuid, logger }) {
-    if (process.platform !== 'linux')
-        throw new Error('BlueZ backend is only available on Linux.');
-    const { systemBus } = loadDbusNext();
-    const bus = systemBus();
-    try {
-        const objectManagerObject = await bus.getProxyObject('org.bluez', '/');
-        const objectManager = objectManagerObject.getInterface('org.freedesktop.DBus.ObjectManager');
-        let objects = await objectManager.GetManagedObjects();
-        let target = findBluezDeviceByDiscovered(objects, device);
-        if (!target) {
-            const matches = await discoverBluezDevices({
-                namePrefix: '',
-                deviceName: device.name,
-                timeoutMs,
-                scanServiceUuid: null,
-                matchServiceUuid: null,
-                logger
-            });
-            const refreshed = matches.find((match) => match.name === device.name || match.address === device.address || match.id === device.id);
-            if (!refreshed)
-                throw new Error(`Could not rediscover ${device.name || device.address || device.id}.`);
-            objects = await objectManager.GetManagedObjects();
-            target = findBluezDeviceByDiscovered(objects, refreshed);
-        }
-        if (!target)
-            throw new Error(`Could not find ${device.name || device.address || device.id} in BlueZ managed objects.`);
-        logger(`BlueZ connecting to ${target.address || '<unknown address>'} at ${target.path}.`);
-        const deviceObject = await bus.getProxyObject('org.bluez', target.path);
-        const bluezDevice = deviceObject.getInterface('org.bluez.Device1');
-        const deviceProperties = deviceObject.getInterface('org.freedesktop.DBus.Properties');
-        if (!(await getBluezBoolean(deviceProperties, 'org.bluez.Device1', 'Connected'))) {
-            await withTimeout(bluezDevice.Connect(), connectTimeoutMs, 'BlueZ Device1.Connect()');
-        }
-        await waitForBluezBooleanProperty(deviceProperties, 'org.bluez.Device1', 'ServicesResolved', true, timeoutMs);
-        logger('BlueZ connected and services resolved.');
-        const refreshedObjects = await objectManager.GetManagedObjects();
-        const characteristics = await buildBluezCharacteristics({ bus, objects: refreshedObjects, devicePath: target.path, notifyUuid, logger });
-        await characteristics.notify.subscribe();
-        logger(`Subscribed to BLE notification characteristic ${characteristics.notify.uuid} via BlueZ.`);
-        const session = {
-            device: toDiscoveredDevice(target.path, refreshedObjects[target.path]?.['org.bluez.Device1'] || {}, 'bluez'),
-            notify: characteristics.notify,
-            disconnect: async () => {
-                activeSessions.delete(session);
-                await bluezDevice.Disconnect().catch(() => { });
-                bus.disconnect();
-            }
-        };
-        activeSessions.add(session);
-        return session;
-    }
-    catch (error) {
-        bus.disconnect();
-        throw error;
-    }
-}
 async function openBluezAdapter(bus) {
-    const objectManagerObject = await bus.getProxyObject('org.bluez', '/');
-    const objectManager = objectManagerObject.getInterface('org.freedesktop.DBus.ObjectManager');
+    const objectManagerObject = await bus.getProxyObject(BLUEZ_SERVICE, '/');
+    const objectManager = objectManagerObject.getInterface(DBUS_OBJECT_MANAGER);
     const objects = await objectManager.GetManagedObjects();
     const adapterPath = findBluezAdapterPath(objects);
     if (!adapterPath)
         throw new Error('Could not find a BlueZ adapter via org.bluez ObjectManager.');
-    const adapterObject = await bus.getProxyObject('org.bluez', adapterPath);
-    const adapter = adapterObject.getInterface('org.bluez.Adapter1');
+    const adapterObject = await bus.getProxyObject(BLUEZ_SERVICE, adapterPath);
+    const adapter = adapterObject.getInterface(BLUEZ_ADAPTER);
     return { objectManager, adapter, adapterPath };
 }
-async function buildBluezCharacteristics({ bus, objects, devicePath, notifyUuid, logger }) {
-    const byUuid = new Map();
-    for (const [path, interfaces] of Object.entries(objects)) {
-        if (!path.startsWith(`${devicePath}/`))
-            continue;
-        const characteristic = interfaces['org.bluez.GattCharacteristic1'];
-        if (!characteristic)
-            continue;
-        const uuid = nullableString(unboxBluezValue(characteristic.UUID));
-        if (!uuid)
-            continue;
-        byUuid.set(normalizeUuid(uuid), { path, properties: characteristic });
-    }
-    logger(`BlueZ discovered ${byUuid.size} GATT characteristic(s): ${[...byUuid.keys()].sort().join(', ')}.`);
-    const notify = byUuid.get(normalizeUuid(notifyUuid));
-    if (!notify) {
-        throw new Error(`Missing BLE notify characteristic ${notifyUuid} via BlueZ. Found: ${[...byUuid.keys()].sort().join(', ')}`);
-    }
-    return {
-        notify: await wrapBluezCharacteristic(bus, notify.path, notify.properties)
-    };
-}
-async function wrapBluezCharacteristic(bus, path, initialProperties) {
-    const object = await bus.getProxyObject('org.bluez', path);
-    const characteristic = object.getInterface('org.bluez.GattCharacteristic1');
-    const properties = object.getInterface('org.freedesktop.DBus.Properties');
-    const listeners = new Set();
-    const flags = Array.isArray(unboxBluezValue(initialProperties.Flags)) ? unboxBluezValue(initialProperties.Flags).map(String) : [];
-    let writeQueue = Promise.resolve();
-    const onPropertiesChanged = (interfaceName, changed) => {
-        if (interfaceName !== 'org.bluez.GattCharacteristic1' || !('Value' in changed))
-            return;
-        const value = Buffer.from(unboxBluezValue(changed.Value) || []);
-        for (const listener of listeners)
-            listener(value);
-    };
-    properties.on('PropertiesChanged', onPropertiesChanged);
-    return {
-        uuid: normalizeUuid(String(unboxBluezValue(initialProperties.UUID) || '')),
-        properties: flags,
-        async write(data, withoutResponse = false) {
-            const options = withoutResponse ? { type: new (loadDbusNext().Variant)('s', 'command') } : {};
-            writeQueue = writeQueue.then(() => writeBluezValueWithRetry(characteristic, [...data], options));
-            await writeQueue;
-        },
-        async subscribe() {
-            await characteristic.StartNotify();
-        },
-        onData(listener) {
-            listeners.add(listener);
-        },
-        removeDataListener(listener) {
-            listeners.delete(listener);
-        }
-    };
-}
 function findBluezAdapterPath(objects) {
     for (const [path, interfaces] of Object.entries(objects)) {
-        if (interfaces['org.bluez.Adapter1'])
+        if (interfaces[BLUEZ_ADAPTER])
             return path;
     }
     return null;
 }
-function findBluezDevices(objects, options) {
-    const devices = [];
-    for (const [path, interfaces] of Object.entries(objects)) {
-        const device = interfaces['org.bluez.Device1'];
-        if (!device)
-            continue;
-        const uuids = readBluezUuids(device);
-        const discovered = toDiscoveredDevice(path, device, 'bluez');
-        if (matchesBleDevice({ name: discovered.name, address: discovered.address, serviceUuids: uuids }, { namePrefix: options.namePrefix, deviceName: options.deviceName, serviceUuid: options.matchServiceUuid })) {
-            devices.push(discovered);
-        }
-    }
-    return devices;
-}
-function findBluezDeviceByDiscovered(objects, selected) {
-    for (const [path, interfaces] of Object.entries(objects)) {
-        const device = interfaces['org.bluez.Device1'];
-        if (!device)
-            continue;
-        const discovered = toDiscoveredDevice(path, device, 'bluez');
-        if (selected.id === path || (!!selected.name && selected.name === discovered.name) || (!!selected.address && selected.address.toUpperCase() === discovered.address?.toUpperCase())) {
-            return { path, address: discovered.address };
-        }
-    }
-    return null;
+function matchesDiscoveredDevice(device, options) {
+    return matchesBleDevice({ name: device.name, address: device.address, serviceUuids: device.serviceUuids }, { namePrefix: options.namePrefix, deviceName: options.deviceName, serviceUuid: options.matchServiceUuid });
 }
 function toDiscoveredDevice(path, device, backend) {
     return {
         id: path,
         address: nullableString(unboxBluezValue(device.Address)),
-        addressType: null,
+        addressType: nullableString(unboxBluezValue(device.AddressType)),
         name: nullableString(unboxBluezValue(device.Name)) || nullableString(unboxBluezValue(device.Alias)),
         rssi: nullableNumber(unboxBluezValue(device.RSSI)),
+        serviceUuids: readBluezUuids(device),
+        manufacturerData: readManufacturerData(device.ManufacturerData).map((payload) => createManufacturerData(payload.companyId, payload.data)),
         backend
     };
 }
@@ -241,70 +190,45 @@ function readBluezUuids(device) {
     const value = unboxBluezValue(device.UUIDs);
     return Array.isArray(value) ? value.map((uuid) => String(uuid)) : [];
 }
-export async function setBluezDiscoveryFilter(adapter, Variant, serviceUuid, logger) {
+function readManufacturerData(value) {
+    const data = unboxBluezValue(value);
+    if (!data || typeof data !== 'object')
+        return [];
+    const entries = data instanceof Map ? Array.from(data.entries()) : Object.entries(data);
+    const payloads = [];
+    for (const [companyId, bytes] of entries) {
+        const buffer = bytesToBuffer(bytes);
+        if (buffer && buffer.length > 0)
+            payloads.push({ companyId: String(companyId), data: buffer });
+    }
+    return payloads;
+}
+function bytesToBuffer(value) {
+    const unboxed = unboxBluezValue(value);
+    if (Buffer.isBuffer(unboxed))
+        return unboxed;
+    if (unboxed instanceof Uint8Array)
+        return Buffer.from(unboxed);
+    if (Array.isArray(unboxed) && unboxed.every((byte) => typeof byte === 'number'))
+        return Buffer.from(unboxed);
+    return null;
+}
+export async function setBluezDiscoveryFilter(adapter, Variant, serviceUuid, duplicateData, logger) {
     const filter = {
         Transport: new Variant('s', 'le'),
-        DuplicateData: new Variant('b', false)
+        DuplicateData: new Variant('b', duplicateData)
     };
     if (serviceUuid)
-        filter.UUIDs = new Variant('as', [serviceUuid]);
-    const names = ['transport', 'duplicates'];
+        filter.UUIDs = new Variant('as', [formatCanonicalUuid(serviceUuid)]);
+    const names = ['transport', duplicateData ? 'duplicate advertisement data' : 'deduplicated advertisement data'];
     if (serviceUuid)
-        names.push('service UUID');
+        names.push(`service UUID ${normalizeUuid(serviceUuid)}`);
     await adapter.SetDiscoveryFilter(filter)
         .then(() => logger(`BlueZ discovery filter applied: ${names.join(', ')}.`))
         .catch((error) => logger(`Warning: could not set BlueZ discovery filter (${names.join(', ')}): ${errorMessage(error)}.`));
 }
-async function getBluezBoolean(properties, interfaceName, propertyName) {
-    const value = await properties.Get(interfaceName, propertyName).catch(() => null);
-    const unboxed = unboxBluezValue(value);
-    return typeof unboxed === 'boolean' ? unboxed : null;
-}
-async function waitForBluezBooleanProperty(properties, interfaceName, propertyName, expected, timeoutMs) {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < timeoutMs) {
-        if ((await getBluezBoolean(properties, interfaceName, propertyName)) === expected)
-            return;
-        await delay(250);
-    }
-    throw new Error(`Timed out after ${timeoutMs}ms waiting for BlueZ ${propertyName}=${expected}.`);
-}
-async function writeBluezValueWithRetry(characteristic, value, options) {
-    let lastError;
-    for (let attempt = 0; attempt < 12; attempt += 1) {
-        try {
-            await characteristic.WriteValue(value, options);
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (!isBluezInProgressError(error))
-                throw error;
-            await delay(80);
-        }
-    }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
-}
-function isBluezInProgressError(error) {
-    const message = errorMessage(error).toLowerCase();
-    return message.includes('in progress') || message.includes('inprogress');
-}
-function withTimeout(promise, timeoutMs, label) {
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms during ${label}.`)), timeoutMs);
-        promise.then((value) => {
-            clearTimeout(timeout);
-            resolve(value);
-        }, (error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-    });
-}
-async function shutdownBluez() {
-    const sessions = [...activeSessions];
-    activeSessions = new Set();
-    await Promise.all(sessions.map((session) => session.disconnect().catch(() => { })));
+function deviceKey(device) {
+    return device.address?.toLowerCase() || device.name || `${device.backend}:${device.id}`;
 }
 function loadDbusNext() {
     try {