cubing 0.27.0 → 0.28.2

package/README.md

@@ -15,7 +15,7 @@ Twizzle</a> is the spiritual successor to [alg.cubing.net](https://alg.cubing.ne
 
 ## Getting started
 
-If you're just getting started, the easiest way to use `cubing.js` is throught `cdn.cubing.net`:
+If you're just getting started, the easiest way to use `cubing.js` is through `cdn.cubing.net`:
 
 ```html
 <script src="https://cdn.cubing.net/js/cubing/twisty" type="module"></script>
@@ -39,6 +39,8 @@ import { Alg } from "cubing/alg";
 import { TwistyPlayer } from "cubing/twisty";
 ```
 
+Please note that `cubing.js` requires ES2020 module compatibility. See [here](https://js.cubing.net/cubing/#javascript).
+
 ## Contributing
 
 If you would like to contribute to the development of `cubing.js`, please refer to our [contribution guidelines](./CONTRIBUTING.md).

package/dist/esm/alg/index.js

@@ -12,13 +12,13 @@ import {
   QuantumMove,
   TraversalDownUp,
   TraversalUp,
-  algCubingNetLink,
+  experimentalAlgCubingNetLink,
   experimentalAppendMove,
   experimentalIs,
   keyToMove,
   setAlgDebug
-} from "../chunk-NQORDEXF.js";
-import "../chunk-MGJA5U5O.js";
+} from "../chunk-PCR6JT2W.js";
+import "../chunk-SBZRVSPK.js";
 export {
   Alg,
   AlgBuilder,
@@ -33,7 +33,7 @@ export {
   QuantumMove,
   TraversalDownUp,
   TraversalUp,
-  algCubingNetLink,
+  experimentalAlgCubingNetLink,
   experimentalAppendMove,
   experimentalIs,
   keyToMove,

package/dist/esm/bluetooth/index.js

@@ -1,23 +1,23 @@
 import {
   binaryComponentsToReid3x3x3,
   twizzleBinaryToBinaryComponents
-} from "../chunk-AU3UW5N4.js";
+} from "../chunk-PTUPP5AW.js";
 import {
   puzzles
-} from "../chunk-LNUPGLIU.js";
+} from "../chunk-D4YYXJDB.js";
 import {
   experimental3x3x3KPuzzle
-} from "../chunk-VYMKSHDI.js";
+} from "../chunk-TX2AQ4XW.js";
 import {
   KState
-} from "../chunk-VY7VF4MA.js";
+} from "../chunk-5744RHHG.js";
 import {
   Alg,
   Move,
   experimentalAppendMove,
   keyToMove
-} from "../chunk-NQORDEXF.js";
-import "../chunk-MGJA5U5O.js";
+} from "../chunk-PCR6JT2W.js";
+import "../chunk-SBZRVSPK.js";
 
 // src/cubing/bluetooth/debug.ts
 var DEBUG_LOGGING_ENABLED = false;
