@wodzik/cubecore 0.1.0

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/moyu-mhc.js

@@ -0,0 +1,352 @@
+import { Subject } from 'rxjs';
+import { normalizeUuid } from '../attachment/normalize-uuid.js';
+import { registerProtocol } from '../protocol.js';
+import { CubieCube, SOLVED_FACELET } from '../cubie-cube.js';
+import { now, findCharacteristic } from '../ble-utils.js';
+import { MoyuV1Client, moyuStickersToFaceletString, MOYU_V1_SOLVED_STICKERS, } from './moyu-v1.js';
+const UUID_SUFFIX = '-0000-1000-8000-00805f9b34fb';
+const SERVICE_UUID = '00001000' + UUID_SUFFIX;
+const CHRCT_UUID_WRITE = '00001001' + UUID_SUFFIX;
+const CHRCT_UUID_READ = '00001002' + UUID_SUFFIX;
+const CHRCT_UUID_TURN = '00001003' + UUID_SUFFIX;
+const CHRCT_UUID_GYRO = '00001004' + UUID_SUFFIX;
+const FACE_ORDER_LEN = 6;
+const DEVICE_FACE_TO_AXIS = [3, 4, 5, 1, 2, 0];
+function normalizeQuaternion(q) {
+    const n = Math.hypot(q.w, q.x, q.y, q.z) || 1;
+    return { w: q.w / n, x: q.x / n, y: q.y / n, z: q.z / n };
+}
+const MOYU_MHC_PROTOCOL = { id: 'moyu-mhc', name: 'MoYu MHC' };
+class MoyuMhcConnection {
+    deviceName;
+    deviceMAC;
+    protocol = MOYU_MHC_PROTOCOL;
+    capabilities;
+    events$;
+    device;
+    writeChrct = null;
+    readChrct = null;
+    turnChrct = null;
+    gyroChrct = null;
+    v1 = null;
+    faceStatus = [0, 0, 0, 0, 0, 0];
+    curCubie = new CubieCube();
+    prevCubie = new CubieCube();
+    lastBatteryLevel = null;
+    batteryInterval = null;
+    constructor(device) {
+        this.device = device;
+        this.deviceName = device.name || 'MHC';
+        this.deviceMAC = '';
+        this.events$ = new Subject();
+        this.capabilities = {
+            gyroscope: false,
+            battery: false,
+            facelets: false,
+            hardware: false,
+            reset: false,
+        };
+    }
+    onTurnEvent = (event) => {
+        const value = event.target.value;
+        if (!value)
+            return;
+        this.parseTurn(value);
+    };
+    onReadEvent = (event) => {
+        const value = event.target.value;
+        if (!value || !this.v1)
+            return;
+        this.v1.onReadNotification(value);
+    };
+    onGyroEvent = (event) => {
+        const e = event.target.value;
+        if (!e || e.byteLength < 20)
+            return;
+        const fw = e.getFloat32(4, true);
+        const fx = e.getFloat32(8, true);
+        const fy = e.getFloat32(12, true);
+        const fz = e.getFloat32(16, true);
+        const quaternion = normalizeQuaternion({
+            w: fw,
+            x: fx,
+            y: -fy,
+            z: fz,
+        });
+        const timestamp = now();
+        this.events$.next({
+            timestamp,
+            type: 'GYRO',
+            quaternion,
+        });
+    };
+    /**
+     * After each move, `prevCubie` holds the latest physical state (see parseTurn swap).
+     * Seed that cube from the device facelet string and align turn counters with gyro angles.
+     */
+    applyCubeStateFromDevice(stickers, angles) {
+        const facelet = moyuStickersToFaceletString(stickers);
+        this.prevCubie = new CubieCube();
+        const parsed = this.prevCubie.fromFacelet(facelet);
+        if (parsed === -1) {
+            this.prevCubie = new CubieCube();
+            this.curCubie = new CubieCube();
+            this.faceStatus = [0, 0, 0, 0, 0, 0];
+            return;
+        }
+        this.curCubie = new CubieCube();
+        for (let i = 0; i < FACE_ORDER_LEN; i++) {
+            this.faceStatus[i] = (angles[i] ?? 0) % 9;
+        }
+    }
+    parseTurn(data) {
+        const timestamp = now();
+        if (data.byteLength < 1)
+            return;
+        const nMoves = data.getUint8(0);
+        if (data.byteLength < 1 + nMoves * 6)
+            return;
+        for (let i = 0; i < nMoves; i++) {
+            const offset = 1 + i * 6;
+            let ts = data.getUint8(offset + 1) << 24
+                | data.getUint8(offset + 0) << 16
+                | data.getUint8(offset + 3) << 8
+                | data.getUint8(offset + 2);
+            ts = Math.round(ts / 65536 * 1000);
+            const face = data.getUint8(offset + 4);
+            if (face >= FACE_ORDER_LEN)
+                continue;
+            const dir = Math.round(data.getInt8(offset + 5) / 36);
+            const prevRot = this.faceStatus[face];
+            const curRot = this.faceStatus[face] + dir;
+            this.faceStatus[face] = (curRot + 9) % 9;
+            const axis = DEVICE_FACE_TO_AXIS[face];
+            let pow;
+            if (prevRot >= 5 && curRot <= 4) {
+                pow = 2;
+            }
+            else if (prevRot <= 4 && curRot >= 5) {
+                pow = 0;
+            }
+            else {
+                continue;
+            }
+            const m = axis * 3 + pow;
+            const moveStr = ("URFDLB".charAt(axis) + " 2'".charAt(pow)).trim();
+            CubieCube.CubeMult(this.prevCubie, CubieCube.moveCube[m], this.curCubie);
+            const faceletStr = this.curCubie.toFaceCube();
+            this.events$.next({
+                timestamp,
+                type: "MOVE",
+                face: axis,
+                direction: pow === 0 ? 0 : 1,
+                move: moveStr,
+                localTimestamp: timestamp,
+                cubeTimestamp: ts
+            });
+            this.events$.next({
+                timestamp,
+                type: "FACELETS",
+                facelets: faceletStr
+            });
+            const tmp = this.curCubie;
+            this.curCubie = this.prevCubie;
+            this.prevCubie = tmp;
+        }
+    }
+    emitBatteryLevel(rawLevel, timestamp = now(), forceEmission = false) {
+        if (!Number.isFinite(rawLevel)) {
+            return;
+        }
+        const batteryLevel = Math.min(100, Math.max(0, Math.round(rawLevel)));
+        if (!forceEmission && this.lastBatteryLevel === batteryLevel) {
+            return;
+        }
+        this.lastBatteryLevel = batteryLevel;
+        this.events$.next({
+            timestamp,
+            type: 'BATTERY',
+            batteryLevel,
+        });
+    }
+    async pollBattery() {
+        if (!this.v1) {
+            return;
+        }
+        try {
+            const b = await this.v1.getBatteryInfo();
+            this.emitBatteryLevel(b.value.percentage);
+        }
+        catch {
+            /* ignore failed optional commands */
+        }
+    }
+    onDisconnect = () => {
+        this.device.removeEventListener('gattserverdisconnected', this.onDisconnect);
+        this.lastBatteryLevel = null;
+        if (this.batteryInterval) {
+            clearInterval(this.batteryInterval);
+            this.batteryInterval = null;
+        }
+        this.events$.next({ timestamp: now(), type: "DISCONNECT" });
+        this.events$.complete();
+    };
+    updateCapabilities() {
+        const hasV1 = this.v1 !== null;
+        this.capabilities.gyroscope = this.gyroChrct !== null;
+        this.capabilities.battery = hasV1;
+        this.capabilities.facelets = hasV1;
+        this.capabilities.hardware = hasV1;
+        this.capabilities.reset = hasV1;
+    }
+    async init() {
+        this.device.addEventListener('gattserverdisconnected', this.onDisconnect);
+        const gatt = await this.device.gatt.connect();
+        const service = await gatt.getPrimaryService(SERVICE_UUID);
+        const chrcts = await service.getCharacteristics();
+        this.writeChrct = findCharacteristic(chrcts, CHRCT_UUID_WRITE);
+        this.readChrct = findCharacteristic(chrcts, CHRCT_UUID_READ);
+        this.turnChrct = findCharacteristic(chrcts, CHRCT_UUID_TURN);
+        this.gyroChrct = findCharacteristic(chrcts, CHRCT_UUID_GYRO);
+        if (this.writeChrct) {
+            this.v1 = new MoyuV1Client(this.writeChrct);
+        }
+        if (this.readChrct) {
+            this.readChrct.addEventListener('characteristicvaluechanged', this.onReadEvent);
+            await this.readChrct.startNotifications();
+        }
+        if (this.turnChrct) {
+            this.turnChrct.addEventListener('characteristicvaluechanged', this.onTurnEvent);
+            await this.turnChrct.startNotifications();
+        }
+        if (this.gyroChrct) {
+            this.gyroChrct.addEventListener('characteristicvaluechanged', this.onGyroEvent);
+            await this.gyroChrct.startNotifications();
+        }
+        this.updateCapabilities();
+        if (this.v1) {
+            await this.pollBattery();
+            this.batteryInterval = setInterval(() => {
+                void this.pollBattery();
+            }, 60_000);
+            try {
+                const st = await this.v1.getCubeState();
+                this.applyCubeStateFromDevice(st.stickers, st.angles);
+                const facelets = this.prevCubie.toFaceCube();
+                this.events$.next({
+                    timestamp: now(),
+                    type: 'FACELETS',
+                    facelets,
+                });
+            }
+            catch {
+                this.events$.next({
+                    timestamp: now(),
+                    type: 'FACELETS',
+                    facelets: SOLVED_FACELET,
+                });
+            }
+        }
+        else {
+            this.events$.next({
+                timestamp: now(),
+                type: 'FACELETS',
+                facelets: SOLVED_FACELET,
+            });
+        }
+    }
+    async sendCommand(command) {
+        if (!this.v1)
+            return;
+        const ts = now();
+        try {
+            if (command.type === 'REQUEST_FACELETS') {
+                const st = await this.v1.getCubeState();
+                this.applyCubeStateFromDevice(st.stickers, st.angles);
+                this.events$.next({
+                    timestamp: ts,
+                    type: 'FACELETS',
+                    facelets: this.prevCubie.toFaceCube(),
+                });
+            }
+            else if (command.type === 'REQUEST_BATTERY') {
+                const b = await this.v1.getBatteryInfo();
+                this.emitBatteryLevel(b.value.percentage, ts, true);
+            }
+            else if (command.type === 'REQUEST_HARDWARE') {
+                const h = await this.v1.getHardwareInfo();
+                this.events$.next({
+                    timestamp: ts,
+                    type: 'HARDWARE',
+                    softwareVersion: `${h.major}.${h.minor}.${h.patch}`,
+                    hardwareVersion: `boot:${h.bootCount}`,
+                    gyroSupported: this.capabilities.gyroscope,
+                });
+            }
+            else if (command.type === 'REQUEST_RESET') {
+                await this.v1.setCubeState(MOYU_V1_SOLVED_STICKERS, [0, 0, 0, 0, 0, 0]);
+                this.faceStatus = [0, 0, 0, 0, 0, 0];
+                this.curCubie = new CubieCube();
+                this.prevCubie = new CubieCube();
+                this.events$.next({
+                    timestamp: ts,
+                    type: 'FACELETS',
+                    facelets: SOLVED_FACELET,
+                });
+            }
+        }
+        catch {
+            /* ignore failed optional commands */
+        }
+    }
+    async disconnect() {
+        if (this.readChrct) {
+            this.readChrct.removeEventListener('characteristicvaluechanged', this.onReadEvent);
+            await this.readChrct.stopNotifications().catch(() => { });
+        }
+        if (this.turnChrct) {
+            this.turnChrct.removeEventListener('characteristicvaluechanged', this.onTurnEvent);
+            await this.turnChrct.stopNotifications().catch(() => { });
+        }
+        if (this.gyroChrct) {
+            this.gyroChrct.removeEventListener('characteristicvaluechanged', this.onGyroEvent);
+            await this.gyroChrct.stopNotifications().catch(() => { });
+        }
+        this.lastBatteryLevel = null;
+        if (this.batteryInterval) {
+            clearInterval(this.batteryInterval);
+            this.batteryInterval = null;
+        }
+        this.readChrct = null;
+        this.turnChrct = null;
+        this.gyroChrct = null;
+        this.writeChrct = null;
+        this.v1 = 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 moyuMhcProtocol = {
+    nameFilters: [
+        { namePrefix: "MHC" }
+    ],
+    optionalServices: [SERVICE_UUID],
+    matchesDevice(device) {
+        const name = device.name || '';
+        return name.startsWith('MHC');
+    },
+    gattAffinity(serviceUuids, _device) {
+        return serviceUuids.has(normalizeUuid(SERVICE_UUID)) ? 110 : 0;
+    },
+    async connect(device, _macProvider, _context) {
+        const conn = new MoyuMhcConnection(device);
+        await conn.init();
+        return conn;
+    }
+};
+registerProtocol(moyuMhcProtocol);
+export { moyuMhcProtocol };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/moyu-v1.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="web-bluetooth" />
+declare const MOYU_V1_SOLVED_STICKERS: number[][];
+export interface MoyuV1CubeStatePayload {
+    readonly stickers: number[][];
+    readonly angles: number[];
+}
+export declare function moyuV1ParseCubeStatePayload(t: DataView): MoyuV1CubeStatePayload;
+export declare function moyuV1EncodeCubeStatePayload(stickers: number[][], angles: number[]): Uint8Array;
+/** Build 54-char URFDLB facelet string for CubieCube.fromFacelet. */
+export declare function moyuStickersToFaceletString(stickers: number[][]): string;
+export interface MoyuV1HardwareInfo {
+    readonly bootCount: number;
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+}
+export interface MoyuV1BatteryInfo {
+    readonly charging: boolean;
+    readonly full: boolean;
+    readonly percentage: number;
+    readonly voltage: number;
+}
+export declare class MoyuV1Client {
+    private readonly writeCharacteristic;
+    private readonly idGen;
+    private readonly sendCountGen;
+    private incomplete;
+    private waiters;
+    constructor(writeCharacteristic: BluetoothRemoteGATTCharacteristic);
+    /** Call from 0x1002 notification handler. */
+    onReadNotification(dv: DataView): void;
+    private headerByte;
+    private sendRawRequest;
+    send(command: number, payload?: Uint8Array): Promise<{
+        sentAt: number;
+        receivedAt: number;
+        value: DataView;
+    }>;
+    getCubeState(): Promise<MoyuV1CubeStatePayload>;
+    setCubeState(stickers?: number[][], angles?: number[]): Promise<void>;
+    getBatteryInfo(): Promise<{
+        sentAt: number;
+        receivedAt: number;
+        value: MoyuV1BatteryInfo;
+    }>;
+    getHardwareInfo(): Promise<MoyuV1HardwareInfo>;
+    getTime(): Promise<{
+        sentAt: number;
+        receivedAt: number;
+        value: {
+            seconds: number;
+            counter: number;
+        };
+    }>;
+    setSleepState(state: number): Promise<void>;
+}
+export { MOYU_V1_SOLVED_STICKERS };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/moyu-v1.js

@@ -0,0 +1,243 @@
+import { writeGattCharacteristicValue } from '../../gatt-characteristic-write.js';
+/**
+ * MoYu BLE API v1: fragmented request/response on 0x1001 / 0x1002 and cube-state payload parsing.
+ */
+const MOYU_V1_CMD_TIME = 1;
+const MOYU_V1_CMD_HW = 2;
+const MOYU_V1_CMD_BATTERY = 3;
+const MOYU_V1_CMD_CUBE_STATE = 10;
+const MOYU_V1_CMD_SLEEP = 6;
+/** Sticker id 0–5 → center color letter (MoYu face order D,L,B,R,F,U). */
+const STICKER_ID_TO_COLOR = 'DLBRFU';
+/**
+ * Map MoYu face index × cell (0–8) to URFDLB linear facelet index (U 0–8, R 9–17, …)
+ */
+const MOYU_CELL_TO_STD = [
+    [27, 28, 29, 30, 31, 32, 33, 34, 35],
+    [44, 43, 42, 41, 40, 39, 38, 37, 36],
+    [53, 52, 51, 50, 49, 48, 47, 46, 45],
+    [17, 16, 26, 14, 13, 12, 11, 10, 9],
+    [29, 25, 24, 23, 22, 21, 20, 19, 18],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8],
+];
+const MOYU_V1_SOLVED_STICKERS = [
+    [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 1, 1, 1],
+    [2, 2, 2, 2, 2, 2, 2, 2, 2],
+    [3, 3, 3, 3, 3, 3, 3, 3, 3],
+    [4, 4, 4, 4, 4, 4, 4, 4, 4],
+    [5, 5, 5, 5, 5, 5, 5, 5, 5],
+];
+function parseIncomingPart(dv) {
+    const index = dv.getUint8(1) & 15;
+    const total = dv.getUint8(1) >> 4;
+    const payload = new Uint8Array(dv.buffer, dv.byteOffset + 2, Math.max(0, dv.byteLength - 2));
+    return { index, total, payload };
+}
+function mergeParts(parts) {
+    const sorted = [...parts].sort((a, b) => a.index - b.index);
+    const len = sorted.reduce((n, p) => n + p.payload.length, 0);
+    const out = new Uint8Array(len);
+    let o = 0;
+    for (const p of sorted) {
+        out.set(p.payload, o);
+        o += p.payload.length;
+    }
+    return new DataView(out.buffer);
+}
+function parseResponse(merged, timestamp) {
+    const header = merged.getUint8(0);
+    const command = header & 15;
+    const success = ((header >> 4) & 1) === 1;
+    const id = (header >> 5) & 7;
+    const payload = new DataView(merged.buffer, merged.byteOffset + 1, merged.byteLength - 1);
+    return { command, success, id, timestamp, payload };
+}
+function concatU8(a, b) {
+    const o = new Uint8Array(a.length + b.length);
+    o.set(a);
+    o.set(b, a.length);
+    return o;
+}
+class IdGenerator {
+    lastId = 0;
+    next() {
+        this.lastId = (this.lastId + 1) % 8;
+        return this.lastId;
+    }
+}
+class SendCountGenerator {
+    lastCount = -1;
+    next() {
+        this.lastCount = (this.lastCount + 1) % 256;
+        return this.lastCount;
+    }
+}
+export function moyuV1ParseCubeStatePayload(t) {
+    const stickers = [];
+    for (let s = 0; s < 6; s++) {
+        const r = [];
+        for (let a = 0; a < 9; a++) {
+            const o = t.getUint8(Math.floor((9 * s + a) / 2));
+            r.push((o >> ((9 * s + a) % 2 === 0 ? 0 : 4)) & 15);
+        }
+        stickers.push(r);
+    }
+    const angles = [];
+    for (let s = 0; s < 6; s++) {
+        const row = 27 + Math.floor(s / 2);
+        const a = t.getUint8(row);
+        angles.push((a >> (s % 2 === 0 ? 0 : 4)) & 15);
+    }
+    return { stickers, angles };
+}
+export function moyuV1EncodeCubeStatePayload(stickers, angles) {
+    const e = new Uint8Array(30);
+    const i = new DataView(e.buffer);
+    for (let s = 0; s < 6; s++) {
+        for (let r = 0; r < 9; r++) {
+            const lo = (9 * s + r) % 2 === 0;
+            const o = Math.floor((9 * s + r) / 2);
+            i.setUint8(o, i.getUint8(o) | ((15 & stickers[s][r]) << (lo ? 0 : 4)));
+        }
+    }
+    for (let s = 0; s < 6; s++) {
+        const lo = s % 2 === 0;
+        const row = 27 + Math.floor(s / 2);
+        i.setUint8(row, i.getUint8(row) | ((15 & angles[s]) << (lo ? 0 : 4)));
+    }
+    return e;
+}
+/** Build 54-char URFDLB facelet string for CubieCube.fromFacelet. */
+export function moyuStickersToFaceletString(stickers) {
+    const chars = new Array(54).fill('?');
+    for (let face = 0; face < 6; face++) {
+        const row = MOYU_CELL_TO_STD[face];
+        const stickerRow = stickers[face];
+        for (let p = 0; p < 9; p++) {
+            const id = stickerRow[p] & 15;
+            const c = id < 6 ? STICKER_ID_TO_COLOR[id] : '?';
+            chars[row[p]] = c;
+        }
+    }
+    return chars.join('');
+}
+export class MoyuV1Client {
+    writeCharacteristic;
+    idGen = new IdGenerator();
+    sendCountGen = new SendCountGenerator();
+    incomplete = [];
+    waiters = [];
+    constructor(writeCharacteristic) {
+        this.writeCharacteristic = writeCharacteristic;
+    }
+    /** Call from 0x1002 notification handler. */
+    onReadNotification(dv) {
+        const part = parseIncomingPart(dv);
+        this.incomplete.push(part);
+        if (part.total <= 0 || part.index !== part.total - 1) {
+            return;
+        }
+        const merged = mergeParts(this.incomplete);
+        this.incomplete = [];
+        const receivedAt = Date.now();
+        const r = parseResponse(merged, receivedAt);
+        const idx = this.waiters.findIndex((w) => w.command === r.command && w.id === r.id);
+        if (idx < 0) {
+            return;
+        }
+        const w = this.waiters.splice(idx, 1)[0];
+        clearTimeout(w.timeout);
+        if (!r.success) {
+            w.reject(new Error(`MoYu v1 command ${r.command} failed`));
+            return;
+        }
+        w.resolve({ sentAt: w.sentAt, receivedAt, value: r.payload });
+    }
+    headerByte(command, hasPayload, id) {
+        return command | ((hasPayload ? 1 : 0) << 4) | (id << 5);
+    }
+    async sendRawRequest(body) {
+        const nParts = Math.ceil(body.length / 18);
+        if (nParts > 16)
+            throw new Error('Too many parts');
+        for (let i = 0; i < nParts; i++) {
+            const frame = new Uint8Array(20);
+            const v = new DataView(frame.buffer);
+            v.setUint8(0, this.sendCountGen.next());
+            v.setUint8(1, i | (nParts << 4));
+            const slice = body.subarray(18 * i, 18 * (i + 1));
+            frame.set(slice, 2);
+            await writeGattCharacteristicValue(this.writeCharacteristic, frame);
+        }
+        return Date.now();
+    }
+    async send(command, payload) {
+        const id = this.idGen.next();
+        const hasPayload = payload !== undefined;
+        const h = this.headerByte(command, hasPayload, id);
+        const first = new Uint8Array(1);
+        new DataView(first.buffer).setUint8(0, h);
+        const body = hasPayload && payload !== undefined ? concatU8(first, payload) : first;
+        let waiter;
+        const result = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                const i = this.waiters.findIndex((w) => w.command === command && w.id === id);
+                if (i >= 0)
+                    this.waiters.splice(i, 1);
+                reject(new Error(`MoYu v1 command ${command} timeout`));
+            }, 5000);
+            waiter = { command, id, sentAt: 0, resolve, reject, timeout };
+            this.waiters.push(waiter);
+        });
+        waiter.sentAt = await this.sendRawRequest(body);
+        return result;
+    }
+    async getCubeState() {
+        const r = await this.send(MOYU_V1_CMD_CUBE_STATE);
+        return moyuV1ParseCubeStatePayload(r.value);
+    }
+    async setCubeState(stickers = MOYU_V1_SOLVED_STICKERS, angles = [0, 0, 0, 0, 0, 0]) {
+        const pl = moyuV1EncodeCubeStatePayload(stickers, angles);
+        await this.send(MOYU_V1_CMD_CUBE_STATE, pl);
+    }
+    async getBatteryInfo() {
+        const r = await this.send(MOYU_V1_CMD_BATTERY);
+        const t = r.value;
+        return {
+            sentAt: r.sentAt,
+            receivedAt: r.receivedAt,
+            value: {
+                charging: !!t.getUint8(0),
+                full: !!t.getUint8(1),
+                percentage: t.getUint16(2, true),
+                voltage: t.getInt32(4, true) / 1000,
+            },
+        };
+    }
+    async getHardwareInfo() {
+        const r = await this.send(MOYU_V1_CMD_HW);
+        const t = r.value;
+        return {
+            bootCount: t.getUint32(16, true),
+            major: t.getUint8(20),
+            minor: t.getUint8(21),
+            patch: t.getUint16(22, true),
+        };
+    }
+    async getTime() {
+        const r = await this.send(MOYU_V1_CMD_TIME);
+        const v = r.value;
+        return {
+            sentAt: r.sentAt,
+            receivedAt: r.receivedAt,
+            value: { seconds: v.getUint16(0, true), counter: v.getUint16(2, true) },
+        };
+    }
+    async setSleepState(state) {
+        const e = new Uint8Array(1);
+        new DataView(e.buffer).setUint8(0, state);
+        await this.send(MOYU_V1_CMD_SLEEP, e);
+    }
+}
+export { MOYU_V1_SOLVED_STICKERS };

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

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