@wodzik/cubecore 0.1.0

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/default-optional-services.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Consolidated GATT service UUIDs for pairing so the OS grants access across vendors.
+ */
+export declare const DEVICE_INFORMATION_SERVICE: string;
+export declare const GENERIC_ACCESS_SERVICE: string;
+/** QiYi primary (16-bit FFF0). */
+export declare const QIYI_LIKE_FFF0: string;
+/** MoYu plain (MHC). */
+export declare const MOYU_PLAIN_SERVICE: string;
+/** MoYu32 / WCU. */
+export declare const MOYU32_SERVICE = "0783b03e-7735-b5a0-1760-a305d2795cb0";
+/** Giiker. */
+export declare const GIIKER_DATA_SERVICE: string;
+export declare const GIIKER_CTRL_SERVICE: string;
+/** GoCube UART. */
+export declare const GOCUBE_UART_SERVICE = "6e400001-b5a3-f393-e0a9-e50e24dcca9e";
+/**
+ * Union of services commonly needed when connecting smart cubes via Web Bluetooth.
+ */
+export declare const DEFAULT_SMARTCUBE_OPTIONAL_SERVICES: readonly string[];
+export declare function mergeOptionalServiceUuids(protocolServices: Iterable<string>): string[];

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/default-optional-services.js