@@ -64,7 +64,7 @@ var m = {
   "-x z": new Quaternion(0, 0, s2, s2)
 };
 var BasicRotationTransformer = class {
-  transformMove(_moveEvent) {
+  transformAlgLeaf(_algLeafEvent) {
   }
   transformOrientation(orientationEvent) {
     const { x, y, z, w } = orientationEvent.quaternion;
@@ -94,7 +94,7 @@ var BluetoothPuzzle = class extends EventTarget {
   async getState() {
     throw new Error("cannot get state");
   }
-  addMoveListener(listener) {
+  addAlgLeafListener(listener) {
     this.listeners.push(listener);
   }
   addOrientationListener(listener) {
@@ -103,12 +103,12 @@ var BluetoothPuzzle = class extends EventTarget {
   experimentalAddBasicRotationTransformer() {
     this.transformers.push(new BasicRotationTransformer());
   }
-  dispatchMove(moveEvent) {
+  dispatchAlgLeaf(algLeaf) {
     for (const transformer of this.transformers) {
-      transformer.transformMove(moveEvent);
+      transformer.transformAlgLeaf(algLeaf);
     }
     for (const l of this.listeners) {
-      l(moveEvent);
+      l(algLeaf);
     }
   }
   dispatchOrientation(orientationEvent) {
@@ -151,12 +151,12 @@ var KeyboardPuzzle = class extends BluetoothPuzzle {
     if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) {
       return;
     }
-    const move = keyToMove(e);
-    if (move) {
-      const newState = (await this.state).applyMove(move);
+    const algLeaf = keyToMove(e);
+    if (algLeaf) {
+      const newState = (await this.state).applyAlg(new Alg([algLeaf]));
       this.state = Promise.resolve(newState);
-      this.dispatchMove({
-        latestMove: move,
+      this.dispatchAlgLeaf({
+        latestAlgLeaf: algLeaf,
         timeStamp: e.timeStamp,
         state: newState
       });
@@ -181,7 +181,9 @@ function requestOptions(configs, acceptAllDevices = false) {
     if (!acceptAllDevices) {
       options.filters = options.filters.concat(config.filters);
     }
-    options.optionalServices = options.optionalServices.concat(config.optionalServices);
+    options.optionalServices = options.optionalServices.concat(
+      config.optionalServices
+    );
   }
   debugLog({ requestOptions: options });
   return options;
@@ -194,10 +196,14 @@ async function bluetoothConnect(configs, options = {}) {
   try {
     let acceptAllDevices = options.acceptAllDevices;
     if (!acceptAllDevices && consecutiveFailures >= MAX_FAILURES_BEFORE_ACCEPT_ALL_FALLBACK) {
-      console.info(`The last ${MAX_FAILURES_BEFORE_ACCEPT_ALL_FALLBACK} Bluetooth puzzle connection attempts failed. This time, the Bluetooth prompt will show all possible devices.`);
+      console.info(
+        `The last ${MAX_FAILURES_BEFORE_ACCEPT_ALL_FALLBACK} Bluetooth puzzle connection attempts failed. This time, the Bluetooth prompt will show all possible devices.`
+      );
       acceptAllDevices = true;
     }
-    device = await navigator.bluetooth.requestDevice(requestOptions(configs, acceptAllDevices));
+    device = await navigator.bluetooth.requestDevice(
+      requestOptions(configs, acceptAllDevices)
+    );
     consecutiveFailures = 0;
   } catch (e) {
     consecutiveFailures++;
@@ -226,7 +232,9 @@ import { Quaternion as Quaternion2 } from "three";
 // src/cubing/vendor/unsafe-raw-aes/unsafe-raw-aes.ts
 var blockSize = 16;
 var zeros = new Uint8Array(blockSize);
-var paddingBlockPlaintext = new Uint8Array(new Array(blockSize).fill(blockSize));
+var paddingBlockPlaintext = new Uint8Array(
+  new Array(blockSize).fill(blockSize)
+);
 var AES_CBC = "AES-CBC";
 async function importKey(keyBytes) {
   return await crypto.subtle.importKey("raw", keyBytes, AES_CBC, true, [
@@ -235,21 +243,33 @@ async function importKey(keyBytes) {
   ]);
 }
 async function unsafeEncryptBlockWithIV(key, plaintextBlock, iv) {
-  const cryptoResult = await window.crypto.subtle.encrypt({
-    name: AES_CBC,
-    iv
-  }, key, plaintextBlock);
+  const cryptoResult = await window.crypto.subtle.encrypt(
+    {
+      name: AES_CBC,
+      iv
+    },
+    key,
+    plaintextBlock
+  );
   return cryptoResult.slice(0, blockSize);
 }
 async function unsafeDecryptBlock(key, ciphertextBlock) {
-  const paddingBlock = await unsafeEncryptBlockWithIV(key, paddingBlockPlaintext, ciphertextBlock);
+  const paddingBlock = await unsafeEncryptBlockWithIV(
+    key,
+    paddingBlockPlaintext,
+    ciphertextBlock
+  );
   const cbcCiphertext = new Uint8Array(2 * blockSize);
   cbcCiphertext.set(new Uint8Array(ciphertextBlock), 0);
   cbcCiphertext.set(new Uint8Array(paddingBlock), blockSize);
-  const cryptoResult = await window.crypto.subtle.decrypt({
-    name: AES_CBC,
-    iv: zeros
-  }, key, cbcCiphertext);
+  const cryptoResult = await window.crypto.subtle.decrypt(
+    {
+      name: AES_CBC,
+      iv: zeros
+    },
+    key,
+    cbcCiphertext
+  );
   return cryptoResult.slice(0, blockSize);
 }
 
@@ -316,7 +336,10 @@ async function decryptState(data, aesKey) {
   }
   const copy = new Uint8Array(data);
   copy.set(new Uint8Array(await unsafeDecryptBlock(aesKey, copy.slice(3))), 3);
-  copy.set(new Uint8Array(await unsafeDecryptBlock(aesKey, copy.slice(0, 16))), 0);
+  copy.set(
+    new Uint8Array(await unsafeDecryptBlock(aesKey, copy.slice(0, 16))),
+    0
+  );
   if (probablyDecodedCorrectly(copy)) {
     return copy;
   }
@@ -333,7 +356,10 @@ var PhysicalState = class {
     }
   }
   static async read(characteristic, aesKey) {
-    const value = await decryptState(new Uint8Array((await characteristic.readValue()).buffer), aesKey);
+    const value = await decryptState(
+      new Uint8Array((await characteristic.readValue()).buffer),
+      aesKey
+    );
     const timeStamp = Date.now();
     return new PhysicalState(new DataView(value.buffer), timeStamp);
   }
@@ -360,7 +386,9 @@ var PhysicalState = class {
     if (n < 0 || n > MAX_LATEST_MOVES) {
       throw new Error(`Must ask for 0 to 6 latest moves. (Asked for ${n})`);
     }
-    return Array.from(this.arr.slice(19 - n, 19)).map((i) => ganMoveToBlockMove[i]);
+    return Array.from(this.arr.slice(19 - n, 19)).map(
+      (i) => ganMoveToBlockMove[i]
+    );
   }
   debugInfo() {
     return {
@@ -401,7 +429,10 @@ var commands = {
   ])
 };
 function buf2hex(buffer) {
-  return Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join(" ");
+  return Array.prototype.map.call(
+    new Uint8Array(buffer),
+    (x) => ("00" + x.toString(16)).slice(-2)
+  ).join(" ");
 }
 var reidEdgeOrder = "UF UR UB UL DF DR DB DL FR FL BR BL".split(" ");
 var reidCornerOrder = "UFR URB UBL ULF DRF DFL DLB DBR".split(" ");
@@ -446,15 +477,23 @@ var gan356iEdgeMappings = [
 var faceOrder = "URFDLB";
 async function getKey(server) {
   const infoService = await server.getPrimaryService(UUIDs.infoService);
-  const versionCharacteristic = await infoService.getCharacteristic(UUIDs.versionCharacteristic);
-  const versionBuffer = new Uint8Array((await versionCharacteristic.readValue()).buffer);
+  const versionCharacteristic = await infoService.getCharacteristic(
+    UUIDs.versionCharacteristic
+  );
+  const versionBuffer = new Uint8Array(
+    (await versionCharacteristic.readValue()).buffer
+  );
   const versionValue = ((versionBuffer[0] << 8) + versionBuffer[1] << 8) + versionBuffer[2];
   if (versionValue < 65544) {
     return null;
   }
   const keyXor = versionValue < 65792 ? key10 : key11;
-  const systemIDCharacteristic = await infoService.getCharacteristic(UUIDs.systemIDCharacteristic);
-  const systemID = new Uint8Array((await systemIDCharacteristic.readValue()).buffer).reverse();
+  const systemIDCharacteristic = await infoService.getCharacteristic(
+    UUIDs.systemIDCharacteristic
+  );
+  const systemID = new Uint8Array(
+    (await systemIDCharacteristic.readValue()).buffer
+  ).reverse();
   const key = new Uint8Array(keyXor);
   for (let i = 0; i < systemID.length; i++) {
     key[i] = (key[i] + systemID[i]) % 256;
@@ -478,12 +517,21 @@ var GanCube = class extends BluetoothPuzzle {
   static async connect(server) {
     const ganCubeService = await server.getPrimaryService(UUIDs.ganCubeService);
     debugLog("Service:", ganCubeService);
-    const physicalStateCharacteristic = await ganCubeService.getCharacteristic(UUIDs.physicalStateCharacteristic);
+    const physicalStateCharacteristic = await ganCubeService.getCharacteristic(
+      UUIDs.physicalStateCharacteristic
+    );
     debugLog("Characteristic:", physicalStateCharacteristic);
     const aesKey = await getKey(server);
     const initialMoveCounter = (await PhysicalState.read(physicalStateCharacteristic, aesKey)).moveCounter();
     debugLog("Initial Move Counter:", initialMoveCounter);
-    const cube = new GanCube(await puzzles["3x3x3"].kpuzzle(), ganCubeService, server, physicalStateCharacteristic, initialMoveCounter, aesKey);
+    const cube = new GanCube(
+      await puzzles["3x3x3"].kpuzzle(),
+      ganCubeService,
+      server,
+      physicalStateCharacteristic,
+      initialMoveCounter,
+      aesKey
+    );
     return cube;
   }
   name() {
@@ -493,7 +541,10 @@ var GanCube = class extends BluetoothPuzzle {
     this.server.disconnect();
   }
   startTrackingMoves() {
-    this.intervalHandle = window.setInterval(this.intervalHandler.bind(this), this.INTERVAL_MS);
+    this.intervalHandle = window.setInterval(
+      this.intervalHandler.bind(this),
+      this.INTERVAL_MS
+    );
   }
   stopTrackingMoves() {
     if (!this.intervalHandle) {
@@ -503,16 +554,21 @@ var GanCube = class extends BluetoothPuzzle {
     this.intervalHandle = null;
   }
   async intervalHandler() {
-    const physicalState = await PhysicalState.read(this.physicalStateCharacteristic, this.aesKey);
+    const physicalState = await PhysicalState.read(
+      this.physicalStateCharacteristic,
+      this.aesKey
+    );
     let numInterveningMoves = physicalState.numMovesSince(this.lastMoveCounter);
     if (numInterveningMoves > MAX_LATEST_MOVES) {
-      debugLog(`Too many moves! Dropping ${numInterveningMoves - MAX_LATEST_MOVES} moves`);
+      debugLog(
+        `Too many moves! Dropping ${numInterveningMoves - MAX_LATEST_MOVES} moves`
+      );
       numInterveningMoves = MAX_LATEST_MOVES;
     }
     for (const move of physicalState.latestMoves(numInterveningMoves)) {
       this.state = this.state.applyMove(move);
-      this.dispatchMove({
-        latestMove: move,
+      this.dispatchAlgLeaf({
+        latestAlgLeaf: move,
         timeStamp: physicalState.timeStamp,
         debug: physicalState.debugInfo(),
         state: this.state
@@ -525,10 +581,15 @@ var GanCube = class extends BluetoothPuzzle {
     this.lastMoveCounter = physicalState.moveCounter();
   }
   async getBattery() {
-    return new Uint8Array(await this.readActualAngleAndBatteryCharacteristic())[7];
+    return new Uint8Array(
+      await this.readActualAngleAndBatteryCharacteristic()
+    )[7];
   }
   async getState() {
-    const arr = await decryptState(new Uint8Array(await this.readFaceletStatus1Characteristic()), this.aesKey);
+    const arr = await decryptState(
+      new Uint8Array(await this.readFaceletStatus1Characteristic()),
+      this.aesKey
+    );
     const stickers = [];
     for (let i = 0; i < 18; i += 3) {
       let v = ((arr[i ^ 1] << 8) + arr[i + 1 ^ 1] << 8) + arr[i + 2 ^ 1];
@@ -716,13 +777,20 @@ var GiiKERCube = class extends BluetoothPuzzle {
   static async connect(server) {
     const cubeService = await server.getPrimaryService(UUIDs2.cubeService);
     debugLog("Service:", cubeService);
-    const cubeCharacteristic = await cubeService.getCharacteristic(UUIDs2.cubeCharacteristic);
+    const cubeCharacteristic = await cubeService.getCharacteristic(
+      UUIDs2.cubeCharacteristic
+    );
     debugLog("Characteristic:", cubeCharacteristic);
-    const originalValue = await decodeState(new Uint8Array((await cubeCharacteristic.readValue()).buffer));
+    const originalValue = await decodeState(
+      new Uint8Array((await cubeCharacteristic.readValue()).buffer)
+    );
     debugLog("Original value:", originalValue);
     const cube = new GiiKERCube(server, cubeCharacteristic, originalValue);
     await cubeCharacteristic.startNotifications();
-    cubeCharacteristic.addEventListener("characteristicvaluechanged", cube.onCubeCharacteristicChanged.bind(cube));
+    cubeCharacteristic.addEventListener(
+      "characteristicvaluechanged",
+      cube.onCubeCharacteristicChanged.bind(cube)
+    );
     return cube;
   }
   name() {
@@ -732,7 +800,9 @@ var GiiKERCube = class extends BluetoothPuzzle {
     this.server.disconnect();
   }
   async getState() {
-    return this.toReid333(new Uint8Array((await this.cubeCharacteristic.readValue()).buffer));
+    return this.toReid333(
+      new Uint8Array((await this.cubeCharacteristic.readValue()).buffer)
+    );
   }
   getBit(val, i) {
     const n = i / 8 | 0;
@@ -779,8 +849,8 @@ var GiiKERCube = class extends BluetoothPuzzle {
     debugLog(giikerState);
     const str = giikerStateStr(giikerState);
     debugLog(str);
-    this.dispatchMove({
-      latestMove: giikerMoveToAlgMove(giikerState[32], giikerState[33]),
+    this.dispatchAlgLeaf({
+      latestAlgLeaf: giikerMoveToAlgMove(giikerState[32], giikerState[33]),
       timeStamp: event.timeStamp,
       debug: {
         stateStr: str
@@ -828,7 +898,10 @@ var UUIDs3 = {
   goCubeStateCharacteristic: "6e400003-b5a3-f393-e0a9-e50e24dcca9e"
 };
 function buf2hex2(buffer) {
-  return Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join(" ");
+  return Array.prototype.map.call(
+    new Uint8Array(buffer),
+    (x) => ("00" + x.toString(16)).slice(-2)
+  ).join(" ");
 }
 function bufferToString(buffer) {
   const byteView = new Uint8Array(buffer);
@@ -867,11 +940,16 @@ var GoCube = class extends BluetoothPuzzle {
   static async connect(server) {
     const service = await server.getPrimaryService(UUIDs3.goCubeService);
     debugLog({ service });
-    const goCubeStateCharacteristic = await service.getCharacteristic(UUIDs3.goCubeStateCharacteristic);
+    const goCubeStateCharacteristic = await service.getCharacteristic(
+      UUIDs3.goCubeStateCharacteristic
+    );
     debugLog({ goCubeStateCharacteristic });
     const cube = new GoCube(server, goCubeStateCharacteristic);
     await goCubeStateCharacteristic.startNotifications();
-    goCubeStateCharacteristic.addEventListener("characteristicvaluechanged", cube.onCubeCharacteristicChanged.bind(cube));
+    goCubeStateCharacteristic.addEventListener(
+      "characteristicvaluechanged",
+      cube.onCubeCharacteristicChanged.bind(cube)
+    );
     return cube;
   }
   disconnect() {
@@ -899,8 +977,8 @@ var GoCube = class extends BluetoothPuzzle {
       for (let i = 3; i < buffer.byteLength - 4; i += 2) {
         const move = moveMap[buffer.getUint8(i)];
         this.alg = experimentalAppendMove(this.alg, move);
-        this.dispatchMove({
-          latestMove: moveMap[buffer.getUint8(i)],
+        this.dispatchAlgLeaf({
+          latestAlgLeaf: moveMap[buffer.getUint8(i)],
           timeStamp: event.timeStamp,
           debug: {
             stateStr: buf2hex2(buffer.buffer)
@@ -908,7 +986,9 @@ var GoCube = class extends BluetoothPuzzle {
         });
       }
     } else {
-      const coords = bufferToString(buffer.buffer.slice(3, buffer.byteLength - 3)).split("#").map((s) => parseInt(s, 10) / 16384);
+      const coords = bufferToString(
+        buffer.buffer.slice(3, buffer.byteLength - 3)
+      ).split("#").map((s) => parseInt(s, 10) / 16384);
       const quat = new Quaternion3(coords[0], coords[1], coords[2], coords[3]);
       this.lastRawQuat = quat.clone();
       if (!this.homeQuatInverse) {
@@ -955,16 +1035,27 @@ var HeykubeCube = class extends BluetoothPuzzle {
     super();
     this.server = server;
     this.stateCharacteristic = stateCharacteristic;
-    device.addEventListener("gattserverdisconnected", this.onDisconnect.bind(this));
+    device.addEventListener(
+      "gattserverdisconnected",
+      this.onDisconnect.bind(this)
+    );
     this.stateCharacteristic.startNotifications();
     this.startTrackingMoves();
   }
   static async connect(server, device) {
     const service = await server.getPrimaryService(UUIDs4.heykubeService);
     debugLog("Service:", service);
-    const stateCharacteristic = await service.getCharacteristic(UUIDs4.stateCharacteristic);
+    const stateCharacteristic = await service.getCharacteristic(
+      UUIDs4.stateCharacteristic
+    );
     debugLog("Characteristic:", stateCharacteristic);
-    const cube = new HeykubeCube(await puzzles["3x3x3"].kpuzzle(), service, device, server, stateCharacteristic);
+    const cube = new HeykubeCube(
+      await puzzles["3x3x3"].kpuzzle(),
+      service,
+      device,
+      server,
+      stateCharacteristic
+    );
     return cube;
   }
   name() {
@@ -977,12 +1068,15 @@ var HeykubeCube = class extends BluetoothPuzzle {
     this.dispatchEvent(new CustomEvent("disconnect"));
   }
   startTrackingMoves() {
-    this.stateCharacteristic.addEventListener("characteristicvaluechanged", (e) => this.onStateCharacteristic(e));
+    this.stateCharacteristic.addEventListener(
+      "characteristicvaluechanged",
+      (e) => this.onStateCharacteristic(e)
+    );
   }
   onStateCharacteristic(event) {
     const state = this.decodeState(event.target.value);
-    this.dispatchMove({
-      latestMove: state.latestMove,
+    this.dispatchAlgLeaf({
+      latestAlgLeaf: state.latestMove,
       timeStamp: event.timeStamp,
       state: state.state
     });
@@ -1008,7 +1102,9 @@ var HeykubeCube = class extends BluetoothPuzzle {
     for (let i = 0; i < dv.byteLength; i++) {
       b2[i] = flipBitOrder(dv.getUint8(i), 8);
     }
-    const components1 = twizzleBinaryToBinaryComponents(b2.slice(0, 11));
+    const components1 = twizzleBinaryToBinaryComponents(
+      b2.slice(0, 11)
+    );
     const components2 = {
       epLex: flipBitOrder(components1.epLex, 29),
       eoMask: flipBitOrder(components1.eoMask, 12),
@@ -1049,7 +1145,10 @@ async function connectSmartPuzzle(options) {
 
 // src/cubing/bluetooth/smart-robot/GanRobot.ts
 function buf2hex3(buffer) {
-  return Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join(" ");
+  return Array.prototype.map.call(
+    new Uint8Array(buffer),
+    (x) => ("00" + x.toString(16)).slice(-2)
+  ).join(" ");
 }
 var MAX_NIBBLES_PER_WRITE = 18 * 2;
 var QUANTUM_TURN_DURATION_MS = 150;
@@ -1137,13 +1236,28 @@ var GanRobot = class extends EventTarget {
     };
     this.locked = false;
     this.moveQueue = new Alg();
-    device.addEventListener("gattserverdisconnected", this.onDisconnect.bind(this));
+    device.addEventListener(
+      "gattserverdisconnected",
+      this.onDisconnect.bind(this)
+    );
   }
   static async connect(server, device) {
-    const ganTimerService = await server.getPrimaryService(UUIDs5.ganRobotService);
-    const statusCharacteristic = await ganTimerService.getCharacteristic(UUIDs5.statusCharacteristic);
-    const moveCharacteristic = await ganTimerService.getCharacteristic(UUIDs5.moveCharacteristic);
-    const timer = new GanRobot(ganTimerService, server, device, statusCharacteristic, moveCharacteristic);
+    const ganTimerService = await server.getPrimaryService(
+      UUIDs5.ganRobotService
+    );
+    const statusCharacteristic = await ganTimerService.getCharacteristic(
+      UUIDs5.statusCharacteristic
+    );
+    const moveCharacteristic = await ganTimerService.getCharacteristic(
+      UUIDs5.moveCharacteristic
+    );
+    const timer = new GanRobot(
+      ganTimerService,
+      server,
+      device,
+      statusCharacteristic,
+      moveCharacteristic
+    );
     return timer;
   }
   name() {
@@ -1164,7 +1278,9 @@ var GanRobot = class extends EventTarget {
   }
   async writeNibbles(nibbles) {
     if (nibbles.length > MAX_NIBBLES_PER_WRITE) {
-      throw new Error(`Can only write ${MAX_NIBBLES_PER_WRITE} nibbles at a time!`);
+      throw new Error(
+        `Can only write ${MAX_NIBBLES_PER_WRITE} nibbles at a time!`
+      );
     }
     const bytes = new Uint8Array(18);
     let i;
@@ -1193,7 +1309,9 @@ var GanRobot = class extends EventTarget {
     await sleep(this.experimentalOptions.postSleep);
   }
   async getStatus() {
-    const statusBytes = new Uint8Array((await this.statusCharacteristic.readValue()).buffer);
+    const statusBytes = new Uint8Array(
+      (await this.statusCharacteristic.readValue()).buffer
+    );
     this.experimentalDebugLog("moves remaining:", statusBytes[0]);
     return {
       movesRemaining: statusBytes[0]
@@ -1206,26 +1324,26 @@ var GanRobot = class extends EventTarget {
     if (!this.locked) {
       try {
         this.locked = true;
-        if (this.moveQueue.experimentalNumUnits() === 1) {
+        if (this.moveQueue.experimentalNumChildAlgNodes() === 1) {
           await sleep(this.experimentalOptions.bufferQueue);
         }
-        while (this.moveQueue.experimentalNumUnits() > 0) {
-          let units = Array.from(this.moveQueue.units());
-          if (this.experimentalOptions.singleMoveFixHack && units.length === 1) {
-            const move = units[0];
+        while (this.moveQueue.experimentalNumChildAlgNodes() > 0) {
+          let algNodes = Array.from(this.moveQueue.childAlgNodes());
+          if (this.experimentalOptions.singleMoveFixHack && algNodes.length === 1) {
+            const move = algNodes[0];
             if (move.amount === 2) {
-              units = [
+              algNodes = [
                 move.modified({ amount: 1 }),
                 move.modified({ amount: 1 })
               ];
             } else {
-              units = [
+              algNodes = [
                 move.modified({ amount: -move.amount }),
                 move.modified({ amount: 2 })
               ];
             }
           }
-          const moves2 = units.splice(0, MAX_NIBBLES_PER_WRITE);
+          const moves2 = algNodes.splice(0, MAX_NIBBLES_PER_WRITE);
           const nibbles = moves2.map(this.moveToNibble.bind(this));
           const sending = new Alg(moves2);
           this.experimentalDebugLog("SENDING", sending.toString());
@@ -1233,7 +1351,7 @@ var GanRobot = class extends EventTarget {
             this.experimentalDebugOnSend(sending);
           }
           const write = this.writeNibbles(nibbles);
-          this.moveQueue = new Alg(units);
+          this.moveQueue = new Alg(algNodes);
           await write;
         }
       } finally {
@@ -1248,12 +1366,18 @@ var GanRobot = class extends EventTarget {
         await this.queueMoves(new Alg([move]));
       } else if (move.family === (this.experimentalOptions.xAngle ? "B" : "U")) {
         await Promise.all([
-          this.queueMoves(this.experimentalOptions.xAngle ? F_B_SWAP : U_D_SWAP),
-          this.queueMoves(new Alg([
-            move.modified({
-              family: this.experimentalOptions.xAngle ? "F" : "D"
-            })
-          ]).concat(this.experimentalOptions.xAngle ? F_B_UNSWAP : U_D_UNSWAP))
+          this.queueMoves(
+            this.experimentalOptions.xAngle ? F_B_SWAP : U_D_SWAP
+          ),
+          this.queueMoves(
+            new Alg([
+              move.modified({
+                family: this.experimentalOptions.xAngle ? "F" : "D"
+              })
+            ]).concat(
+              this.experimentalOptions.xAngle ? F_B_UNSWAP : U_D_UNSWAP
+            )
+          )
         ]);
       }
     }
@@ -1286,14 +1410,26 @@ var GanTimer = class extends EventTarget {
     this.previousDetail = null;
     this.startPolling();
     console.log(server);
-    device.addEventListener("gattserverdisconnected", this.onDisconnect.bind(this));
+    device.addEventListener(
+      "gattserverdisconnected",
+      this.onDisconnect.bind(this)
+    );
   }
   static async connect(server, device) {
-    const ganTimerService = await server.getPrimaryService(UUIDs6.ganTimerService);
+    const ganTimerService = await server.getPrimaryService(
+      UUIDs6.ganTimerService
+    );
     console.log("Service:", ganTimerService);
-    const timeCharacteristic = await ganTimerService.getCharacteristic(UUIDs6.timeCharacteristic);
+    const timeCharacteristic = await ganTimerService.getCharacteristic(
+      UUIDs6.timeCharacteristic
+    );
     console.log("Characteristic:", timeCharacteristic);
-    const timer = new GanTimer(ganTimerService, server, device, timeCharacteristic);
+    const timer = new GanTimer(
+      ganTimerService,
+      server,
+      device,
+      timeCharacteristic
+    );
     return timer;
   }
   disconnect() {