@wodzik/cubecore 0.1.0

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocol.js

@@ -0,0 +1,8 @@
+const protocolRegistry = [];
+function registerProtocol(protocol) {
+    protocolRegistry.push(protocol);
+}
+function getRegisteredProtocols() {
+    return protocolRegistry;
+}
+export { registerProtocol, getRegisteredProtocols };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/gan.d.ts

@@ -0,0 +1,3 @@
+import { SmartCubeProtocol } from '../protocol.js';
+declare const ganProtocol: SmartCubeProtocol;
+export { ganProtocol };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/gan.js

@@ -0,0 +1,265 @@
+import { Subject } from 'rxjs';
+import { normalizeUuid } from '../attachment/normalize-uuid.js';
+import { getCachedMacForDevice, macFromGanManufacturerData, waitForManufacturerData } from '../attachment/address-hints.js';
+import { registerProtocol } from '../protocol.js';
+import * as def from '../../gan-cube-definitions.js';
+import { GanGen2CubeEncrypter, GanGen3CubeEncrypter, GanGen4CubeEncrypter } from '../../gan-cube-encrypter.js';
+import { GanGen1CubeConnection } from '../../gan-gen1.js';
+import { macStringToSaltOrThrow } from '../../gan-mac-salt.js';
+import { isValidGanGen2Packet, isValidGanGen3Packet, isValidGanGen4Packet, } from '../../gan-gen234-packet-validate.js';
+import { GanCubeClassicConnection, GanGen2ProtocolDriver, GanGen3ProtocolDriver, GanGen4ProtocolDriver } from '../../gan-cube-protocol.js';
+const DEFAULT_GAN_CAPABILITIES = {
+    gyroscope: true,
+    battery: true,
+    facelets: true,
+    hardware: true,
+    reset: true,
+};
+const GAN_GEN1_CAPABILITIES = {
+    gyroscope: true,
+    battery: true,
+    facelets: true,
+    hardware: false,
+    reset: false,
+};
+const GAN_GEN1_PROTOCOL = { id: 'gan-gen1', name: 'GAN Gen1' };
+const GAN_GEN2_PROTOCOL = { id: 'gan-gen2', name: 'GAN Gen2' };
+const GAN_GEN3_PROTOCOL = { id: 'gan-gen3', name: 'GAN Gen3' };
+const GAN_GEN4_PROTOCOL = { id: 'gan-gen4', name: 'GAN Gen4' };
+function ganEventToSmartEvent(event) {
+    switch (event.type) {
+        case "MOVE":
+            return {
+                timestamp: event.timestamp,
+                type: "MOVE",
+                face: event.face,
+                direction: event.direction,
+                move: event.move,
+                localTimestamp: event.localTimestamp,
+                cubeTimestamp: event.cubeTimestamp
+            };
+        case "FACELETS":
+            return {
+                timestamp: event.timestamp,
+                type: "FACELETS",
+                facelets: event.facelets
+            };
+        case "GYRO":
+            return {
+                timestamp: event.timestamp,
+                type: "GYRO",
+                quaternion: event.quaternion,
+                velocity: event.velocity
+            };
+        case "BATTERY":
+            return {
+                timestamp: event.timestamp,
+                type: "BATTERY",
+                batteryLevel: event.batteryLevel
+            };
+        case "HARDWARE":
+            return {
+                timestamp: event.timestamp,
+                type: "HARDWARE",
+                hardwareName: event.hardwareName,
+                softwareVersion: event.softwareVersion,
+                hardwareVersion: event.hardwareVersion,
+                productDate: event.productDate,
+                gyroSupported: event.gyroSupported
+            };
+        case "DISCONNECT":
+            return {
+                timestamp: event.timestamp,
+                type: "DISCONNECT"
+            };
+    }
+}
+function hasGanGen1Profile(serviceUuids) {
+    const primary = normalizeUuid(def.GAN_GEN1_PRIMARY_SERVICE);
+    const deviceInfo = normalizeUuid(def.GAN_GEN1_DEVICE_INFO_SERVICE);
+    return serviceUuids.has(primary) && serviceUuids.has(deviceInfo);
+}
+class GanSmartCubeConnection {
+    ganConn;
+    deviceMac;
+    lastBatteryLevel = null;
+    forceNextBatteryEmission = false;
+    events$;
+    protocol;
+    capabilities;
+    constructor(ganConn, mac, protocol, capabilities) {
+        this.ganConn = ganConn;
+        this.deviceMac = mac;
+        this.protocol = protocol;
+        const base = capabilities ? { ...capabilities } : { ...DEFAULT_GAN_CAPABILITIES };
+        if (!capabilities && ganConn.deviceName?.startsWith('AiCube')) {
+            base.gyroscope = false;
+        }
+        this.capabilities = base;
+        this.events$ = new Subject();
+        ganConn.events$.subscribe({
+            next: (event) => {
+                if (event.type === 'HARDWARE' &&
+                    this.protocol.id === 'gan-gen2' &&
+                    typeof event.gyroSupported === 'boolean') {
+                    this.capabilities.gyroscope = event.gyroSupported;
+                }
+                if (event.type === 'BATTERY') {
+                    const batteryLevel = Math.min(100, Math.max(0, Math.round(event.batteryLevel)));
+                    const forceEmission = this.forceNextBatteryEmission;
+                    this.forceNextBatteryEmission = false;
+                    if (!forceEmission && this.lastBatteryLevel === batteryLevel) {
+                        return;
+                    }
+                    this.lastBatteryLevel = batteryLevel;
+                    this.events$.next({
+                        timestamp: event.timestamp,
+                        type: 'BATTERY',
+                        batteryLevel,
+                    });
+                    return;
+                }
+                this.events$.next(ganEventToSmartEvent(event));
+            },
+            complete: () => this.events$.complete(),
+        });
+    }
+    get deviceName() {
+        return this.ganConn.deviceName;
+    }
+    get deviceMAC() {
+        return this.deviceMac;
+    }
+    async sendCommand(command) {
+        if (command.type === 'REQUEST_BATTERY') {
+            this.forceNextBatteryEmission = true;
+        }
+        return this.ganConn.sendCubeCommand(command);
+    }
+    async disconnect() {
+        this.forceNextBatteryEmission = false;
+        return this.ganConn.disconnect();
+    }
+}
+async function connectGanDevice(device, macProvider, context) {
+    const bleDevice = device;
+    const gatt = device.gatt;
+    if (!gatt.connected) {
+        await gatt.connect();
+    }
+    const services = await gatt.getPrimaryServices();
+    const serviceUuidSet = new Set(services.map((s) => normalizeUuid(s.uuid)));
+    if (hasGanGen1Profile(serviceUuidSet)) {
+        const gen1Conn = await GanGen1CubeConnection.create(device);
+        return new GanSmartCubeConnection(gen1Conn, '', GAN_GEN1_PROTOCOL, GAN_GEN1_CAPABILITIES);
+    }
+    let mac = null;
+    if (context?.advertisementManufacturerData) {
+        mac = macFromGanManufacturerData(context.advertisementManufacturerData);
+    }
+    mac = mac || getCachedMacForDevice(device);
+    if (!mac && macProvider) {
+        const r = await macProvider(device, false);
+        if (r) {
+            mac = r;
+        }
+    }
+    if (!mac) {
+        const mf = await waitForManufacturerData(device, 5000);
+        if (mf) {
+            mac = macFromGanManufacturerData(mf);
+        }
+    }
+    if (!mac && macProvider) {
+        const r = await macProvider(device, true);
+        if (r) {
+            mac = r;
+        }
+    }
+    if (!mac) {
+        throw new Error('Unable to determine cube MAC address, connection is not possible!');
+    }
+    bleDevice.mac = mac;
+    const salt = macStringToSaltOrThrow(mac);
+    const g2 = normalizeUuid(def.GAN_GEN2_SERVICE);
+    const g3 = normalizeUuid(def.GAN_GEN3_SERVICE);
+    const g4 = normalizeUuid(def.GAN_GEN4_SERVICE);
+    let pick = null;
+    if (serviceUuidSet.has(g2))
+        pick = 'g2';
+    else if (serviceUuidSet.has(g3))
+        pick = 'g3';
+    else if (serviceUuidSet.has(g4))
+        pick = 'g4';
+    let ganConn = null;
+    if (pick === 'g2') {
+        const service = await gatt.getPrimaryService(def.GAN_GEN2_SERVICE);
+        const commandCharacteristic = await service.getCharacteristic(def.GAN_GEN2_COMMAND_CHARACTERISTIC);
+        const stateCharacteristic = await service.getCharacteristic(def.GAN_GEN2_STATE_CHARACTERISTIC);
+        const key = device.name?.startsWith('AiCube') ? def.GAN_ENCRYPTION_KEYS[1] : def.GAN_ENCRYPTION_KEYS[0];
+        const encrypter = new GanGen2CubeEncrypter(new Uint8Array(key.key), new Uint8Array(key.iv), salt);
+        const driver = new GanGen2ProtocolDriver();
+        ganConn = await GanCubeClassicConnection.create(bleDevice, commandCharacteristic, stateCharacteristic, encrypter, driver, { validateDecrypted: isValidGanGen2Packet });
+    }
+    else if (pick === 'g3') {
+        const service = await gatt.getPrimaryService(def.GAN_GEN3_SERVICE);
+        const commandCharacteristic = await service.getCharacteristic(def.GAN_GEN3_COMMAND_CHARACTERISTIC);
+        const stateCharacteristic = await service.getCharacteristic(def.GAN_GEN3_STATE_CHARACTERISTIC);
+        const key = def.GAN_ENCRYPTION_KEYS[0];
+        const encrypter = new GanGen3CubeEncrypter(new Uint8Array(key.key), new Uint8Array(key.iv), salt);
+        const driver = new GanGen3ProtocolDriver();
+        ganConn = await GanCubeClassicConnection.create(bleDevice, commandCharacteristic, stateCharacteristic, encrypter, driver, { validateDecrypted: isValidGanGen3Packet });
+    }
+    else if (pick === 'g4') {
+        const service = await gatt.getPrimaryService(def.GAN_GEN4_SERVICE);
+        const commandCharacteristic = await service.getCharacteristic(def.GAN_GEN4_COMMAND_CHARACTERISTIC);
+        const stateCharacteristic = await service.getCharacteristic(def.GAN_GEN4_STATE_CHARACTERISTIC);
+        const key = def.GAN_ENCRYPTION_KEYS[0];
+        const encrypter = new GanGen4CubeEncrypter(new Uint8Array(key.key), new Uint8Array(key.iv), salt);
+        const driver = new GanGen4ProtocolDriver();
+        ganConn = await GanCubeClassicConnection.create(bleDevice, commandCharacteristic, stateCharacteristic, encrypter, driver, { validateDecrypted: isValidGanGen4Packet });
+    }
+    if (!ganConn) {
+        throw new Error("Can't find target BLE services - wrong or unsupported cube device model");
+    }
+    return new GanSmartCubeConnection(ganConn, mac, pick === 'g2' ? GAN_GEN2_PROTOCOL : pick === 'g3' ? GAN_GEN3_PROTOCOL : GAN_GEN4_PROTOCOL);
+}
+const ganProtocol = {
+    nameFilters: [{ namePrefix: 'GAN' }, { namePrefix: 'MG' }, { namePrefix: 'AiCube' }],
+    optionalServices: [
+        def.GAN_GEN1_PRIMARY_SERVICE,
+        def.GAN_GEN1_DEVICE_INFO_SERVICE,
+        def.GAN_GEN2_SERVICE,
+        def.GAN_GEN3_SERVICE,
+        def.GAN_GEN4_SERVICE,
+    ],
+    optionalManufacturerData: def.GAN_CIC_LIST,
+    matchesDevice(device) {
+        const name = device.name || '';
+        return name.startsWith('GAN') || name.startsWith('MG') || name.startsWith('AiCube');
+    },
+    gattAffinity(serviceUuids, _device) {
+        const g2 = normalizeUuid(def.GAN_GEN2_SERVICE);
+        const g3 = normalizeUuid(def.GAN_GEN3_SERVICE);
+        const g4 = normalizeUuid(def.GAN_GEN4_SERVICE);
+        const g1Primary = normalizeUuid(def.GAN_GEN1_PRIMARY_SERVICE);
+        const deviceInfo = normalizeUuid(def.GAN_GEN1_DEVICE_INFO_SERVICE);
+        const bonus = serviceUuids.has(deviceInfo) ? 5 : 0;
+        if (serviceUuids.has(g1Primary) && serviceUuids.has(deviceInfo)) {
+            return 125 + bonus;
+        }
+        if (serviceUuids.has(g4)) {
+            return 120 + bonus;
+        }
+        if (serviceUuids.has(g3)) {
+            return 120 + bonus;
+        }
+        if (serviceUuids.has(g2)) {
+            return 120 + bonus;
+        }
+        return 0;
+    },
+    connect: connectGanDevice
+};
+registerProtocol(ganProtocol);
+export { ganProtocol };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/giiker.d.ts

