@wodzik/cubecore 0.1.7 → 0.1.9

package/bluetooth/rotations.d.ts

@@ -64,12 +64,18 @@ export interface HeldOptions {
     /**
      * Wide moves to read from one face turn and the core's rotation — the rest
      * stay a face turn and a rotation. Default r, l, f, b: a u or d is almost
-     * always a U / D turn and a y regrip. Slices (both faces of an axis) are
-     * always read.
+     * always a U / D turn and a y regrip.
      */
     wide?: readonly string[];
+    /**
+     * Slices to read from both faces of an axis and the core's rotation
+     * (default M, S: an E — U D' and a y — is as likely a U / D turn and a
+     * regrip as u and d); the rest stay two face turns and a rotation.
+     */
+    slices?: readonly string[];
 }
 export declare const DEFAULT_WIDE: readonly string[];
+export declare const DEFAULT_SLICES: readonly string[];
 export declare function heldTokens(moves: readonly TimedMove[], startRotation: string, rotations: readonly RotationRecord[], options?: HeldOptions): HeldToken[];
 /** A rotation and the face moves around it that make a slice / wide move → that move. */
 export declare function mergeSlicesAndWides(tokens: readonly HeldToken[], allowed?: ReadonlySet<string>): HeldToken[];

package/bluetooth/rotations.js

@@ -29,8 +29,9 @@ export function heldMove(move, grip) {
     return canonical ? canonical + move.slice(1) : move;
 }
 export const DEFAULT_WIDE = ["r", "l", "f", "b"];