@@ -0,0 +1,47 @@
+/**
+ * Consolidated GATT service UUIDs for pairing so the OS grants access across vendors.
+ */
+import * as gan from '../../gan-cube-definitions.js';
+const S = '-0000-1000-8000-00805f9b34fb';
+export const DEVICE_INFORMATION_SERVICE = '0000180a' + S;
+export const GENERIC_ACCESS_SERVICE = '00001800' + S;
+/** QiYi primary (16-bit FFF0). */
+export const QIYI_LIKE_FFF0 = '0000fff0' + S;
+/** MoYu plain (MHC). */
+export const MOYU_PLAIN_SERVICE = '00001000' + S;
+/** MoYu32 / WCU. */
+export const MOYU32_SERVICE = '0783b03e-7735-b5a0-1760-a305d2795cb0';
+/** Giiker. */
+export const GIIKER_DATA_SERVICE = '0000aadb' + S;
+export const GIIKER_CTRL_SERVICE = '0000aaaa' + S;
+/** GoCube UART. */
+export const GOCUBE_UART_SERVICE = '6e400001-b5a3-f393-e0a9-e50e24dcca9e';
+/**
+ * Union of services commonly needed when connecting smart cubes via Web Bluetooth.
+ */
+export const DEFAULT_SMARTCUBE_OPTIONAL_SERVICES = [
+    GENERIC_ACCESS_SERVICE,
+    DEVICE_INFORMATION_SERVICE,
+    gan.GAN_GEN2_SERVICE,
+    gan.GAN_GEN2_COMMAND_CHARACTERISTIC,
+    gan.GAN_GEN2_STATE_CHARACTERISTIC,
+    gan.GAN_GEN3_SERVICE,
+    gan.GAN_GEN3_COMMAND_CHARACTERISTIC,
+    gan.GAN_GEN3_STATE_CHARACTERISTIC,
+    gan.GAN_GEN4_SERVICE,
+    gan.GAN_GEN4_COMMAND_CHARACTERISTIC,
+    gan.GAN_GEN4_STATE_CHARACTERISTIC,
+    QIYI_LIKE_FFF0,
+    MOYU_PLAIN_SERVICE,
+    MOYU32_SERVICE,
+    GIIKER_DATA_SERVICE,
+    GIIKER_CTRL_SERVICE,
+    GOCUBE_UART_SERVICE,
+];
+export function mergeOptionalServiceUuids(protocolServices) {
+    const u = new Set(DEFAULT_SMARTCUBE_OPTIONAL_SERVICES);
+    for (const s of protocolServices) {
+        u.add(s);
+    }
+    return Array.from(u);
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/device-name-scan-filters.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="web-bluetooth" />
+/**
+ * Extra Web Bluetooth scan filters when reconnecting with a known advertised name.
+ */
+/** Wildcard-style names some stacks use for GAN advertising aliases. */
+export declare function extraScanFiltersForKnownDeviceName(deviceName: string | undefined): BluetoothLEScanFilter[];

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/device-name-scan-filters.js

@@ -0,0 +1,24 @@
+/**
+ * Extra Web Bluetooth scan filters when reconnecting with a known advertised name.
+ */
+/** Wildcard-style names some stacks use for GAN advertising aliases. */
+export function extraScanFiltersForKnownDeviceName(deviceName) {
+    if (!deviceName) {
+        return [];
+    }
+    const n = deviceName.trim();
+    if (!n) {
+        return [];
+    }
+    const out = [{ name: n }];
+    if (n.startsWith('GANic')) {
+        out.push({ name: 'GANicXXX' });
+    }
+    if (n.startsWith('GANi3')) {
+        out.push({ name: 'GANi3XXX' });
+    }
+    if (n.startsWith('AiCube')) {
+        out.push({ name: 'AiCubeXXX' });
+    }
+    return out;
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/gatt-snapshot.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="web-bluetooth" />
+/**
+ * Connect GATT (if needed) and return normalized primary service UUIDs.
+ * Uses a connect timeout and limited retries on transient failures.
+ */
+export declare function collectPrimaryServiceUuids(device: BluetoothDevice): Promise<ReadonlySet<string>>;

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/gatt-snapshot.js

@@ -0,0 +1,57 @@
+import { normalizeUuid } from './normalize-uuid.js';
+const GATT_CONNECT_TIMEOUT_MS = 25_000;
+const GATT_RETRY_MAX = 2;
+const GATT_RETRY_BASE_DELAY_MS = 150;
+function disconnectGattSafe(gatt) {
+    return Promise.resolve(gatt.disconnect()).catch(() => { });
+}
+async function delay(ms) {
+    await new Promise((r) => setTimeout(r, ms));
+}
+async function connectGattWithTimeout(gatt, timeoutMs) {
+    const sym = Symbol('gattTimeout');
+    try {
+        await Promise.race([
+            gatt.connect(),
+            new Promise((_, rej) => setTimeout(() => rej(sym), timeoutMs)),
+        ]);
+    }
+    catch (e) {
+        if (e === sym) {
+            await disconnectGattSafe(gatt);
+            throw new Error('GATT connection timeout');
+        }
+        await disconnectGattSafe(gatt).catch(() => { });
+        throw e;
+    }
+}
+/**
+ * Connect GATT (if needed) and return normalized primary service UUIDs.
+ * Uses a connect timeout and limited retries on transient failures.
+ */
+export async function collectPrimaryServiceUuids(device) {
+    const gatt = device.gatt;
+    if (!gatt) {
+        throw new Error('GATT unavailable on this device');
+    }
+    let lastErr;
+    for (let attempt = 0; attempt <= GATT_RETRY_MAX; attempt++) {
+        try {
+            await connectGattWithTimeout(gatt, GATT_CONNECT_TIMEOUT_MS);
+            const services = await gatt.getPrimaryServices();
+            const set = new Set();
+            for (const s of services) {
+                set.add(normalizeUuid(s.uuid));
+            }
+            return set;
+        }
+        catch (e) {
+            lastErr = e;
+            await disconnectGattSafe(gatt);
+            if (attempt < GATT_RETRY_MAX) {
+                await delay(GATT_RETRY_BASE_DELAY_MS * (attempt + 1));
+            }
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/mac-candidates.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Derive BLE address candidates from advertised device names (pattern-based only).
+ */
+/**
+ * QiYi / XMD-style names: build candidate MACs for cryptographic probing.
+ */
+export declare function buildQiYiMacCandidatesFromName(deviceName: string | null | undefined): string[];
+/**
+ * MoYu32 / WCU name patterns: multiple third-byte variants per hardware line.
+ */
+export declare function buildMoyu32MacCandidatesFromName(deviceName: string | null | undefined): string[];

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/mac-candidates.js

@@ -0,0 +1,67 @@
+/**
+ * Derive BLE address candidates from advertised device names (pattern-based only).
+ */
+function pushUnique(out, seen, mac) {
+    if (seen.has(mac)) {
+        return;
+    }
+    seen.add(mac);
+    out.push(mac);
+}
+/**
+ * QiYi / XMD-style names: build candidate MACs for cryptographic probing.
+ */
+export function buildQiYiMacCandidatesFromName(deviceName) {
+    const out = [];
+    const seen = new Set();
+    if (!deviceName) {
+        return out;
+    }
+    const t = deviceName.trim();
+    const qyA = /^QY-QYSC-A-([0-9A-Fa-f]{4})$/.exec(t);
+    if (qyA) {
+        const x = qyA[1].toUpperCase();
+        pushUnique(out, seen, `CC:A2:00:00:${x.slice(0, 2)}:${x.slice(2, 4)}`);
+    }
+    const qyS = /^QY-QYSC-S-([0-9A-Fa-f]{4})$/.exec(t);
+    if (qyS) {
+        const x = qyS[1].toUpperCase();
+        const a = `${x.slice(0, 2)}:${x.slice(2, 4)}`;
+        pushUnique(out, seen, `CC:A3:00:00:${a}`);
+        pushUnique(out, seen, `CC:A3:00:01:${a}`);
+    }
+    const xmd = /^XMD-TornadoV4-i-([0-9A-Fa-f]{4})$/.exec(t);
+    if (xmd) {
+        const x = xmd[1].toUpperCase();
+        pushUnique(out, seen, `CC:A6:00:00:${x.slice(0, 2)}:${x.slice(2, 4)}`);
+    }
+    return out.slice(0, 100);
+}
+/**
+ * MoYu32 / WCU name patterns: multiple third-byte variants per hardware line.
+ */
+export function buildMoyu32MacCandidatesFromName(deviceName) {
+    const out = [];
+    const seen = new Set();
+    if (!deviceName) {
+        return out;
+    }
+    const t = deviceName.trim();
+    const my32 = /^WCU_MY32_([0-9A-Fa-f]{4})$/.exec(t);
+    if (my32) {
+        const x = my32[1].toUpperCase();
+        const a = `${x.slice(0, 2)}:${x.slice(2, 4)}`;
+        for (const mid of ['00', '01', '02']) {
+            pushUnique(out, seen, `CF:30:16:${mid}:${a}`);
+        }
+    }
+    const my33 = /^WCU_MY33_([0-9A-Fa-f]{4})$/.exec(t);
+    if (my33) {
+        const x = my33[1].toUpperCase();
+        const a = `${x.slice(0, 2)}:${x.slice(2, 4)}`;
+        for (const mid of ['02', '01', '00']) {
+            pushUnique(out, seen, `CF:30:16:${mid}:${a}`);
+        }
+    }
+    return out.slice(0, 100);
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/mac-probe-moyu32.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="web-bluetooth" />
+/**
+ * Returns true if notifications decrypt to plausible MoYu32 payloads for this MAC.
+ */
+export declare function probeMoyu32Mac(device: BluetoothDevice, mac: string, options?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<boolean>;

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/mac-probe-moyu32.js

@@ -0,0 +1,98 @@
+import { findCharacteristic } from '../ble-utils.js';
+import { writeGattCharacteristicValue } from '../../gatt-characteristic-write.js';
+import { createMoyu32SessionCrypto } from './moyu32-session-crypto.js';
+import { isValidMoYu32DecryptedPacket } from './packet-sanity.js';
+const MOYU32_SVC = '0783b03e-7735-b5a0-1760-a305d2795cb0';
+const MOYU32_CHR_READ = '0783b03e-7735-b5a0-1760-a305d2795cb1';
+const MOYU32_CHR_WRITE = '0783b03e-7735-b5a0-1760-a305d2795cb2';
+/**
+ * Returns true if notifications decrypt to plausible MoYu32 payloads for this MAC.
+ */
+export async function probeMoyu32Mac(device, mac, options) {
+    const timeoutMs = options?.timeoutMs ?? 2000;
+    const gatt = device.gatt;
+    if (!gatt) {
+        return false;
+    }
+    if (!gatt.connected) {
+        await gatt.connect();
+    }
+    const service = await gatt.getPrimaryService(MOYU32_SVC);
+    const chrcts = await service.getCharacteristics();
+    const readChrct = findCharacteristic(chrcts, MOYU32_CHR_READ);
+    const writeChrct = findCharacteristic(chrcts, MOYU32_CHR_WRITE);
+    if (!readChrct || !writeChrct) {
+        return false;
+    }
+    const crypto = createMoyu32SessionCrypto(mac);
+    let samples = 0;
+    let good = 0;
+    let stopped = false;
+    const onNotify = (ev) => {
+        if (stopped) {
+            return;
+        }
+        const t = ev.target.value;
+        if (!t) {
+            return;
+        }
+        try {
+            const raw = [];
+            for (let i = 0; i < t.byteLength; i++) {
+                raw.push(t.getUint8(i));
+            }
+            const dec = crypto.decrypt(raw);
+            samples++;
+            if (isValidMoYu32DecryptedPacket(dec)) {
+                good++;
+            }
+        }
+        catch {
+            samples++;
+        }
+    };
+    readChrct.addEventListener('characteristicvaluechanged', onNotify);
+    await readChrct.startNotifications();
+    const sendCmd = async (cmd) => {
+        const t = Array(20).fill(0);
+        t[0] = cmd;
+        const enc = crypto.encrypt(t);
+        await writeGattCharacteristicValue(writeChrct, new Uint8Array(enc).buffer);
+    };
+    const sendInitBurst = async () => {
+        await sendCmd(161);
+        await sendCmd(163);
+        await sendCmd(164);
+    };
+    try {
+        await sendInitBurst();
+        // Some MoYu32 variants do not begin steady-state status updates until
+        // they receive the same startup request burst a second time.
+        await sendInitBurst();
+    }
+    catch {
+        stopped = true;
+        readChrct.removeEventListener('characteristicvaluechanged', onNotify);
+        await readChrct.stopNotifications().catch(() => { });
+        return false;
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && !stopped) {
+        if (options?.signal?.aborted) {
+            stopped = true;
+            break;
+        }
+        if (good >= 3) {
+            stopped = true;
+            break;
+        }
+        if (samples > 8 && good === 0) {
+            break;
+        }
+        await new Promise((r) => setTimeout(r, 120));
+    }
+    stopped = true;
+    readChrct.removeEventListener('characteristicvaluechanged', onNotify);
+    await readChrct.stopNotifications().catch(() => { });
+    return good >= 3;
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/mac-probe-qiyi.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="web-bluetooth" />
+/**
+ * Returns true if notifications decrypt to plausible QiYi payloads for this MAC.
+ */
+export declare function probeQiYiMac(device: BluetoothDevice, mac: string, options?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<boolean>;

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/mac-probe-qiyi.js

@@ -0,0 +1,128 @@
+import { ModeOfOperation } from 'aes-js';
+import { findCharacteristic } from '../ble-utils.js';
+import { writeGattCharacteristicValue } from '../../gatt-characteristic-write.js';
+import { isValidQiYiDecryptedPacket } from './packet-sanity.js';
+const UUID_SUFFIX = '-0000-1000-8000-00805f9b34fb';
+const QIYI_SVC = '0000fff0' + UUID_SUFFIX;
+const QIYI_CHR = '0000fff6' + UUID_SUFFIX;
+const QIYI_KEY = [87, 177, 249, 171, 205, 90, 232, 167, 156, 185, 140, 231, 87, 140, 81, 8];
+function crc16modbus(data) {
+    let crc = 0xffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc & 1) > 0 ? (crc >> 1) ^ 0xa001 : crc >> 1;
+        }
+    }
+    return crc;
+}
+/** Same wire as QiYiConnection.sendHello → sendMessage (wake cube for MAC validation). */
+function buildEncryptedQiYiHello(mac) {
+    const macBytes = mac.split(/[:-\s]+/).map((x) => parseInt(x, 16));
+    const content = [0x00, 0x6b, 0x01, 0x00, 0x00, 0x22, 0x06, 0x00, 0x02, 0x08, 0x00];
+    for (let i = 5; i >= 0; i--) {
+        content.push(macBytes[i] ?? 0);
+    }
+    const msg = [0xfe];
+    msg.push(4 + content.length);
+    for (let k = 0; k < content.length; k++) {
+        msg.push(content[k]);
+    }
+    const crc = crc16modbus(msg);
+    msg.push(crc & 0xff, crc >> 8);
+    const npad = (16 - (msg.length % 16)) % 16;
+    for (let p = 0; p < npad; p++) {
+        msg.push(0);
+    }
+    return encryptBlocks(new Uint8Array(msg));
+}
+function encryptBlocks(plain) {
+    const cipher = new ModeOfOperation.ecb(new Uint8Array(QIYI_KEY));
+    const out = new Uint8Array(plain.length);
+    for (let i = 0; i < plain.length; i += 16) {
+        const block = cipher.encrypt(plain.subarray(i, i + 16));
+        out.set(block, i);
+    }
+    return out.buffer;
+}
+function decryptBlocks(enc) {
+    const view = enc instanceof ArrayBuffer ? new Uint8Array(enc) : new Uint8Array(enc.buffer, enc.byteOffset, enc.byteLength);
+    const cipher = new ModeOfOperation.ecb(new Uint8Array(QIYI_KEY));
+    const out = new Uint8Array(view.length);
+    for (let i = 0; i < view.length; i += 16) {
+        const block = cipher.decrypt(view.subarray(i, i + 16));
+        out.set(block, i);
+    }
+    return out;
+}
+/**
+ * Returns true if notifications decrypt to plausible QiYi payloads for this MAC.
+ */
+export async function probeQiYiMac(device, mac, options) {
+    const timeoutMs = options?.timeoutMs ?? 3000;
+    const gatt = device.gatt;
+    if (!gatt) {
+        return false;
+    }
+    if (!gatt.connected) {
+        await gatt.connect();
+    }
+    const service = await gatt.getPrimaryService(QIYI_SVC);
+    const chrcts = await service.getCharacteristics();
+    const chrct = findCharacteristic(chrcts, QIYI_CHR);
+    if (!chrct) {
+        return false;
+    }
+    let stopped = false;
+    let ok = false;
+    const onNotify = (ev) => {
+        if (stopped) {
+            return;
+        }
+        const v = ev.target.value;
+        if (!v) {
+            return;
+        }
+        try {
+            const raw = new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+            const dec = decryptBlocks(raw);
+            if (isValidQiYiDecryptedPacket(dec)) {
+                ok = true;
+                stopped = true;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    chrct.addEventListener('characteristicvaluechanged', onNotify);
+    await chrct.startNotifications();
+    const wake = () => {
+        if (stopped) {
+            return;
+        }
+        try {
+            void writeGattCharacteristicValue(chrct, buildEncryptedQiYiHello(mac)).catch(() => { });
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    const iv = setInterval(wake, 100);
+    wake();
+    await new Promise((resolve) => {
+        const maxTimer = setTimeout(() => resolve(), timeoutMs);
+        const poll = setInterval(() => {
+            if (ok || options?.signal?.aborted) {
+                clearInterval(poll);
+                clearTimeout(maxTimer);
+                resolve();
+            }
+        }, 40);
+    });
+    clearInterval(iv);
+    stopped = true;
+    chrct.removeEventListener('characteristicvaluechanged', onNotify);
+    await chrct.stopNotifications().catch(() => { });
+    return ok;
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/moyu32-session-crypto.d.ts

@@ -0,0 +1,5 @@
+/** MoYu32 AES session crypto keyed by device address (same derivation as protocol driver). */
+export declare function createMoyu32SessionCrypto(mac: string): {
+    decrypt(raw: number[]): number[];
+    encrypt(data: number[]): number[];
+};

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/moyu32-session-crypto.js

@@ -0,0 +1,60 @@
+import { ModeOfOperation } from 'aes-js';
+const BASE_KEY = [21, 119, 58, 92, 103, 14, 45, 31, 23, 103, 42, 19, 155, 103, 82, 87];
+const BASE_IV = [17, 35, 38, 37, 134, 42, 44, 59, 85, 6, 127, 49, 126, 103, 33, 87];
+function macSegments(mac) {
+    const parts = mac.split(/[:-\s]+/).map((x) => parseInt(x, 16));
+    if (parts.length < 6 || parts.some((n) => Number.isNaN(n))) {
+        throw new Error('Invalid MAC');
+    }
+    return parts.slice(0, 6);
+}
+/** MoYu32 AES session crypto keyed by device address (same derivation as protocol driver). */
+export function createMoyu32SessionCrypto(mac) {
+    const t = macSegments(mac);
+    const key = BASE_KEY.slice();
+    const iv = BASE_IV.slice();
+    for (let i = 0; i < 6; i++) {
+        key[i] = (key[i] + t[5 - i]) % 255;
+        iv[i] = (iv[i] + t[5 - i]) % 255;
+    }
+    return {
+        decrypt(raw) {
+            const cipher = new ModeOfOperation.ecb(new Uint8Array(key));
+            const ret = raw.slice();
+            if (ret.length > 16) {
+                const offset = ret.length - 16;
+                const block = cipher.decrypt(new Uint8Array(ret.slice(offset)));
+                for (let i = 0; i < 16; i++) {
+                    ret[i + offset] = block[i] ^ iv[i];
+                }
+            }
+            const block = cipher.decrypt(new Uint8Array(ret.slice(0, 16)));
+            for (let i = 0; i < 16; i++) {
+                ret[i] = block[i] ^ iv[i];
+            }
+            return ret;
+        },
+        encrypt(data) {
+            const ret = data.slice();
+            const cipher = new ModeOfOperation.ecb(new Uint8Array(key));
+            for (let i = 0; i < 16; i++) {
+                ret[i] ^= iv[i];
+            }
+            const block = cipher.encrypt(new Uint8Array(ret.slice(0, 16)));
+            for (let i = 0; i < 16; i++) {
+                ret[i] = block[i];
+            }
+            if (ret.length > 16) {
+                const offset = ret.length - 16;
+                for (let i = 0; i < 16; i++) {
+                    ret[i + offset] ^= iv[i];
+                }
+                const block2 = cipher.encrypt(new Uint8Array(ret.slice(offset, offset + 16)));
+                for (let i = 0; i < 16; i++) {
+                    ret[i + offset] = block2[i];
+                }
+            }
+            return ret;
+        },
+    };
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/normalize-uuid.d.ts

@@ -0,0 +1,2 @@
+/** Normalize BLE UUID to 128-bit uppercase (16-bit UUIDs expanded per SIG base). */
+export declare function normalizeUuid(uuid: string): string;

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/normalize-uuid.js

@@ -0,0 +1,8 @@
+/** Normalize BLE UUID to 128-bit uppercase (16-bit UUIDs expanded per SIG base). */
+export function normalizeUuid(uuid) {
+    let u = uuid;
+    if (/^[0-9A-Fa-f]{4}$/.exec(u)) {
+        u = '0000' + u + '-0000-1000-8000-00805F9B34FB';
+    }
+    return u.toUpperCase();
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/packet-sanity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Post-decrypt sanity checks for MAC candidate probing.
+ */
+/** Validates decrypted MoYu32 notification bitstream. */
+export declare function isValidMoYu32DecryptedPacket(bytes: number[]): boolean;
+/** Validates decrypted QiYi notification payload. */
+export declare function isValidQiYiDecryptedPacket(e: Uint8Array): boolean;