@tempivo/sensor-beacon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tempivo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+# @tempivo/sensor-beacon
+
+Decode **Tempivo sensor** BLE **manufacturer data** (company id **0x026C**). Use this in partner apps, gateways, or Node scripts that scan advertisements. **No GATT connection** is required.
+
+## Install
+
+```bash
+npm install @tempivo/sensor-beacon
+```
+
+Node.js 18+.
+
+## Quick start
+
+Many platforms return manufacturer bytes **without** the 2-byte company id (`6C 02`). If your stack includes the id, strip it first:
+
+```ts
+import {
+  TEMPVO_SENSOR_MANUFACTURER_ID,
+  normalizeManufacturerBytes,
+  decodeSensorBeaconPayload,
+} from '@tempivo/sensor-beacon';
+
+// Web Bluetooth: manufacturerData.get(0x026C) → DataView
+const payload = normalizeManufacturerBytes(manufacturerDataView);
+const reading = decodeSensorBeaconPayload(payload);
+if (reading) {
+  console.log(reading.serialMac, reading.firmware, reading.temperatures);
+}
+```
+
+`TEMPVO_SENSOR_MANUFACTURER_ID` is `0x026c` (same id on air as little-endian `6C 02`).
+
+## Advertising-only workflow
+
+1. Scan BLE advertisements (no connect).
+2. Read manufacturer specific data for **0x026C**.
+3. Call `normalizeManufacturerBytes` then `decodeSensorBeaconPayload`, or cache frames with `ingestManufacturerPayload` and merge with `buildSensorBeaconReading`.
+
+FW6 devices split data across:
+
+- **`0x03` frame** (22 bytes): serial/MAC, firmware, battery, period, timestamp.
+- **`0x04` frame** (scan response): measurement slots (temperature, humidity, CO₂, etc.).
+
+You may receive `0x03` and `0x04` in separate packets. Use `SensorBeaconFrameCache` to merge by device key:
+
+```ts
+import {
+  createSensorBeaconFrameCache,
+  ingestManufacturerPayload,
+  buildSensorBeaconReading,
+  macKeyFromAddress,
+} from '@tempivo/sensor-beacon';
+
+const cache = createSensorBeaconFrameCache();
+const macKey = macKeyFromAddress('28:2C:02:4F:00:12');
+
+ingestManufacturerPayload(advPayload, macKey, cache);
+ingestManufacturerPayload(scanPayload, macKey, cache);
+
+const reading = buildSensorBeaconReading(
+  cache.last03.get(macKey),
+  cache.last04.get(macKey)
+);
+```
+
+## API
+
+| Export | Purpose |
+|--------|---------|
+| `TEMPVO_SENSOR_MANUFACTURER_ID` | BLE company id `0x026c` |
+| `normalizeManufacturerBytes` | Strip company id prefix when present |
+| `decodeSensorBeaconPayload` | One-shot decode of payload bytes |
+| `ingestManufacturerPayload` | Update frame cache from one advertisement |
+| `buildSensorBeaconReading` | Merge cached `0x03` / `0x04` frames |
+| `SensorBeaconReading` | Parsed device + measurements |
+| `SensorBeaconMeasurement` | One slot in `0x04` scan data |
+| `SensorBeaconFrameCache` | Per-device last `0x03` / `0x04` frames |
+
+Measurement types **0x01–0x22** (temperature, humidity, pressure, IAQ, CO₂, PM, etc.) are decoded to human-readable `text` on each `SensorBeaconMeasurement`.
+
+## Tempivo app integration
+
+The Tempivo web app uses the same broadcast format for live debug scans. This package is the supported **partner-facing** npm build of that decoder.
+
+## License
+
+MIT

package/dist/decoder.d.ts