+export const DEFAULT_SLICES = ["M", "S"];
 export function heldTokens(moves, startRotation, rotations, options = {}) {
-    const allowed = new Set(options.wide ?? DEFAULT_WIDE);
+    const allowed = new Set([...(options.wide ?? DEFAULT_WIDE), ...(options.slices ?? DEFAULT_SLICES)]);
     let grip = rotateGrip(IDENTITY_GRIP, startRotation);
     const rots = snapToSlices(moves, grip, [...rotations].sort((a, b) => a.after - b.after || a.t - b.t), allowed);
     const tokens = [];
@@ -69,13 +70,13 @@ const AXIS_FACES = { x: ["R", "L"], y: ["U", "D"], z: ["F", "B"] };
 const SLICE_WIDE = ["M", "E", "S", "r", "l", "u", "d", "f", "b"].flatMap((f) => [f, `${f}'`, `${f}2`]);
 const effect = (alg) => applyMoves(solvedState(), alg).join();
 const SLICE_WIDE_EFFECT = new Map();
-/** The slice (or an `allowed` wide move) the group (held letters and a rotation) amounts to, or null. */
+/** The slice / wide move the group (held letters and a rotation) amounts to, if `allowed` (by its letter), or null. */
 function sliceOrWide(group, allowed) {
     if (SLICE_WIDE_EFFECT.size === 0)
         for (const m of SLICE_WIDE)
             SLICE_WIDE_EFFECT.set(effect(m), m);
     const m = SLICE_WIDE_EFFECT.get(effect(group.join(" ")));
-    return m && ("MES".includes(m[0]) || allowed.has(m[0])) ? m : null;
+    return m && allowed.has(m[0]) ? m : null;
 }
 /**
  * The consecutive run (up to MAX_GROUP) of moves on the axis nearest to
@@ -142,7 +143,7 @@ function snapToSlices(moves, startGrip, rotations, allowed) {
     return out.sort((a, b) => a.after - b.after || a.t - b.t);
 }
 /** A rotation and the face moves around it that make a slice / wide move → that move. */
-export function mergeSlicesAndWides(tokens, allowed = new Set(DEFAULT_WIDE)) {
+export function mergeSlicesAndWides(tokens, allowed = new Set([...DEFAULT_WIDE, ...DEFAULT_SLICES])) {
     const out = [...tokens];
     for (let k = 0; k < out.length; k++) {
         const rot = out[k];

package/core/method.d.ts

@@ -14,6 +14,8 @@ export interface Stage {
     done(s: State): boolean;
     /** Canonical slot / sub-step finished at this stage, given the details already reported. */
     detail?(s: State, earlier: readonly string[]): string | undefined;
+    /** The detail is absolute (colours, "edges"…), not a canonical slot to translate into physical faces. */
+    absoluteDetail?: boolean;
     /**
      * The case this stage starts from (e.g. "OLL 27", "T", "OLL skip"),
      * recognised on the state the previous stage finished in.

package/core/method.js

@@ -19,7 +19,9 @@ export function countedStages(prefix, label, count, guard) {
         id: `${prefix}-${n}`,
         label: `${label} ${n}`,
         done: (s) => guard(s) && count(s).length >= n,
-        detail: (s, earlier) => newItem(count(s), earlier),
+        // Only this group's own earlier details (the n − 1 just before): another
+        // group's may name the same slots (LBL: corners, then edges, per slot).
+        detail: (s, earlier) => newItem(count(s), earlier.slice(earlier.length - (n - 1))),
     }));
 }
 /** Orient, permute, AUF — the last layer of CFOP, ZZ and Petrus. */

package/core/tracker.js

@@ -99,7 +99,7 @@ export class MethodTracker {
                     stage: stage.id,
                     moveIndex: this.moveCount,
                     ...(time !== undefined ? { time } : {}),
-                    ...(raw ? { detail: physicalSlot(raw, p.frame) } : {}),
+                    ...(raw ? { detail: stage.absoluteDetail ? raw : physicalSlot(raw, p.frame) } : {}),
                     ...(kase ? { case: kase } : {}),
                 });
                 p.stageIndex++;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "A 3×3×3 cube library for the web, built around smart (Bluetooth) cubes: state, notation, methods, solvers and scrambles, a three.js renderer with skins, pictures, web components, React bindings.",
   "license": "MPL-2.0",
   "author": "Tomasz Wodzikowski <wodziszczakow@gmail.com>",

package/roux/index.d.ts

@@ -9,8 +9,7 @@
 import { type Frame, type Mask, type MaskRule, type Method, type LseStageDef, type StageDef, type State } from "../core/index.js";
 export * from "./cmll.js";
 export declare const firstBlock: (s: State) => boolean;
-export declare function secondBlock(s: State): boolean;
-/** CMLL: both blocks, and the top corners solved relative to them (up to AUF). */
+export declare const secondBlock: (s: State) => boolean;
 export declare const cmll: (s: State) => boolean;
 /**
  * LSE edge orientation: every last-six edge has its top/bottom-coloured
@@ -18,9 +17,9 @@ export declare const cmll: (s: State) => boolean;
  * (the top / bottom centres on F / B), the edges in the M slice count by
  * F / B instead (one M puts them right, flips and all).
  */
-export declare function lseEo(s: State): boolean;
+export declare const lseEo: (s: State) => boolean;
 /** LSE 4b: UL and UR edges in place, with the corners aligned. */
-export declare function ulUr(s: State): boolean;
+export declare const ulUr: (s: State) => boolean;
 export declare const ROUX: Method;
 export type RouxMask = "fb" | "blocks" | "cmll" | "lse" | "eo" | "ulur";
 export declare const ROUX_MASKS: Record<RouxMask, MaskRule>;

package/roux/index.js

@@ -6,7 +6,7 @@
  * pieces to each other (and to the L/R centres, which M never moves) — still
  * no absolute colours, so any scheme and any orientation works.
  */
-import { FACELETS, IDENTITY_FRAME, PIECE, buildMask, checks as C, colorAt, } from "../core/index.js";
+import { applyMove, parseAlg, FACELETS, IDENTITY_FRAME, PIECE, buildMask, checks as C, colorAt, } from "../core/index.js";
 import { recognizeCmll } from "./cmll.js";
 export * from "./cmll.js";
 const { cubieAt, faceletOn, centerIdx, opposite, upToAuf } = C;
@@ -39,12 +39,33 @@ function rouxBlock(s, side) {
         return null;
     return { bottom, front, back };
 }
-export const firstBlock = (s) => rouxBlock(s, "L") !== null;
-export function secondBlock(s) {
+/**
+ * Across M: the state turned about the L–R axis, 0–3 quarters — the first
+ * turn where `pick` finds something, and what. A smart cube reports its
+ * moves relative to its centres, so an M (R L' as it reports it) turns
+ * everything but the centres: the blocks end up a quarter or two off the
+ * bottom as it sees them. The checks here only compare with the L / R
+ * centres (which M never moves) and pieces with each other, so the turned
+ * state reads the same as a cube whose M slice was never turned.
+ */
+const X = parseAlg("x")[0];
+function acrossM(s, pick) {
+    let t = s;
+    for (let k = 0; k < 4; k++) {
+        const v = pick(t);
+        if (v !== null && v !== false)
+            return v;
+        t = applyMove(t, X);
+    }
+    return null;
+}
+function bothBlocks(s) {
     const fb = rouxBlock(s, "L");
     const sb = rouxBlock(s, "R");
-    return fb !== null && sb !== null && fb.bottom === sb.bottom && fb.front === sb.front && fb.back === sb.back;
+    return fb !== null && sb !== null && fb.bottom === sb.bottom && fb.front === sb.front && fb.back === sb.back ? fb : null;
 }
+export const firstBlock = (s) => acrossM(s, (t) => rouxBlock(t, "L")) !== null;
+export const secondBlock = (s) => acrossM(s, bothBlocks) !== null;
 const CMLL_CORNERS = { ufl: cubieAt(-1, 1, 1), ubl: cubieAt(-1, 1, -1), ufr: cubieAt(1, 1, 1), ubr: cubieAt(1, 1, -1) };
 function cmllAligned(s) {
     const fb = rouxBlock(s, "L");
@@ -64,7 +85,8 @@ function cmllAligned(s) {
         col(ubr, "B") === fb.back);
 }
 /** CMLL: both blocks, and the top corners solved relative to them (up to AUF). */
-export const cmll = (s) => secondBlock(s) && upToAuf(s, cmllAligned);
+const cmllAt = (s) => bothBlocks(s) !== null && upToAuf(s, cmllAligned);
+export const cmll = (s) => acrossM(s, cmllAt) !== null;
 const LSE_EDGES = [cubieAt(0, 1, 1), cubieAt(0, 1, -1), cubieAt(-1, 1, 0), cubieAt(1, 1, 0), cubieAt(0, -1, 1), cubieAt(0, -1, -1)];
 /**
  * LSE edge orientation: every last-six edge has its top/bottom-coloured
@@ -72,8 +94,9 @@ const LSE_EDGES = [cubieAt(0, 1, 1), cubieAt(0, 1, -1), cubieAt(-1, 1, 0), cubie
  * (the top / bottom centres on F / B), the edges in the M slice count by
  * F / B instead (one M puts them right, flips and all).
  */
-export function lseEo(s) {
-    if (!cmll(s))
+export const lseEo = (s) => acrossM(s, lseEoAt) !== null;
+function lseEoAt(s) {
+    if (!cmllAt(s))
         return false;
     const bottom = rouxBlock(s, "L").bottom;
     const ud = [bottom, opposite(bottom)];
@@ -88,8 +111,9 @@ export function lseEo(s) {
     });
 }
 /** LSE 4b: UL and UR edges in place, with the corners aligned. */
-export function ulUr(s) {
-    if (!lseEo(s))
+export const ulUr = (s) => acrossM(s, ulUrAt) !== null;
+function ulUrAt(s) {
+    if (!lseEoAt(s))
         return false;
     return upToAuf(s, (t) => {
         if (!cmllAligned(t))
@@ -103,17 +127,40 @@ export function ulUr(s) {
             colorAt(t, faceletOn(ur, "R")) === colorAt(t, centerIdx("R")));
     });
 }
+const COLOUR_LETTERS = "URFDLB";
+const letter = (c) => COLOUR_LETTERS[c] ?? "";
+/** A block's floor and wall colours ("DL"). */
+function blockColours(s, side) {
+    const b = acrossM(s, (t) => {
+        const block = rouxBlock(t, side);
+        return block ? { bottom: block.bottom, wall: colorAt(t, centerIdx(side)) } : null;
+    });
+    return b ? letter(b.bottom) + letter(b.wall) : undefined;
+}
+/** The wall pair neither block touches ("FB"). */
+function wallColours(s) {
+    const b = acrossM(s, bothBlocks);
+    return b ? letter(b.front) + letter(b.back) : undefined;
+}
+/** The floor's colour ("D"). */
+function floorColour(s) {
+    const b = acrossM(s, (t) => rouxBlock(t, "L"));
+    return b ? letter(b.bottom) : undefined;
+}
 export const ROUX = {
     id: "roux",
     name: "Roux",
     stages: [
-        { id: "fb", label: "First block", done: firstBlock },
-        { id: "sb", label: "Second block", done: secondBlock },
+        // Details as colours (a face's letter = its centre's colour, "DL" = D-coloured floor, L-coloured wall):
+        // across M, the floor a smart cube sees moves, the colours don't.
+        { id: "fb", label: "First block", done: firstBlock, absoluteDetail: true, detail: (s) => blockColours(s, "L") },
+        { id: "sb", label: "Second block", done: secondBlock, absoluteDetail: true, detail: (s) => blockColours(s, "R") },
         // CMLL recognises the case it starts from ("Sune Left Bar", "CMLL skip") — StageBoundary.case.
-        { id: "cmll", label: "CMLL", done: cmll, recognize: (s) => (secondBlock(s) ? (recognizeCmll(s)?.id ?? "CMLL skip") : undefined) },
+        { id: "cmll", label: "CMLL", done: cmll, absoluteDetail: true, detail: (s) => wallColours(s), recognize: (s) => (secondBlock(s) ? (recognizeCmll(s)?.id ?? "CMLL skip") : undefined) },
         { id: "eo", label: "EO", done: lseEo },
         { id: "ulur", label: "UL/UR", done: ulUr },
-        { id: "l4e", label: "L4E", done: C.isSolved },
+        // Solved, every quarter about L–R shows blocks: the floor is the first block's.
+        { id: "l4e", label: "L4E", done: C.isSolved, absoluteDetail: true, detail: (s, earlier) => earlier[0]?.[0] ?? floorColour(s) },
     ],
 };
 const y = (c) => c.pos[1];