@@ -0,0 +1,3 @@
+import { SmartCubeProtocol } from '../protocol.js';
+declare const giikerProtocol: SmartCubeProtocol;
+export { giikerProtocol };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/giiker.js

@@ -0,0 +1,345 @@
+import { Subject } from 'rxjs';
+import { normalizeUuid } from '../attachment/normalize-uuid.js';
+import { registerProtocol } from '../protocol.js';
+import { CubieCube } from '../cubie-cube.js';
+import { now, findCharacteristic } from '../ble-utils.js';
+import { writeGattCharacteristicValue } from '../../gatt-characteristic-write.js';
+const UUID_SUFFIX = '-0000-1000-8000-00805f9b34fb';
+const SERVICE_UUID_DATA = '0000aadb' + UUID_SUFFIX;
+const CHRCT_UUID_DATA = '0000aadc' + UUID_SUFFIX;
+const SERVICE_UUID_RW = '0000aaaa' + UUID_SUFFIX;
+const CHRCT_UUID_READ = '0000aaab' + UUID_SUFFIX;
+const CHRCT_UUID_WRITE = '0000aaac' + UUID_SUFFIX;
+const GIIKER_CFACELET = [
+    [26, 15, 29], [20, 8, 9], [18, 38, 6], [24, 27, 44],
+    [51, 35, 17], [45, 11, 2], [47, 0, 36], [53, 42, 33]
+];
+const GIIKER_EFACELET = [
+    [25, 28], [23, 12], [19, 7], [21, 41],
+    [32, 16], [5, 10], [3, 37], [30, 43],
+    [52, 34], [48, 14], [46, 1], [50, 39]
+];
+const DECRYPT_KEY = [176, 81, 104, 224, 86, 137, 237, 119, 38, 26, 193, 161, 210, 126, 150, 81, 93, 13, 236, 249, 89, 235, 88, 24, 113, 81, 214, 131, 130, 199, 2, 169, 39, 165, 171, 41];
+const CO_MASK = [-1, 1, -1, 1, 1, -1, 1, -1];
+function giikerHexPayload(value) {
+    const raw = [];
+    for (let i = 0; i < 20; i++) {
+        raw.push(value.getUint8(i));
+    }
+    let logicalBytes = raw.length;
+    if (raw[18] === 0xa7) {
+        const k1 = (raw[19] >> 4) & 0xf;
+        const k2 = raw[19] & 0xf;
+        for (let i = 0; i < 18; i++) {
+            raw[i] = (raw[i] + DECRYPT_KEY[i + k1] + DECRYPT_KEY[i + k2]) & 0xFF;
+        }
+        logicalBytes = 18;
+    }
+    const valhex = [];
+    for (let i = 0; i < logicalBytes; i++) {
+        valhex.push((raw[i] >> 4) & 0xf);
+        valhex.push(raw[i] & 0xf);
+    }
+    return { valhex, logicalBytes };
+}
+function giikerMoveString(faceNibble, dirNibble) {
+    const face = ["?", "B", "D", "L", "U", "R", "F"][faceNibble];
+    if (!face || face === "?")
+        return null;
+    // Observed mappings: 1/2 => "", 3 => "2", 4 => "'", and some firmwares use 9 for half-turn.
+    const dirKey = dirNibble === 9 ? 3 : dirNibble;
+    const suffix = ["", "", "2", "'"][dirKey] ?? "";
+    return `${face}${suffix}`;
+}
+function parseState(value) {
+    const { valhex } = giikerHexPayload(value);
+    const eo = [];
+    for (let i = 0; i < 3; i++) {
+        for (let mask = 8; mask !== 0; mask >>= 1) {
+            eo.push((valhex[i + 28] & mask) ? 1 : 0);
+        }
+    }
+    const cc = new CubieCube();
+    for (let i = 0; i < 8; i++) {
+        cc.ca[i] = (valhex[i] - 1) | (((3 + valhex[i + 8] * CO_MASK[i]) % 3) << 3);
+    }
+    for (let i = 0; i < 12; i++) {
+        cc.ea[i] = ((valhex[i + 16] - 1) << 1) | eo[i];
+    }
+    const facelet = cc.toFaceCube(GIIKER_CFACELET, GIIKER_EFACELET);
+    const prevMoves = [];
+    // Byte 16 is the current move (face/dir nibbles). Encrypted packets must ignore bytes 18–19.
+    const faceNibble = valhex[32];
+    const dirNibble = valhex[33];
+    if (faceNibble !== undefined && dirNibble !== undefined) {
+        const mv = giikerMoveString(faceNibble, dirNibble);
+        if (mv)
+            prevMoves.push(mv);
+    }
+    return { facelet, prevMoves };
+}
+const GIIKER_PROTOCOL = { id: 'giiker', name: 'Giiker' };
+class GiikerConnection {
+    deviceName;
+    deviceMAC;
+    protocol = GIIKER_PROTOCOL;
+    capabilities = {
+        gyroscope: false,
+        battery: true,
+        facelets: true,
+        hardware: true,
+        reset: true
+    };
+    events$;
+    device;
+    gatt = null;
+    dataChrct = null;
+    lastFacelet = '';
+    isReady = false;
+    pendingValues = [];
+    rwReadChrct = null;
+    rwWriteChrct = null;
+    batteryInterval = null;
+    onBatteryChanged = null;
+    lastBatteryLevel = null;
+    forceNextBatteryEmission = false;
+    constructor(device, name) {
+        this.device = device;
+        this.deviceName = name;
+        this.deviceMAC = '';
+        this.events$ = new Subject();
+    }
+    onStateChanged = (event) => {
+        const value = event.target.value;
+        if (!value)
+            return;
+        if (!this.isReady) {
+            // Copy the view, because the underlying buffer can be reused by the platform.
+            const b = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+            this.pendingValues.push(new DataView(b));
+            return;
+        }
+        const timestamp = now();
+        const { facelet, prevMoves } = parseState(value);
+        if (this.lastFacelet && this.lastFacelet !== facelet && prevMoves.length > 0) {
+            const moveStr = prevMoves[0].trim();
+            const face = "URFDLB".indexOf(moveStr[0]);
+            const direction = moveStr.includes("2") ? 2 : moveStr.includes("'") ? 1 : 0;
+            this.events$.next({
+                timestamp,
+                type: "MOVE",
+                face,
+                direction,
+                move: moveStr,
+                localTimestamp: timestamp,
+                cubeTimestamp: null
+            });
+        }
+        this.lastFacelet = facelet;
+        this.events$.next({
+            timestamp,
+            type: "FACELETS",
+            facelets: facelet
+        });
+    };
+    emitHardwareEvent() {
+        this.events$.next({
+            timestamp: now(),
+            type: "HARDWARE",
+            hardwareName: this.deviceName,
+            gyroSupported: false
+        });
+    }
+    emitBatteryLevel(rawLevel, timestamp = now()) {
+        if (!Number.isFinite(rawLevel)) {
+            return;
+        }
+        const batteryLevel = Math.min(100, Math.max(0, Math.round(rawLevel)));
+        const forceEmission = this.forceNextBatteryEmission;
+        this.forceNextBatteryEmission = false;
+        if (!forceEmission && this.lastBatteryLevel === batteryLevel) {
+            return;
+        }
+        this.lastBatteryLevel = batteryLevel;
+        this.events$.next({
+            timestamp,
+            type: 'BATTERY',
+            batteryLevel,
+        });
+    }
+    onDisconnect = () => {
+        this.device.removeEventListener('gattserverdisconnected', this.onDisconnect);
+        this.isReady = false;
+        this.pendingValues = [];
+        this.lastBatteryLevel = null;
+        this.forceNextBatteryEmission = false;
+        if (this.batteryInterval) {
+            clearInterval(this.batteryInterval);
+            this.batteryInterval = null;
+        }
+        if (this.rwReadChrct && this.onBatteryChanged) {
+            this.rwReadChrct.removeEventListener('characteristicvaluechanged', this.onBatteryChanged);
+        }
+        this.onBatteryChanged = null;
+        this.events$.next({ timestamp: now(), type: "DISCONNECT" });
+        this.events$.complete();
+    };
+    async init() {
+        this.device.addEventListener('gattserverdisconnected', this.onDisconnect);
+        this.gatt = await this.device.gatt.connect();
+        const dataService = await this.gatt.getPrimaryService(SERVICE_UUID_DATA);
+        this.dataChrct = await dataService.getCharacteristic(CHRCT_UUID_DATA);
+        // Attach listener before notifications to reduce missed packets.
+        this.dataChrct.addEventListener('characteristicvaluechanged', this.onStateChanged);
+        await this.dataChrct.startNotifications();
+        const initialValue = await this.dataChrct.readValue();
+        const { facelet } = parseState(initialValue);
+        this.lastFacelet = facelet;
+        const timestamp = now();
+        this.events$.next({
+            timestamp,
+            type: "FACELETS",
+            facelets: facelet
+        });
+        // Setup periodic battery polling if the control service is available.
+        try {
+            const rwService = await this.gatt.getPrimaryService(SERVICE_UUID_RW);
+            const chrcts = await rwService.getCharacteristics();
+            this.rwReadChrct = findCharacteristic(chrcts, CHRCT_UUID_READ);
+            this.rwWriteChrct = findCharacteristic(chrcts, CHRCT_UUID_WRITE);
+            if (this.rwReadChrct && this.rwWriteChrct) {
+                this.onBatteryChanged = (evt) => {
+                    const val = evt.target.value;
+                    if (!val)
+                        return;
+                    this.emitBatteryLevel(val.getUint8(1));
+                };
+                this.rwReadChrct.addEventListener('characteristicvaluechanged', this.onBatteryChanged);
+                await this.rwReadChrct.startNotifications();
+                const tick = () => {
+                    if (!this.rwWriteChrct)
+                        return;
+                    writeGattCharacteristicValue(this.rwWriteChrct, new Uint8Array([0xb5]).buffer).catch(() => { });
+                };
+                tick();
+                this.batteryInterval = setInterval(tick, 60_000);
+            }
+        }
+        catch {
+            // Battery service may not be available
+        }
+        // Release any queued notifications that arrived during init.
+        this.isReady = true;
+        const queued = this.pendingValues;
+        this.pendingValues = [];
+        for (const dv of queued) {
+            // Reuse the same logic path.
+            const ts2 = now();
+            const { facelet: f2, prevMoves: m2 } = parseState(dv);
+            if (this.lastFacelet && this.lastFacelet !== f2 && m2.length > 0) {
+                const moveStr = m2[0].trim();
+                const face = "URFDLB".indexOf(moveStr[0]);
+                const direction = moveStr.includes("2") ? 2 : moveStr.includes("'") ? 1 : 0;
+                this.events$.next({
+                    timestamp: ts2,
+                    type: "MOVE",
+                    face,
+                    direction,
+                    move: moveStr,
+                    localTimestamp: ts2,
+                    cubeTimestamp: null
+                });
+            }
+            this.lastFacelet = f2;
+            this.events$.next({
+                timestamp: ts2,
+                type: "FACELETS",
+                facelets: f2
+            });
+        }
+    }
+    async sendCommand(command) {
+        if (command.type === "REQUEST_BATTERY") {
+            // Periodic battery polling is set up in init when available.
+            if (this.rwWriteChrct) {
+                this.forceNextBatteryEmission = true;
+                await writeGattCharacteristicValue(this.rwWriteChrct, new Uint8Array([0xb5]).buffer);
+            }
+        }
+        else if (command.type === "REQUEST_FACELETS") {
+            if (this.lastFacelet) {
+                this.events$.next({
+                    timestamp: now(),
+                    type: "FACELETS",
+                    facelets: this.lastFacelet
+                });
+            }
+        }
+        else if (command.type === "REQUEST_HARDWARE") {
+            this.emitHardwareEvent();
+        }
+        else if (command.type === "REQUEST_RESET") {
+            if (this.rwWriteChrct) {
+                await writeGattCharacteristicValue(this.rwWriteChrct, new Uint8Array([0xa1]).buffer);
+            }
+        }
+    }
+    async disconnect() {
+        if (this.dataChrct) {
+            this.dataChrct.removeEventListener('characteristicvaluechanged', this.onStateChanged);
+            await this.dataChrct.stopNotifications().catch(() => { });
+            this.dataChrct = null;
+        }
+        this.lastBatteryLevel = null;
+        this.forceNextBatteryEmission = false;
+        if (this.batteryInterval) {
+            clearInterval(this.batteryInterval);
+            this.batteryInterval = null;
+        }
+        if (this.rwReadChrct) {
+            if (this.onBatteryChanged) {
+                this.rwReadChrct.removeEventListener('characteristicvaluechanged', this.onBatteryChanged);
+            }
+            await this.rwReadChrct.stopNotifications().catch(() => { });
+            this.rwReadChrct = null;
+        }
+        this.onBatteryChanged = null;
+        this.rwWriteChrct = null;
+        this.device.removeEventListener('gattserverdisconnected', this.onDisconnect);
+        this.events$.next({ timestamp: now(), type: "DISCONNECT" });
+        this.events$.complete();
+        if (this.device.gatt?.connected) {
+            this.device.gatt.disconnect();
+        }
+    }
+}
+const giikerProtocol = {
+    nameFilters: [
+        { namePrefix: "Gi" },
+        { namePrefix: "Mi Smart Magic Cube" },
+        { namePrefix: "Hi-" }
+    ],
+    optionalServices: [SERVICE_UUID_DATA, SERVICE_UUID_RW],
+    matchesDevice(device) {
+        const name = device.name || '';
+        return name.startsWith('Gi') || name.startsWith('Mi Smart Magic Cube') || name.startsWith('Hi-');
+    },
+    gattAffinity(serviceUuids, _device) {
+        return serviceUuids.has(normalizeUuid(SERVICE_UUID_DATA)) ? 115 : 0;
+    },
+    async connect(device, _macProvider, _context) {
+        const devName = device.name || '';
+        const name = devName.startsWith('GiC') ? 'Giiker i3' :
+            devName.startsWith('GiS') ? 'Giiker i3S' :
+                devName.startsWith('GiY') ? 'Giiker i3Y' :
+                    devName.startsWith('Mi Smart') ? 'Mi Smart Magic Cube' :
+                        devName.startsWith('Gi') ? 'Giiker i3SE' :
+                            devName.startsWith('Hi-') ? 'Hi-' :
+                                devName || 'Unknown';
+        const conn = new GiikerConnection(device, name);
+        await conn.init();
+        return conn;
+    }
+};
+registerProtocol(giikerProtocol);
+export { giikerProtocol };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/gocube.d.ts

@@ -0,0 +1,15 @@
+import { SmartCubeProtocol } from '../protocol.js';
+/**
+ * MsgOrientation payload: ASCII decimals `x#y#z#w` (see public GoCube UART docs). Normalize to a unit quaternion.
+ * Integer components are scaled together so normalization yields the physical orientation.
+ *
+ * Wire `(rx,ry,rz,rw)` normalized to `(nx,ny,nz,nw)` then mapped to `(nx, -nz, -ny, nw)`.
+ */
+export declare function parseGoCubeOrientationPayload(payloadUtf8: string): {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+} | null;
+declare const goCubeProtocol: SmartCubeProtocol;
+export { goCubeProtocol };