@@ -0,0 +1,15 @@
+import type { SensorBeaconReading } from './types.js';
+export declare const TEMPVO_SENSOR_MANUFACTURER_ID = 620;
+/** FW6 `0x03` advertisement frame length (bytes after company id). */
+export declare const ADV_FRAME_03_LEN = 22;
+export declare function decodeMeasurementSlot(mtype: number, raw24: number): string;
+export declare function serialKeyFromAdv03Frame(frame: Uint8Array): string | null;
+export declare function macKeyFromAddress(macWithColons: string): string;
+export declare function lookupDeviceKeys(primaryMacKey: string, extraSerialKey?: string | null): string[];
+export declare function splitSensorBeaconFrames(payload: Uint8Array): Uint8Array[];
+/** Merge cached or inline `0x03` / `0x02` / `0x04` frames into one reading. */
+export declare function buildSensorBeaconReading(adv03: Uint8Array | null | undefined, adv04: Uint8Array | null | undefined, rawHex?: string): SensorBeaconReading | null;
+/** One-shot decode of manufacturer payload (after company id strip). */
+export declare function decodeSensorBeaconPayload(data: Uint8Array): SensorBeaconReading | null;
+/** FW 7+ → modern (`false`); FW 6-/5.x → legacy (`true`). */
+export declare function legacyHintFromFirmware(firmware: string | null | undefined): boolean | null;

package/dist/decoder.js

