@wodzik/cubecore 0.1.0

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/packet-sanity.js

@@ -0,0 +1,142 @@
+/**
+ * Post-decrypt sanity checks for MAC candidate probing.
+ */
+/** Validates decrypted MoYu32 notification bitstream. */
+export function isValidMoYu32DecryptedPacket(bytes) {
+    if (!bytes || bytes.length < 20) {
+        return false;
+    }
+    try {
+        for (let i = 0; i < bytes.length; i++) {
+            if (bytes[i] < 0 || bytes[i] > 255) {
+                return false;
+            }
+        }
+        let z = 0;
+        let f = 0;
+        for (let n = 0; n < Math.min(bytes.length, 20); n++) {
+            if (bytes[n] === 0) {
+                z++;
+            }
+            else if (bytes[n] === 255) {
+                f++;
+            }
+        }
+        if (z > 14 || f > 14 || new Set(bytes.slice(0, 20)).size > 18) {
+            return false;
+        }
+        let n = '';
+        for (let i = 0; i < bytes.length; i++) {
+            n += (bytes[i] + 256).toString(2).slice(1);
+        }
+        const r = parseInt(n.slice(0, 8), 2);
+        return validateMoYu32BitBody(n, r);
+    }
+    catch {
+        return false;
+    }
+}
+function validateMoYu32BitBody(e, t) {
+    if (!e || e.length < 160) {
+        return false;
+    }
+    try {
+        const i = parseInt(e.slice(0, 8), 2);
+        if (i !== t ||
+            ![161, 163, 164, 165, 171].includes(i) ||
+            (i === 164 && parseInt(e.slice(8, 16), 2) > 100)) {
+            return false;
+        }
+        if (i === 161) {
+            for (let k = 0; k < 8; k++) {
+                const v = parseInt(e.slice(8 + 8 * k, 16 + 8 * k), 2);
+                if (v !== 0 && (v < 32 || v > 126)) {
+                    return false;
+                }
+            }
+        }
+        if (i === 165) {
+            let c = 0;
+            for (let j = 0; j < 5; j++) {
+                const v = parseInt(e.slice(96 + 5 * j, 101 + 5 * j), 2);
+                if (v <= 11) {
+                    c++;
+                }
+                else if (v < 31) {
+                    return false;
+                }
+            }
+            if (c === 0) {
+                return false;
+            }
+            let allZero = true;
+            let allMax = true;
+            for (let r = 0; r < c; r++) {
+                const v = parseInt(e.slice(8 + 16 * r, 24 + 16 * r), 2);
+                if (v !== 0) {
+                    allZero = false;
+                }
+                if (v !== 65535) {
+                    allMax = false;
+                }
+            }
+            if (allZero || allMax) {
+                return false;
+            }
+        }
+        if (i === 163) {
+            const body = e.slice(8, 152);
+            const zeros = (body.match(/0/g) || []).length;
+            const ones = (body.match(/1/g) || []).length;
+            if (zeros > 0.9 * body.length || ones > 0.9 * body.length) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Validates decrypted QiYi notification payload. */
+export function isValidQiYiDecryptedPacket(e) {
+    if (!e || e.length < 7) {
+        return false;
+    }
+    try {
+        const t = e[0];
+        if (t === 254) {
+            const cmd = e[1];
+            const sub = e[2];
+            if (![2, 3].includes(sub) || cmd < 7 || cmd > 100) {
+                return false;
+            }
+            const n = (((e[3] << 24) | (e[4] << 16) | (e[5] << 8) | e[6]) >>> 0);
+            if (n === 0 || n === 0xffffffff) {
+                return false;
+            }
+            return true;
+        }
+        if (t === 204 && e[1] === 16) {
+            if (e.length < 16) {
+                return false;
+            }
+            const dv = new DataView(e.buffer, e.byteOffset);
+            const x = dv.getInt16(6, false);
+            const y = dv.getInt16(8, false);
+            const z = dv.getInt16(10, false);
+            const w = dv.getInt16(12, false);
+            if (Math.abs(x) > 2000 ||
+                Math.abs(y) > 2000 ||
+                Math.abs(z) > 2000 ||
+                Math.abs(w) > 2000) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/profile-rank.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="web-bluetooth" />
+import type { SmartCubeProtocol } from '../protocol.js';
+/**
+ * Pick the protocol that best matches the GATT profile. Tie-break with `matchesDevice` (name).
+ */
+export declare function resolveProtocolByGatt(protocols: readonly SmartCubeProtocol[], serviceUuids: ReadonlySet<string>, device: BluetoothDevice): SmartCubeProtocol | null;

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/profile-rank.js

@@ -0,0 +1,21 @@
+/**
+ * Pick the protocol that best matches the GATT profile. Tie-break with `matchesDevice` (name).
+ */
+export function resolveProtocolByGatt(protocols, serviceUuids, device) {
+    const ranked = protocols.map((p) => ({
+        p,
+        score: p.gattAffinity(serviceUuids, device),
+    }));
+    const maxScore = ranked.reduce((m, r) => Math.max(m, r.score), -1);
+    if (maxScore > 0) {
+        const top = ranked.filter((r) => r.score === maxScore);
+        const preferred = top.find((r) => r.p.matchesDevice(device));
+        return (preferred ?? top[0]).p;
+    }
+    for (const p of protocols) {
+        if (p.matchesDevice(device)) {
+            return p;
+        }
+    }
+    return null;
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/types.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="web-bluetooth" />
+/** Context passed after GATT discovery so sessions can reuse known profile data. */
+export interface AttachmentContext {
+    /** Primary service UUIDs (normalized 128-bit uppercase) seen on this connection. */
+    serviceUuids: ReadonlySet<string>;
+    /** Manufacturer data from a pre-connect advertisement pass, if any. */
+    advertisementManufacturerData?: BluetoothManufacturerData | null;
+    /** Longer advertisement / resolution attempts for MAC (QiYi / MoYu32). */
+    enableAddressSearch?: boolean;
+    onStatus?: (message: string) => void;
+    signal?: AbortSignal;
+}
+export type DeviceSelectionMode = 'filtered' | 'any';
+export interface ConnectSmartCubeOptions {
+    macAddressProvider?: import('../types.js').MacAddressProvider;
+    /** `filtered`: name/manufacturer filters. `any`: accept all BLE devices (GATT profile picks the driver). */
+    deviceSelection?: DeviceSelectionMode;
+    /**
+     * When set with `deviceSelection: 'filtered'`, adds exact-name and known-alias scan filters
+     * (helps reconnect when the cube uses a non-prefix-stable advertised name).
+     */
+    deviceName?: string;
+    /** Aborts long-running steps (e.g. MAC candidate probing). */
+    signal?: AbortSignal;
+    /** Called with short status messages during resolution (e.g. MAC search). */
+    onStatus?: (message: string) => void;
+    /**
+     * When true, if advertisement and name hints fail for QiYi / MoYu32, try a bounded set of MAC candidates
+     * derived from the device name (slow; default false).
+     */
+    enableAddressSearch?: boolean;
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/types.js

@@ -0,0 +1 @@
+export {};

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/ble-utils.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="web-bluetooth" />
+import { now } from '../utils.js';
+declare function findCharacteristic(characteristics: BluetoothRemoteGATTCharacteristic[], uuid: string): BluetoothRemoteGATTCharacteristic | null;
+declare function waitForAdvertisements(device: BluetoothDevice, timeoutMs?: number): Promise<BluetoothManufacturerData | null>;
+declare function extractMacFromManufacturerData(mfData: BluetoothManufacturerData | DataView | null, cicList: number[], reversedByteOrder?: boolean): string | null;
+export { now, findCharacteristic, waitForAdvertisements, extractMacFromManufacturerData };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/ble-utils.js

@@ -0,0 +1,68 @@
+import { now } from '../utils.js';
+function toUuid128(uuid) {
+    if (/^[0-9A-Fa-f]{4}$/.exec(uuid)) {
+        uuid = "0000" + uuid + "-0000-1000-8000-00805F9B34FB";
+    }
+    return uuid.toUpperCase();
+}
+function findCharacteristic(characteristics, uuid) {
+    const targetUuid = toUuid128(uuid);
+    for (const chrct of characteristics) {
+        if (toUuid128(chrct.uuid) === targetUuid) {
+            return chrct;
+        }
+    }
+    return null;
+}
+async function waitForAdvertisements(device, timeoutMs = 5000) {
+    if (typeof device.watchAdvertisements !== 'function') {
+        return null;
+    }
+    return new Promise((resolve) => {
+        const abortController = new AbortController();
+        const onAdvEvent = (evt) => {
+            device.removeEventListener('advertisementreceived', onAdvEvent);
+            abortController.abort();
+            resolve(evt.manufacturerData);
+        };
+        const onAbort = () => {
+            device.removeEventListener('advertisementreceived', onAdvEvent);
+            abortController.abort();
+            resolve(null);
+        };
+        device.addEventListener('advertisementreceived', onAdvEvent);
+        device.watchAdvertisements({ signal: abortController.signal }).catch(onAbort);
+        setTimeout(onAbort, timeoutMs);
+    });
+}
+function extractMacFromManufacturerData(mfData, cicList, reversedByteOrder = true) {
+    if (!mfData)
+        return null;
+    let dataView;
+    if (mfData instanceof DataView) {
+        dataView = new DataView(mfData.buffer.slice(2));
+    }
+    else {
+        for (const id of cicList) {
+            if (mfData.has(id)) {
+                dataView = mfData.get(id);
+                break;
+            }
+        }
+    }
+    if (!dataView || dataView.byteLength < 6)
+        return null;
+    const mac = [];
+    if (reversedByteOrder) {
+        for (let i = 5; i >= 0; i--) {
+            mac.push((dataView.getUint8(i) + 0x100).toString(16).slice(1));
+        }
+    }
+    else {
+        for (let i = dataView.byteLength - 1; i >= dataView.byteLength - 6; i--) {
+            mac.push((dataView.getUint8(i) + 0x100).toString(16).slice(1));
+        }
+    }
+    return mac.join(':');
+}
+export { now, findCharacteristic, waitForAdvertisements, extractMacFromManufacturerData };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/connect.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectSmartCubeOptions } from './attachment/types.js';
+import type { MacAddressProvider, SmartCubeConnection } from './types.js';
+export declare function connectSmartCube(arg?: MacAddressProvider | ConnectSmartCubeOptions): Promise<SmartCubeConnection>;

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

@@ -0,0 +1,178 @@
+import { filter, take, TimeoutError } from 'rxjs';
+import { buildRequestDeviceOptions } from './attachment/build-picker-options.js';
+import { collectPrimaryServiceUuids } from './attachment/gatt-snapshot.js';
+import { resolveProtocolByGatt } from './attachment/profile-rank.js';
+import { removeCachedMacForDevice, setCachedMacForDevice, waitForManufacturerData, } from './attachment/address-hints.js';
+import { CubieCube } from './cubie-cube.js';
+import { getRegisteredProtocols } from './protocol.js';
+/**
+ * MoYu-style payloads always yield 54-char FACELETS from {U,F,R,B,L,D} even when AES decrypt is wrong;
+ * event-type checks are insufficient. A legal 3×3 state requires consistent sticker counts + geometry.
+ */
+function isMacCacheProofEvent(e) {
+    if (e.type !== 'FACELETS') {
+        return false;
+    }
+    return new CubieCube().fromFacelet(e.facelets) !== -1;
+}
+const MAC_VERIFY_TIMEOUT_MS = 10_000;
+/**
+ * After we subscribe for MAC proof, ask the cube for a fresh report. Init often emits
+ * FACELETS before this subscription exists (Subject does not replay), so without this
+ * we can time out even with a correct MAC. Fire-and-forget so a stuck write cannot
+ * block verification or leave the UI on "Verifying…" indefinitely.
+ */
+function requestFreshStateForMacVerify(conn) {
+    const c = conn.capabilities;
+    const p = c.facelets
+        ? conn.sendCommand({ type: 'REQUEST_FACELETS' })
+        : c.hardware
+            ? conn.sendCommand({ type: 'REQUEST_HARDWARE' })
+            : c.battery
+                ? conn.sendCommand({ type: 'REQUEST_BATTERY' })
+                : Promise.resolve();
+    p.catch(() => { });
+}
+/**
+ * Wait until we see decrypted/valid cube traffic so we do not persist a wrong MAC
+ * (GAN / MoYu32 / QiYi can complete GATT setup before crypto is proven).
+ */
+function waitForVerifiedCubeEvent(conn, timeoutMs, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timer;
+        let sub;
+        const cleanup = () => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            sub?.unsubscribe();
+            sub = undefined;
+            if (signal) {
+                signal.removeEventListener('abort', onAbort);
+            }
+        };
+        const finish = (action) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            action();
+        };
+        const onAbort = () => {
+            finish(() => reject(new DOMException('Aborted', 'AbortError')));
+        };
+        if (signal) {
+            if (signal.aborted) {
+                finish(() => reject(new DOMException('Aborted', 'AbortError')));
+                return;
+            }
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+        timer = setTimeout(() => {
+            finish(() => reject(new TimeoutError({
+                seen: 0,
+                lastValue: null,
+                meta: null,
+            })));
+        }, timeoutMs);
+        sub = conn.events$.pipe(filter(isMacCacheProofEvent), take(1)).subscribe({
+            next: () => {
+                finish(() => resolve());
+            },
+            error: (err) => {
+                finish(() => reject(err));
+            },
+        });
+    });
+}
+function isMacAddressProvider(x) {
+    return typeof x === 'function';
+}
+function normalizeOptions(arg) {
+    if (arg === undefined) {
+        return {};
+    }
+    if (isMacAddressProvider(arg)) {
+        return { macAddressProvider: arg };
+    }
+    return arg;
+}
+export async function connectSmartCube(arg) {
+    const opts = normalizeOptions(arg);
+    const protocols = getRegisteredProtocols();
+    if (protocols.length === 0) {
+        throw new Error('No smartcube protocols registered');
+    }
+    const mode = opts.deviceSelection ?? 'filtered';
+    const requestOptions = buildRequestDeviceOptions(protocols, mode, {
+        deviceName: opts.deviceName,
+    });
+    opts.onStatus?.('Select your cube…');
+    const device = await navigator.bluetooth.requestDevice(requestOptions);
+    opts.onStatus?.('Reading advertisements…');
+    const advertisementManufacturerData = await waitForManufacturerData(device, opts.enableAddressSearch ? 8000 : 2500);
+    opts.onStatus?.('Connecting…');
+    const serviceUuids = await collectPrimaryServiceUuids(device);
+    const protocol = resolveProtocolByGatt(protocols, serviceUuids, device);
+    if (!protocol) {
+        try {
+            device.gatt?.disconnect();
+        }
+        catch {
+            /* ignore */
+        }
+        throw new Error("Selected device doesn't match any registered smartcube protocol");
+    }
+    const context = {
+        serviceUuids,
+        advertisementManufacturerData,
+        enableAddressSearch: opts.enableAddressSearch === true,
+        onStatus: opts.onStatus,
+        signal: opts.signal,
+    };
+    let conn;
+    try {
+        conn = await protocol.connect(device, opts.macAddressProvider, context);
+    }
+    catch (e) {
+        try {
+            device.gatt?.disconnect();
+        }
+        catch {
+            /* ignore */
+        }
+        throw e;
+    }
+    if (conn.deviceMAC) {
+        opts.onStatus?.('Verifying connection…');
+        try {
+            const verifyPromise = waitForVerifiedCubeEvent(conn, MAC_VERIFY_TIMEOUT_MS, opts.signal);
+            requestFreshStateForMacVerify(conn);
+            await verifyPromise;
+        }
+        catch (e) {
+            const aborted = e instanceof DOMException && e.name === 'AbortError';
+            if (!aborted) {
+                removeCachedMacForDevice(device);
+            }
+            try {
+                device.gatt?.disconnect();
+            }
+            catch {
+                /* ignore */
+            }
+            if (aborted) {
+                throw e;
+            }
+            if (e instanceof TimeoutError) {
+                throw new Error('Timed out waiting for cube data. Check the Bluetooth MAC address and try again.');
+            }
+            throw e;
+        }
+        setCachedMacForDevice(device, conn.deviceMAC);
+    }
+    return conn;
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/cubie-cube.d.ts

@@ -0,0 +1,16 @@
+declare const SOLVED_FACELET = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB";
+declare const cFacelet: number[][];
+declare const eFacelet: number[][];
+declare class CubieCube {
+    ca: number[];
+    ea: number[];
+    constructor();
+    init(ca: number[], ea: number[]): CubieCube;
+    static EdgeMult(a: CubieCube, b: CubieCube, prod: CubieCube): void;
+    static CornMult(a: CubieCube, b: CubieCube, prod: CubieCube): void;
+    static CubeMult(a: CubieCube, b: CubieCube, prod: CubieCube): void;
+    toFaceCube(customCFacelet?: number[][], customEFacelet?: number[][]): string;
+    fromFacelet(facelet: string, customCFacelet?: number[][], customEFacelet?: number[][]): CubieCube | -1;
+    static moveCube: CubieCube[];
+}
+export { CubieCube, SOLVED_FACELET, cFacelet, eFacelet };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/cubie-cube.js

@@ -0,0 +1,141 @@
+const SOLVED_FACELET = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB";
+const cFacelet = [
+    [8, 9, 20], // URF
+    [6, 18, 38], // UFL
+    [0, 36, 47], // ULB
+    [2, 45, 11], // UBR
+    [29, 26, 15], // DFR
+    [27, 44, 24], // DLF
+    [33, 53, 42], // DBL
+    [35, 17, 51] // DRB
+];
+const eFacelet = [
+    [5, 10], // UR
+    [7, 19], // UF
+    [3, 37], // UL
+    [1, 46], // UB
+    [32, 16], // DR
+    [28, 25], // DF
+    [30, 43], // DL
+    [34, 52], // DB
+    [23, 12], // FR
+    [21, 41], // FL
+    [50, 39], // BL
+    [48, 14] // BR
+];
+class CubieCube {
+    ca;
+    ea;
+    constructor() {
+        this.ca = [0, 1, 2, 3, 4, 5, 6, 7];
+        this.ea = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22];
+    }
+    init(ca, ea) {
+        this.ca = ca.slice();
+        this.ea = ea.slice();
+        return this;
+    }
+    static EdgeMult(a, b, prod) {
+        for (let ed = 0; ed < 12; ed++) {
+            prod.ea[ed] = a.ea[b.ea[ed] >> 1] ^ (b.ea[ed] & 1);
+        }
+    }
+    static CornMult(a, b, prod) {
+        for (let corn = 0; corn < 8; corn++) {
+            const ori = ((a.ca[b.ca[corn] & 7] >> 3) + (b.ca[corn] >> 3)) % 3;
+            prod.ca[corn] = (a.ca[b.ca[corn] & 7] & 7) | (ori << 3);
+        }
+    }
+    static CubeMult(a, b, prod) {
+        CubieCube.CornMult(a, b, prod);
+        CubieCube.EdgeMult(a, b, prod);
+    }
+    toFaceCube(customCFacelet, customEFacelet) {
+        const cf = customCFacelet || cFacelet;
+        const ef = customEFacelet || eFacelet;
+        const f = [];
+        for (let i = 0; i < 54; i++) {
+            f[i] = i;
+        }
+        for (let c = 0; c < 8; c++) {
+            const j = this.ca[c] & 0x7;
+            const ori = this.ca[c] >> 3;
+            for (let n = 0; n < 3; n++) {
+                f[cf[c][(n + ori) % 3]] = cf[j][n];
+            }
+        }
+        for (let e = 0; e < 12; e++) {
+            const j = this.ea[e] >> 1;
+            const ori = this.ea[e] & 1;
+            for (let n = 0; n < 2; n++) {
+                f[ef[e][(n + ori) % 2]] = ef[j][n];
+            }
+        }
+        const ts = "URFDLB";
+        return f.map(v => ts[~~(v / 9)]).join("");
+    }
+    fromFacelet(facelet, customCFacelet, customEFacelet) {
+        const cf = customCFacelet || cFacelet;
+        const ef = customEFacelet || eFacelet;
+        let count = 0;
+        const fArr = [];
+        const centers = facelet[4] + facelet[13] + facelet[22] + facelet[31] + facelet[40] + facelet[49];
+        for (let i = 0; i < 54; ++i) {
+            fArr[i] = centers.indexOf(facelet[i]);
+            if (fArr[i] == -1) {
+                return -1;
+            }
+            count += 1 << (fArr[i] << 2);
+        }
+        if (count != 0x999999) {
+            return -1;
+        }
+        for (let i = 0; i < 8; ++i) {
+            let ori;
+            for (ori = 0; ori < 3; ++ori) {
+                if (fArr[cf[i][ori]] == 0 || fArr[cf[i][ori]] == 3)
+                    break;
+            }
+            const col1 = fArr[cf[i][(ori + 1) % 3]];
+            const col2 = fArr[cf[i][(ori + 2) % 3]];
+            for (let j = 0; j < 8; ++j) {
+                if (col1 == ~~(cf[j][1] / 9) && col2 == ~~(cf[j][2] / 9)) {
+                    this.ca[i] = j | ((ori % 3) << 3);
+                    break;
+                }
+            }
+        }
+        for (let i = 0; i < 12; ++i) {
+            for (let j = 0; j < 12; ++j) {
+                if (fArr[ef[i][0]] == ~~(ef[j][0] / 9) && fArr[ef[i][1]] == ~~(ef[j][1] / 9)) {
+                    this.ea[i] = j << 1;
+                    break;
+                }
+                if (fArr[ef[i][0]] == ~~(ef[j][1] / 9) && fArr[ef[i][1]] == ~~(ef[j][0] / 9)) {
+                    this.ea[i] = j << 1 | 1;
+                    break;
+                }
+            }
+        }
+        return this;
+    }
+    static moveCube = (() => {
+        const mc = [];
+        for (let i = 0; i < 18; i++) {
+            mc[i] = new CubieCube();
+        }
+        mc[0].init([3, 0, 1, 2, 4, 5, 6, 7], [6, 0, 2, 4, 8, 10, 12, 14, 16, 18, 20, 22]); // U
+        mc[3].init([20, 1, 2, 8, 15, 5, 6, 19], [16, 2, 4, 6, 22, 10, 12, 14, 8, 18, 20, 0]); // R
+        mc[6].init([9, 21, 2, 3, 16, 12, 6, 7], [0, 19, 4, 6, 8, 17, 12, 14, 3, 11, 20, 22]); // F
+        mc[9].init([0, 1, 2, 3, 5, 6, 7, 4], [0, 2, 4, 6, 10, 12, 14, 8, 16, 18, 20, 22]); // D
+        mc[12].init([0, 10, 22, 3, 4, 17, 13, 7], [0, 2, 20, 6, 8, 10, 18, 14, 16, 4, 12, 22]); // L
+        mc[15].init([0, 1, 11, 23, 4, 5, 18, 14], [0, 2, 4, 23, 8, 10, 12, 21, 16, 18, 7, 15]); // B
+        for (let a = 0; a < 18; a += 3) {
+            for (let p = 0; p < 2; p++) {
+                CubieCube.CubeMult(mc[a + p], mc[a], mc[a + p + 1]);
+            }
+        }
+        return mc;
+    })();
+}
+export { CubieCube, SOLVED_FACELET, cFacelet, eFacelet };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/index.d.ts

@@ -0,0 +1,11 @@
+import './protocols/gan.js';
+import './protocols/giiker.js';
+import './protocols/gocube.js';
+import './protocols/moyu-mhc.js';
+import './protocols/moyu32.js';
+import './protocols/qiyi.js';
+export type { SmartCubeEvent, SmartCubeEventMessage, SmartCubeMoveEvent, SmartCubeFaceletsEvent, SmartCubeGyroEvent, SmartCubeBatteryEvent, SmartCubeProtocolInfo, SmartCubeHardwareEvent, SmartCubeDisconnectEvent, SmartCubeCommand, SmartCubeCapabilities, SmartCubeConnection } from './types.js';
+export { connectSmartCube } from './connect.js';
+export { getCachedMacForDevice, removeCachedMacForDevice } from './attachment/address-hints.js';
+export type { SmartCubeProtocol, SmartCubeNameFilter, AttachmentContext, ConnectSmartCubeOptions, DeviceSelectionMode } from './protocol.js';
+export { registerProtocol, getRegisteredProtocols } from './protocol.js';

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

@@ -0,0 +1,10 @@
+// Register all protocols (side-effect imports)
+import './protocols/gan.js';
+import './protocols/giiker.js';
+import './protocols/gocube.js';
+import './protocols/moyu-mhc.js';
+import './protocols/moyu32.js';
+import './protocols/qiyi.js';
+export { connectSmartCube } from './connect.js';
+export { getCachedMacForDevice, removeCachedMacForDevice } from './attachment/address-hints.js';
+export { registerProtocol, getRegisteredProtocols } from './protocol.js';

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocol.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="web-bluetooth" />
+import type { AttachmentContext } from './attachment/types.js';
+import { SmartCubeConnection, MacAddressProvider } from './types.js';
+/** Single OR branch for `requestDevice` (`namePrefix`, exact `name`, or both via multiple entries). */
+export type SmartCubeNameFilter = {
+    namePrefix: string;
+} | {
+    name: string;
+};
+interface SmartCubeProtocol {
+    nameFilters: SmartCubeNameFilter[];
+    optionalServices: string[];
+    optionalManufacturerData?: number[];
+    matchesDevice(device: BluetoothDevice): boolean;
+    /**
+     * Higher scores win when choosing a driver from primary service UUIDs.
+     * Use 0 when this profile does not match the GATT snapshot.
+     */
+    gattAffinity(serviceUuids: ReadonlySet<string>, device: BluetoothDevice): number;
+    connect(device: BluetoothDevice, macProvider?: MacAddressProvider, context?: AttachmentContext): Promise<SmartCubeConnection>;
+}
+declare function registerProtocol(protocol: SmartCubeProtocol): void;
+declare function getRegisteredProtocols(): SmartCubeProtocol[];
+export type { SmartCubeProtocol };
+export { registerProtocol, getRegisteredProtocols };
+export type { AttachmentContext, ConnectSmartCubeOptions, DeviceSelectionMode } from './attachment/types.js';