@@ -0,0 +1,333 @@
+import { MEASURE_SPECS } from './measure-specs.js';
+export const TEMPVO_SENSOR_MANUFACTURER_ID = 0x026c;
+/** FW6 `0x03` advertisement frame length (bytes after company id). */
+export const ADV_FRAME_03_LEN = 22;
+const CELL_LABELS = ['ble_only', 'cell_ok', 'no_server', 'net_issue'];
+function u8(b, i) {
+    return b[i] & 0xff;
+}
+function u16be(b, o) {
+    return (u8(b, o) << 8) | u8(b, o + 1);
+}
+function zigzagDecode24(raw24) {
+    const n = raw24 & 0xffffff;
+    return (n >> 1) ^ (-(n & 1));
+}
+function formatNum(v, mtype) {
+    if (Math.abs(v - Math.floor(v)) < 1e-6) {
+        return String(Math.round(v));
+    }
+    if (mtype === 0x01 || mtype === 0x03 || mtype === 0x0f || mtype === 0x13) {
+        return v.toFixed(1);
+    }
+    if (mtype === 0x02 || mtype === 0x1b) {
+        return String(Math.round(v));
+    }
+    return String(v);
+}
+function unitForType(mtype) {
+    switch (mtype) {
+        case 0x01:
+            return '°C';
+        case 0x02:
+        case 0x1b:
+            return '%';
+        case 0x03:
+            return 'hPa';
+        case 0x1a:
+            return 'ppm';
+        case 0x21:
+            return 'mV';
+        case 0x22:
+            return 'mA';
+        default:
+            return '';
+    }
+}
+export function decodeMeasurementSlot(mtype, raw24) {
+    const spec = MEASURE_SPECS.get(mtype);
+    if (!spec) {
+        return `0x${mtype.toString(16).padStart(2, '0').toUpperCase()}: raw 0x${(raw24 & 0xffffff).toString(16).padStart(6, '0')}`;
+    }
+    if (!spec.continuous) {
+        return `${spec.name}: (binary / status)`;
+    }
+    const z = zigzagDecode24(raw24);
+    if (spec.metaFactor === 1) {
+        const v = z * spec.resolution;
+        const unit = unitForType(mtype);
+        const num = formatNum(v, mtype);
+        return unit ? `${spec.name} ${num} ${unit}` : `${spec.name} ${num}`;
+    }
+    if (mtype === 0x06) {
+        const iaq = z % (1 << 9);
+        const cal = (z >> 9) & 0x03;
+        const calS = ['not_stab', 'cal_req', 'cal_ongoing', 'cal_done'][Math.min(cal, 3)];
+        return `${spec.name} ${iaq} (${calS})`;
+    }
+    if (mtype === 0x1a || mtype === 0x1c || mtype === 0x1d || mtype === 0x1e) {
+        const v = (z / spec.metaFactor) * spec.resolution;
+        return `${spec.name} ${v}`;
+    }
+    return `${spec.name} z=${z}`;
+}
+function parsedValuesFromSlot(mtype, raw24) {
+    const spec = MEASURE_SPECS.get(mtype);
+    if (!spec?.continuous || spec.metaFactor !== 1)
+        return {};
+    const z = zigzagDecode24(raw24);
+    const v = z * spec.resolution;
+    if (mtype === 0x01)
+        return { temperatureC: v };
+    if (mtype === 0x02 || mtype === 0x1b)
+        return { humidityPct: v };
+    return {};
+}
+export function serialKeyFromAdv03Frame(frame) {
+    if (frame.length < 7 || u8(frame, 0) !== 0x03)
+        return null;
+    let s = '';
+    for (let i = 1; i <= 6; i++) {
+        s += u8(frame, i).toString(16).padStart(2, '0').toUpperCase();
+    }
+    return s;
+}
+export function macKeyFromAddress(macWithColons) {
+    return macWithColons.replace(/:/gi, '').toUpperCase();
+}
+export function lookupDeviceKeys(primaryMacKey, extraSerialKey) {
+    const keys = new Set([primaryMacKey.toUpperCase()]);
+    if (extraSerialKey?.trim())
+        keys.add(extraSerialKey.toUpperCase());
+    return [...keys];
+}
+export function splitSensorBeaconFrames(payload) {
+    const out = [];
+    let i = 0;
+    const n = payload.length;
+    while (i < n) {
+        const b = u8(payload, i);
+        if (b === 0x03 && i + ADV_FRAME_03_LEN <= n) {
+            out.push(payload.subarray(i, i + ADV_FRAME_03_LEN));
+            i += ADV_FRAME_03_LEN;
+        }
+        else if (b === 0x04) {
+            let j = i + 1;
+            while (j + 4 <= n) {
+                if (j + 4 > n - 2)
+                    break;
+                const mtype = u8(payload, j);
+                if (mtype === 0 || mtype > 0x26)
+                    break;
+                j += 4;
+            }
+            if (n - j >= 2) {
+                out.push(payload.subarray(i, j + 2));
+                i = j + 2;
+            }
+            else {
+                out.push(payload.subarray(i));
+                break;
+            }
+        }
+        else if (b === 0x02 && i + 3 <= n) {
+            const end = Math.min(n, i + 26);
+            out.push(payload.subarray(i, end));
+            i = end;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return out;
+}
+function fw5Summary(frame) {
+    if (frame.length === 0 || u8(frame, 0) !== 0x02)
+        return null;
+    const maj = frame.length > 1 ? u8(frame, 1) : null;
+    const min = frame.length > 2 ? u8(frame, 2) : null;
+    if (maj == null || min == null)
+        return null;
+    return `FW 5.x ${maj}.${min} (limited broadcast decode)`;
+}
+function serialMacFromAdv03(frame) {
+    return Array.from(frame.subarray(1, 7))
+        .map((x) => (x & 0xff).toString(16).padStart(2, '0').toUpperCase())
+        .join(':');
+}
+function parseFw6Adv03(frame) {
+    if (frame.length < ADV_FRAME_03_LEN)
+        return {};
+    const fwRaw = u16be(frame, 7);
+    const major = (fwRaw >> 11) & 0x1f;
+    const minor = (fwRaw >> 5) & 0x3f;
+    const lts = fwRaw & 0x1f;
+    const st = u8(frame, 9);
+    const cell = (st >> 6) & 3;
+    const ts = (u8(frame, 10) << 24) |
+        (u8(frame, 11) << 16) |
+        (u8(frame, 12) << 8) |
+        u8(frame, 13);
+    const pbase = u16be(frame, 14);
+    const pfact = u16be(frame, 16);
+    let readingTimestampIso = null;
+    if (ts > 1_000_000_000 && ts < 4_000_000_000) {
+        readingTimestampIso = new Date(ts * 1000).toISOString();
+    }
+    return {
+        serialMac: serialMacFromAdv03(frame),
+        firmware: `${major}.${minor}.${lts}`,
+        batteryOk: (st & 1) !== 0,
+        encryptionEnabled: ((st >> 3) & 1) !== 0,
+        cellularStatus: CELL_LABELS[cell] ?? String(cell),
+        measurementCounter: ts >>> 0,
+        readingTimestampUnix: ts,
+        readingTimestampIso,
+        periodBaseSeconds: pbase,
+        periodFactor: pfact,
+        periodLabel: `${pbase}s × ${pfact}`,
+    };
+}
+function parseScan04(frame) {
+    const measurements = [];
+    const summaryParts = [];
+    if (frame.length < 5 || u8(frame, 0) !== 0x04) {
+        return { measurements, summaryParts };
+    }
+    let i = 1;
+    while (i + 4 <= frame.length - 2) {
+        const mtype = u8(frame, i);
+        if (mtype === 0)
+            break;
+        const raw24 = (u8(frame, i + 1) << 16) | (u8(frame, i + 2) << 8) | u8(frame, i + 3);
+        const text = decodeMeasurementSlot(mtype, raw24);
+        summaryParts.push(text);
+        measurements.push({
+            typeId: mtype,
+            typeHex: `0x${mtype.toString(16).padStart(2, '0').toUpperCase()}`,
+            raw24: raw24 & 0xffffff,
+            text,
+            ...parsedValuesFromSlot(mtype, raw24),
+        });
+        i += 4;
+    }
+    return { measurements, summaryParts };
+}
+function bufferToHex(b) {
+    return Array.from(b)
+        .map((x) => (x & 0xff).toString(16).padStart(2, '0'))
+        .join('');
+}
+/** Merge cached or inline `0x03` / `0x02` / `0x04` frames into one reading. */
+export function buildSensorBeaconReading(adv03, adv04, rawHex = '') {
+    const summaryParts = [];
+    let base = {
+        serialMac: '',
+        firmware: '',
+        batteryOk: false,
+        encryptionEnabled: false,
+        cellularStatus: '',
+        measurementCounter: null,
+        readingTimestampUnix: null,
+        readingTimestampIso: null,
+        periodBaseSeconds: null,
+        periodFactor: null,
+        periodLabel: '',
+    };
+    if (adv03?.length) {
+        const tag = u8(adv03, 0);
+        if (tag === 0x03) {
+            base = { ...base, ...parseFw6Adv03(adv03) };
+        }
+        else if (tag === 0x02) {
+            const fw5 = fw5Summary(adv03);
+            if (fw5) {
+                base.firmware = fw5;
+                summaryParts.push(fw5);
+            }
+        }
+    }
+    const { measurements, summaryParts: scanParts } = parseScan04(adv04 ?? new Uint8Array(0));
+    summaryParts.push(...scanParts);
+    const temperatures = [];
+    let humidity = null;
+    for (const m of measurements) {
+        if (m.temperatureC !== undefined)
+            temperatures.push(m.temperatureC);
+        if (m.humidityPct !== undefined && humidity === null)
+            humidity = m.humidityPct;
+    }
+    let summary = '';
+    if (summaryParts.length === 0) {
+        if (adv03?.length && u8(adv03, 0) === 0x03) {
+            summary =
+                base.readingTimestampIso ??
+                    'Adv OK. Wait for scan response (measurements).';
+        }
+    }
+    else {
+        summary = summaryParts.slice(0, 4).join(' · ');
+    }
+    if (!summary && adv03 == null && adv04 == null)
+        return null;
+    const sumOut = summary || base.readingTimestampIso || '';
+    if (!base.serialMac && measurements.length === 0 && !base.firmware)
+        return null;
+    return {
+        serialMac: base.serialMac || '—',
+        firmware: base.firmware || '—',
+        batteryOk: base.batteryOk ?? false,
+        encryptionEnabled: base.encryptionEnabled ?? false,
+        cellularStatus: base.cellularStatus || '',
+        measurementCounter: base.measurementCounter ?? null,
+        readingTimestampUnix: base.readingTimestampUnix ?? null,
+        readingTimestampIso: base.readingTimestampIso ?? null,
+        periodBaseSeconds: base.periodBaseSeconds ?? null,
+        periodFactor: base.periodFactor ?? null,
+        periodLabel: base.periodLabel || '—',
+        measurements,
+        summary: sumOut,
+        temperatures,
+        humidity,
+        rawHex,
+    };
+}
+/** One-shot decode of manufacturer payload (after company id strip). */
+export function decodeSensorBeaconPayload(data) {
+    if (data.length < 3)
+        return null;
+    const frames = splitSensorBeaconFrames(data);
+    if (frames.length === 0)
+        return null;
+    let adv03;
+    let adv04;
+    let adv02;
+    for (const fr of frames) {
+        const tag = u8(fr, 0);
+        if (tag === 0x03 && fr.length >= ADV_FRAME_03_LEN)
+            adv03 = fr;
+        else if (tag === 0x04)
+            adv04 = fr;
+        else if (tag === 0x02)
+            adv02 = fr;
+    }
+    const merged03 = adv03 ?? adv02;
+    return buildSensorBeaconReading(merged03, adv04, bufferToHex(data));
+}
+/** FW 7+ → modern (`false`); FW 6-/5.x → legacy (`true`). */
+export function legacyHintFromFirmware(firmware) {
+    if (!firmware?.trim())
+        return null;
+    const t = firmware.trim();
+    if (/^FW 5/i.test(t))
+        return true;
+    const m = /^(\d+)\.\d+/.exec(t);
+    if (!m)
+        return null;
+    const major = parseInt(m[1], 10);
+    if (major >= 7)
+        return false;
+    if (major >= 1)
+        return true;
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, legacyHintFromFirmware, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ingestManufacturerPayload } from './ingest.js';
+export { dataViewToUint8Array, normalizeManufacturerBytes } from './normalize.js';
+export { MEASURE_SPECS, type MeasureSpec } from './measure-specs.js';
+export { createSensorBeaconFrameCache, type SensorBeaconFrameCache, type SensorBeaconMeasurement, type SensorBeaconReading, } from './types.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, legacyHintFromFirmware, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ingestManufacturerPayload } from './ingest.js';
+export { dataViewToUint8Array, normalizeManufacturerBytes } from './normalize.js';
+export { MEASURE_SPECS } from './measure-specs.js';
+export { createSensorBeaconFrameCache, } from './types.js';

package/dist/ingest.d.ts

@@ -0,0 +1,6 @@
+import type { SensorBeaconFrameCache } from './types.js';
+/**
+ * Store latest `0x03` / `0x02` / `0x04` frames per device key.
+ * @returns true if cache changed (UI may refresh).
+ */
+export declare function ingestManufacturerPayload(data: Uint8Array, primaryMacKey: string, cache: SensorBeaconFrameCache): boolean;

package/dist/ingest.js

@@ -0,0 +1,69 @@
+import { ADV_FRAME_03_LEN, lookupDeviceKeys, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+function framesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Store latest `0x03` / `0x02` / `0x04` frames per device key.
+ * @returns true if cache changed (UI may refresh).
+ */
+export function ingestManufacturerPayload(data, primaryMacKey, cache) {
+    let changed = false;
+    const frames = splitSensorBeaconFrames(data);
+    for (const fr of frames) {
+        if (fr.length === 0)
+            continue;
+        const tag = fr[0] & 0xff;
+        switch (tag) {
+            case 0x03: {
+                if (fr.length >= ADV_FRAME_03_LEN) {
+                    const frame = fr.subarray(0, ADV_FRAME_03_LEN);
+                    const keys = lookupDeviceKeys(primaryMacKey, serialKeyFromAdv03Frame(frame));
+                    for (const key of keys) {
+                        const prev = cache.last03.get(key);
+                        if (!prev || !framesEqual(prev, frame)) {
+                            cache.last03.set(key, frame.slice());
+                            changed = true;
+                        }
+                    }
+                }
+                break;
+            }
+            case 0x02: {
+                if (fr.length >= 3) {
+                    const keys = lookupDeviceKeys(primaryMacKey);
+                    for (const key of keys) {
+                        const existing = cache.last03.get(key);
+                        if (existing?.length && (existing[0] & 0xff) === 0x03)
+                            continue;
+                        const prev = cache.last03.get(key);
+                        if (!prev || !framesEqual(prev, fr)) {
+                            cache.last03.set(key, fr.slice());
+                            changed = true;
+                        }
+                    }
+                }
+                break;
+            }
+            case 0x04: {
+                const keys = lookupDeviceKeys(primaryMacKey);
+                for (const key of keys) {
+                    const prev = cache.last04.get(key);
+                    if (!prev || !framesEqual(prev, fr)) {
+                        cache.last04.set(key, fr.slice());
+                        changed = true;
+                    }
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return changed;
+}

package/dist/measure-specs.d.ts

@@ -0,0 +1,8 @@
+export interface MeasureSpec {
+    name: string;
+    resolution: number;
+    metaFactor: number;
+    continuous: boolean;
+}
+/** FW6 scan-response measurement types 0x01–0x22 (per Tempivo sensor broadcast spec). */
+export declare const MEASURE_SPECS: ReadonlyMap<number, MeasureSpec>;

package/dist/measure-specs.js

@@ -0,0 +1,34 @@
+/** FW6 scan-response measurement types 0x01–0x22 (per Tempivo sensor broadcast spec). */
+export const MEASURE_SPECS = new Map([
+    [0x01, { name: 'Temperature', resolution: 0.1, metaFactor: 1, continuous: true }],
+    [0x02, { name: 'Humidity', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x03, { name: 'Atmospheric pressure', resolution: 0.1, metaFactor: 1, continuous: true }],
+    [0x04, { name: 'Differential pressure', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x05, { name: 'OK/Alarm', resolution: 1.0, metaFactor: 1, continuous: false }],
+    [0x06, { name: 'IAQ', resolution: 1.0, metaFactor: 3, continuous: true }],
+    [0x07, { name: 'Flooding', resolution: 1.0, metaFactor: 1, continuous: false }],
+    [0x08, { name: 'Pulse count', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x09, { name: 'Electricity meter', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x0a, { name: 'Water meter', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x0b, { name: 'Soil moisture', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x0c, { name: 'CO', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x0d, { name: 'NO₂', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x0e, { name: 'H₂S', resolution: 0.01, metaFactor: 1, continuous: true }],
+    [0x0f, { name: 'Ambient light', resolution: 0.1, metaFactor: 1, continuous: true }],
+    [0x10, { name: 'PM1.0', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x11, { name: 'PM2.5', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x12, { name: 'PM10', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x13, { name: 'Noise', resolution: 0.1, metaFactor: 1, continuous: true }],
+    [0x14, { name: 'NH₃', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x15, { name: 'CH₄', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x16, { name: 'High pressure', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x17, { name: 'Distance', resolution: 1.0, metaFactor: 1, continuous: true }],
+    [0x1a, { name: 'CO₂', resolution: 1.0, metaFactor: 3, continuous: true }],
+    [0x1b, { name: 'Humidity', resolution: 0.1, metaFactor: 1, continuous: true }],
+    [0x1c, { name: 'Static IAQ', resolution: 1.0, metaFactor: 3, continuous: true }],
+    [0x1d, { name: 'CO₂ equivalent', resolution: 1.0, metaFactor: 3, continuous: true }],
+    [0x1e, { name: 'Breath VOC', resolution: 1.0, metaFactor: 3, continuous: true }],
+    [0x20, { name: 'Percentage', resolution: 0.01, metaFactor: 1, continuous: true }],
+    [0x21, { name: 'Voltage', resolution: 0.1, metaFactor: 1, continuous: true }],
+    [0x22, { name: 'Current', resolution: 0.01, metaFactor: 1, continuous: true }],
+]);

package/dist/normalize.d.ts

@@ -0,0 +1,6 @@
+export declare function dataViewToUint8Array(dv: DataView): Uint8Array;
+/**
+ * Strip BLE company id (0x6C 0x02 little-endian for 0x026C) when present.
+ * Web Bluetooth and Android often already return payload **without** the prefix.
+ */
+export declare function normalizeManufacturerBytes(data: Uint8Array | DataView | ArrayBuffer): Uint8Array;

package/dist/normalize.js

@@ -0,0 +1,30 @@
+import { TEMPVO_SENSOR_MANUFACTURER_ID } from './decoder.js';
+export function dataViewToUint8Array(dv) {
+    return new Uint8Array(dv.buffer, dv.byteOffset, dv.byteLength);
+}
+/**
+ * Strip BLE company id (0x6C 0x02 little-endian for 0x026C) when present.
+ * Web Bluetooth and Android often already return payload **without** the prefix.
+ */
+export function normalizeManufacturerBytes(data) {
+    let bytes;
+    if (data instanceof ArrayBuffer) {
+        bytes = new Uint8Array(data);
+    }
+    else if (data instanceof DataView) {
+        bytes = dataViewToUint8Array(data);
+    }
+    else {
+        bytes = data;
+    }
+    if (bytes.length >= 2 && bytes[0] === 0x6c && bytes[1] === 0x02) {
+        return bytes.subarray(2);
+    }
+    if (bytes.length >= 2) {
+        const id = bytes[0] | (bytes[1] << 8);
+        if (id === TEMPVO_SENSOR_MANUFACTURER_ID) {
+            return bytes.subarray(2);
+        }
+    }
+    return bytes;
+}

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+export interface SensorBeaconMeasurement {
+    typeId: number;
+    typeHex: string;
+    raw24: number;
+    text: string;
+    temperatureC?: number;
+    humidityPct?: number;
+}
+export interface SensorBeaconReading {
+    serialMac: string;
+    firmware: string;
+    batteryOk: boolean;
+    encryptionEnabled: boolean;
+    cellularStatus: string;
+    measurementCounter: number | null;
+    readingTimestampUnix: number | null;
+    readingTimestampIso: string | null;
+    periodBaseSeconds: number | null;
+    periodFactor: number | null;
+    periodLabel: string;
+    measurements: SensorBeaconMeasurement[];
+    summary: string;
+    temperatures: number[];
+    humidity: number | null;
+    rawHex: string;
+}
+export interface SensorBeaconFrameCache {
+    last03: Map<string, Uint8Array>;
+    last04: Map<string, Uint8Array>;
+}
+export declare function createSensorBeaconFrameCache(): SensorBeaconFrameCache;

package/dist/types.js

@@ -0,0 +1,3 @@
+export function createSensorBeaconFrameCache() {
+    return { last03: new Map(), last04: new Map() };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@tempivo/sensor-beacon",
+  "version": "0.1.0",
+  "description": "Decode Tempivo sensor BLE manufacturer advertisements (0x026C). Advertising only, no GATT connect. For integrators and custom apps.",
+  "homepage": "https://app.tempivo.com/integrations",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config jest.config.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "tempivo",
+    "ble",
+    "bluetooth",
+    "beacon",
+    "sensor",
+    "manufacturer-data"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^6.0.2"
+  }
+}