cube-state-engine 1.5.1 → 1.7.0

package/.claude/settings.local.json

@@ -3,7 +3,12 @@
     "allow": [
       "Bash(npm run *)",
       "Bash(node -e \"const m=require\\('./dist/index.js'\\); console.log\\(Object.keys\\(m\\).filter\\(k=>/analyze|invert|MovePerm/.test\\(k\\)\\)\\)\")",
-      "Bash(npm test *)"
+      "Bash(npm test *)",
+      "Read(//mnt/d/workspace/**)",
+      "Bash(node -e ' *)",
+      "Bash(node *)",
+      "Bash(cd /tmp)",
+      "Bash(sed -i 's/console.log\\(`\\\\\\\\nsideA.*cmll\\)}`\\);/console.log\\(\"\\\\\\\\nsideA=\"+sideA+\" up=\"+up+\": aFirst=\"+firstTrue\\(aDone\\)+\" aLast=\"+aDone[n-1]+\" bFirst=\"+firstTrue\\(bDone\\)+\" bLast=\"+bDone[n-1]+\" cmllFirst=\"+firstTrue\\(cmll\\)\\);/' trace.mjs)"
     ]
   }
 }

package/dist/index.d.mts

@@ -309,6 +309,74 @@ function ollDone(st, geo, color) {
   return true;
 }
 
+// --- Roux geometry --------------------------------------------------------
+
+// The pieces of a Roux 1x2x3 block, parameterized by the block's side face and
+// the up face (which fixes down = opposite[up]). The block holds the side
+// center, the side's three edges that do NOT touch the up face, and the side's
+// two corners that DO touch the down face. The center always matches itself, so
+// only edges/corners need checking.
+function rouxBlockPieces(geo, sideFace, upFace) {
+  const downFace = geo.opposite[upFace];
+  const edges = geo
+    .edgesByFace(sideFace)
+    .filter((e) => !e.faces.includes(upFace));
+  const corners = geo
+    .cornersByFace(sideFace)
+    .filter((c) => c.faces.includes(downFace));
+  return { edges, corners };
+}
+
+// A Roux block is done when its three edges and two corners are all placed.
+// As with CMLL, the block stays intact while the slice between the two blocks is
+// unaligned, but the block's down/front/back facelets are compared against the
+// floating centers -- which the slice displaces. So we accept the block if ANY
+// of the four slice rotations makes its pieces match the centers: the slice
+// moves neither the blocks nor their corners/edges (none sit on the slice), it
+// only re-aligns the floating centers. Without this, a perfectly built block
+// reads as broken for most of a Roux solve, because the slice is scrambled until
+// LSE. `slicePerm` is the slice perpendicular to the block axis.
+function rouxBlockDone(st, geo, sideFace, upFace, slicePerm) {
+  const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
+  if (edges.length !== 3 || corners.length !== 2) return false;
+  let cur = st;
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    const ok =
+      edges.every((e) => slotCorrect(cur, centers, e.indices, geo.per)) &&
+      corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per));
+    if (ok) return true;
+  }
+  return false;
+}
+
+// Applies a permutation (out[i] = st[perm[i]]) to a flat sticker array.
+function applyPerm(st, perm) {
+  const out = new Array(st.length);
+  for (let i = 0; i < st.length; i++) out[i] = st[perm[i]];
+  return out;
+}
+
+// CMLL is done when the four corners touching the up face are solved, allowing
+// the slice between the two blocks to be unaligned: we accept the state if ANY
+// of the four slice rotations makes those corners correct. The slice moves
+// neither the corners nor the two blocks, only the four floating centers (and
+// slice edges) around the block axis, so this captures exactly "last-layer
+// corners solved, slice not necessarily aligned yet". `slicePerm` must be the
+// slice perpendicular to the block axis (M for L/R blocks, E for U/D, S for F/B).
+function cmllDone(st, geo, upFace, slicePerm) {
+  let cur = st;
+  const corners = geo.cornersByFace(upFace);
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
+      return true;
+  }
+  return false;
+}
+
 // Index of the move that COMPLETES a stage: the first move after which the
 // condition holds, provided the stage is genuinely achieved by the end of the
 // solve. Later moves are allowed to break it transiently (a turn mid-algorithm
@@ -376,15 +444,71 @@ function isCFOP(build) {
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
 
+// Builds the Roux milestone indices for one (sideFace, upFace) orientation.
+// Detection is cumulative, mirroring buildForCross: the second block only counts
+// while the first block holds, CMLL only once both blocks hold, and LSE is the
+// fully solved cube. The first block is whichever of the two opposite side faces
+// finishes its block earliest; the other side is the second block.
+function buildForRoux(snapshots, geo, sideA, upFace, slicePerm) {
+  snapshots.length;
+  const sideB = geo.opposite[sideA];
+
+  const aDone = snapshots.map((st) =>
+    rouxBlockDone(st, geo, sideA, upFace, slicePerm)
+  );
+  const bDone = snapshots.map((st) =>
+    rouxBlockDone(st, geo, sideB, upFace, slicePerm)
+  );
+  const aIdx = completionIndex(aDone);
+  const bIdx = completionIndex(bDone);
+
+  // First block = the side that completes earliest; second block = the other.
+  let firstSide = sideA;
+  let secondSide = sideB;
+  let fbBools = aDone;
+  let sbBools = bDone;
+  if ((bIdx ?? Infinity) < (aIdx ?? Infinity)) {
+    firstSide = sideB;
+    secondSide = sideA;
+    fbBools = bDone;
+    sbBools = aDone;
+  }
+
+  const fbIdx = completionIndex(fbBools);
+  // Second block gated by the first block holding at the same instant.
+  const secondBlockBools = snapshots.map((_, i) => fbBools[i] && sbBools[i]);
+  const sbIdx = completionIndex(secondBlockBools);
+
+  const cmllIdx = completionIndex(
+    snapshots.map(
+      (st, i) => secondBlockBools[i] && cmllDone(st, geo, upFace, slicePerm)
+    )
+  );
+  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
+
+  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+}
+
+// Does this breakdown follow the Roux order: 1st block -> 2nd block -> CMLL -> LSE?
+function isRoux(build) {
+  const { fbIdx, sbIdx, cmllIdx, lseIdx } = build;
+  if (fbIdx == null || sbIdx == null || cmllIdx == null || lseIdx == null)
+    return false;
+  return fbIdx <= sbIdx && sbIdx <= cmllIdx && cmllIdx <= lseIdx;
+}
+
 /**
  * Analyzes a solution and returns the timing of each method milestone.
  *
  * @param {Array<{m: string, t: number}>} moves - Solution moves with cumulative
  *   timestamps. `m` is a move token; `t` is elapsed ms up to that move.
- * @param {{size?: number}} [options] - Cube size (defaults to 3). CFOP staging
+ * @param {{size?: number}} [options] - Cube size (defaults to 3). Method staging
  *   is only computed for 3x3; other sizes report the solved (PLL) time only.
- * @returns {object} Breakdown with `method`, `total`, `cross`, `f2l[]`, `oll`,
- *   `pll` and `allCrosses` (cross time per face color).
+ * @returns {object} Breakdown with `method` ("CFOP", "Roux" or "unknown"),
+ *   `total`, `tps` and `allCrosses` (cross time per face color). For CFOP it
+ *   carries `cross`, `f2l[]`, `oll`, `pll`; for Roux it carries `firstBlock`,
+ *   `secondBlock`, `cmll`, `lse` (the other method's fields are null). Each
+ *   block record also includes the `side` center color it was built on.
  */
 function analyzeSolution(moves, options = {}) {
   const size = options.size === 2 ? 2 : 3;
@@ -420,6 +544,10 @@ function analyzeSolution(moves, options = {}) {
     f2l: [],
     oll: null,
     pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
     allCrosses: {},
     unsupported,
   };
@@ -491,11 +619,87 @@ function analyzeSolution(moves, options = {}) {
       return ai - bi;
     });
 
-  let chosen = ordered.find((c) => isCFOP(c.build)) ?? ordered[0];
-  const method = chosen && isCFOP(chosen.build) ? "CFOP" : "unknown";
-  const { color: crossColor, build } = chosen;
+  const cfopChosen = ordered.find((c) => isCFOP(c.build)) ?? ordered[0];
+  const cfopValid = !!cfopChosen && isCFOP(cfopChosen.build);
+
+  // Stage the solve as Roux (1st block -> 2nd block -> CMLL -> LSE) on every
+  // orientation. Each candidate fixes a side face and a perpendicular up face;
+  // buildForRoux assigns first/second block by which side finishes earliest.
+  // The "floating" slice that block/CMLL detection lets drift is the one
+  // perpendicular to the block axis: M for L/R blocks, E for U/D, S for F/B.
+  // Pick the valid candidate whose first block completes earliest.
+  const perms = getMovePermutations(size);
+  const axisSlicePerm = (face) => {
+    if (face === 1 || face === 3) return perms["M"].cw; // L/R axis
+    if (face === 0 || face === 5) return perms["E"].cw; // U/D axis
+    return perms["S"].cw; // F/B axis
+  };
+  const rouxCandidates = [];
+  for (let s = 0; s < 6; s++) {
+    for (const u of geo.neighbors[s]) {
+      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, axisSlicePerm(s)));
+    }
+  }
+  const rouxBuild =
+    rouxCandidates
+      .filter((b) => isRoux(b))
+      .sort((a, b) => a.fbIdx - b.fbIdx)[0] ?? null;
+
+  // A solved cube satisfies many orderings, so both stagings can be technically
+  // valid. Disambiguate by which method's FIRST milestone is genuinely reached
+  // early: a real CFOP cross is built up front, whereas on a Roux solve no cross
+  // completes until LSE; conversely a full 1x2x3 block only forms mid-CFOP. The
+  // structure that actually happened owns the earlier first milestone; ties go
+  // to CFOP.
+  let method = "unknown";
+  if (cfopValid && rouxBuild) {
+    method = cfopChosen.build.crossIdx <= rouxBuild.fbIdx ? "CFOP" : "Roux";
+  } else if (cfopValid) {
+    method = "CFOP";
+  } else if (rouxBuild) {
+    method = "Roux";
+  }
+  const total = seq[n - 1].t;
+  const base = {
+    size,
+    method,
+    solved,
+    total,
+    tps: total > 0 ? simplifiedCount / (total / 1000) : 0,
+    moves: simplifiedMoves,
+    cross: null,
+    f2l: [],
+    oll: null,
+    pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
+    allCrosses,
+    unsupported,
+  };
+
+  // Roux: report 1st block / 2nd block / CMLL / LSE, chaining durations.
+  if (method === "Roux") {
+    const fbM = milestone(rouxBuild.fbIdx, 0);
+    const sbM = milestone(rouxBuild.sbIdx, fbM.at);
+    const cmllM = milestone(rouxBuild.cmllIdx, sbM.at);
+    const lseM = milestone(rouxBuild.lseIdx, cmllM.at);
+    return {
+      ...base,
+      firstBlock: fbM.record
+        ? { side: finalCenters[rouxBuild.firstSide], ...fbM.record }
+        : null,
+      secondBlock: sbM.record
+        ? { side: finalCenters[rouxBuild.secondSide], ...sbM.record }
+        : null,
+      cmll: cmllM.record,
+      lse: lseM.record,
+    };
+  }
 
-  // Assemble timed records in solve order so durations chain correctly.
+  // CFOP (or unknown): report cross / F2L / OLL / PLL from the earliest cross.
+  const { color: crossColor, build } = cfopChosen;
   const crossM = milestone(build.crossIdx, 0);
   const cross = crossM.record
     ? { color: crossColor, ...crossM.record }
@@ -512,26 +716,15 @@ function analyzeSolution(moves, options = {}) {
   }
 
   const ollM = milestone(build.ollIdx, prevAt);
-  const oll = ollM.record;
   prevAt = ollM.at;
-
   const pllM = milestone(build.pllIdx, prevAt);
-  const pll = pllM.record;
 
-  const total = seq[n - 1].t;
   return {
-    size,
-    method,
-    solved,
-    total,
-    tps: total > 0 ? simplifiedCount / (total / 1000) : 0,
-    moves: simplifiedMoves,
+    ...base,
     cross,
     f2l,
-    oll,
-    pll,
-    allCrosses,
-    unsupported,
+    oll: ollM.record,
+    pll: pllM.record,
   };
 }
 

package/dist/index.d.ts

@@ -309,6 +309,74 @@ function ollDone(st, geo, color) {
   return true;
 }
 
+// --- Roux geometry --------------------------------------------------------
+
+// The pieces of a Roux 1x2x3 block, parameterized by the block's side face and
+// the up face (which fixes down = opposite[up]). The block holds the side
+// center, the side's three edges that do NOT touch the up face, and the side's
+// two corners that DO touch the down face. The center always matches itself, so
+// only edges/corners need checking.
+function rouxBlockPieces(geo, sideFace, upFace) {
+  const downFace = geo.opposite[upFace];
+  const edges = geo
+    .edgesByFace(sideFace)
+    .filter((e) => !e.faces.includes(upFace));
+  const corners = geo
+    .cornersByFace(sideFace)
+    .filter((c) => c.faces.includes(downFace));
+  return { edges, corners };
+}
+
+// A Roux block is done when its three edges and two corners are all placed.
+// As with CMLL, the block stays intact while the slice between the two blocks is
+// unaligned, but the block's down/front/back facelets are compared against the
+// floating centers -- which the slice displaces. So we accept the block if ANY
+// of the four slice rotations makes its pieces match the centers: the slice
+// moves neither the blocks nor their corners/edges (none sit on the slice), it
+// only re-aligns the floating centers. Without this, a perfectly built block
+// reads as broken for most of a Roux solve, because the slice is scrambled until
+// LSE. `slicePerm` is the slice perpendicular to the block axis.
+function rouxBlockDone(st, geo, sideFace, upFace, slicePerm) {
+  const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
+  if (edges.length !== 3 || corners.length !== 2) return false;
+  let cur = st;
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    const ok =
+      edges.every((e) => slotCorrect(cur, centers, e.indices, geo.per)) &&
+      corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per));
+    if (ok) return true;
+  }
+  return false;
+}
+
+// Applies a permutation (out[i] = st[perm[i]]) to a flat sticker array.
+function applyPerm(st, perm) {
+  const out = new Array(st.length);
+  for (let i = 0; i < st.length; i++) out[i] = st[perm[i]];
+  return out;
+}
+
+// CMLL is done when the four corners touching the up face are solved, allowing
+// the slice between the two blocks to be unaligned: we accept the state if ANY
+// of the four slice rotations makes those corners correct. The slice moves
+// neither the corners nor the two blocks, only the four floating centers (and
+// slice edges) around the block axis, so this captures exactly "last-layer
+// corners solved, slice not necessarily aligned yet". `slicePerm` must be the
+// slice perpendicular to the block axis (M for L/R blocks, E for U/D, S for F/B).
+function cmllDone(st, geo, upFace, slicePerm) {
+  let cur = st;
+  const corners = geo.cornersByFace(upFace);
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
+      return true;
+  }
+  return false;
+}
+
 // Index of the move that COMPLETES a stage: the first move after which the
 // condition holds, provided the stage is genuinely achieved by the end of the
 // solve. Later moves are allowed to break it transiently (a turn mid-algorithm
@@ -376,15 +444,71 @@ function isCFOP(build) {
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
 
+// Builds the Roux milestone indices for one (sideFace, upFace) orientation.
+// Detection is cumulative, mirroring buildForCross: the second block only counts
+// while the first block holds, CMLL only once both blocks hold, and LSE is the
+// fully solved cube. The first block is whichever of the two opposite side faces
+// finishes its block earliest; the other side is the second block.
+function buildForRoux(snapshots, geo, sideA, upFace, slicePerm) {
+  snapshots.length;
+  const sideB = geo.opposite[sideA];
+
+  const aDone = snapshots.map((st) =>
+    rouxBlockDone(st, geo, sideA, upFace, slicePerm)
+  );
+  const bDone = snapshots.map((st) =>
+    rouxBlockDone(st, geo, sideB, upFace, slicePerm)
+  );
+  const aIdx = completionIndex(aDone);
+  const bIdx = completionIndex(bDone);
+
+  // First block = the side that completes earliest; second block = the other.
+  let firstSide = sideA;
+  let secondSide = sideB;
+  let fbBools = aDone;
+  let sbBools = bDone;
+  if ((bIdx ?? Infinity) < (aIdx ?? Infinity)) {
+    firstSide = sideB;
+    secondSide = sideA;
+    fbBools = bDone;
+    sbBools = aDone;
+  }
+
+  const fbIdx = completionIndex(fbBools);
+  // Second block gated by the first block holding at the same instant.
+  const secondBlockBools = snapshots.map((_, i) => fbBools[i] && sbBools[i]);
+  const sbIdx = completionIndex(secondBlockBools);
+
+  const cmllIdx = completionIndex(
+    snapshots.map(
+      (st, i) => secondBlockBools[i] && cmllDone(st, geo, upFace, slicePerm)
+    )
+  );
+  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
+
+  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+}
+
+// Does this breakdown follow the Roux order: 1st block -> 2nd block -> CMLL -> LSE?
+function isRoux(build) {
+  const { fbIdx, sbIdx, cmllIdx, lseIdx } = build;
+  if (fbIdx == null || sbIdx == null || cmllIdx == null || lseIdx == null)
+    return false;
+  return fbIdx <= sbIdx && sbIdx <= cmllIdx && cmllIdx <= lseIdx;
+}
+
 /**
  * Analyzes a solution and returns the timing of each method milestone.
  *
  * @param {Array<{m: string, t: number}>} moves - Solution moves with cumulative
  *   timestamps. `m` is a move token; `t` is elapsed ms up to that move.
- * @param {{size?: number}} [options] - Cube size (defaults to 3). CFOP staging
+ * @param {{size?: number}} [options] - Cube size (defaults to 3). Method staging
  *   is only computed for 3x3; other sizes report the solved (PLL) time only.
- * @returns {object} Breakdown with `method`, `total`, `cross`, `f2l[]`, `oll`,
- *   `pll` and `allCrosses` (cross time per face color).
+ * @returns {object} Breakdown with `method` ("CFOP", "Roux" or "unknown"),
+ *   `total`, `tps` and `allCrosses` (cross time per face color). For CFOP it
+ *   carries `cross`, `f2l[]`, `oll`, `pll`; for Roux it carries `firstBlock`,
+ *   `secondBlock`, `cmll`, `lse` (the other method's fields are null). Each
+ *   block record also includes the `side` center color it was built on.
  */
 function analyzeSolution(moves, options = {}) {
   const size = options.size === 2 ? 2 : 3;
@@ -420,6 +544,10 @@ function analyzeSolution(moves, options = {}) {
     f2l: [],
     oll: null,
     pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
     allCrosses: {},
     unsupported,
   };
@@ -491,11 +619,87 @@ function analyzeSolution(moves, options = {}) {
       return ai - bi;
     });
 
-  let chosen = ordered.find((c) => isCFOP(c.build)) ?? ordered[0];
-  const method = chosen && isCFOP(chosen.build) ? "CFOP" : "unknown";
-  const { color: crossColor, build } = chosen;
+  const cfopChosen = ordered.find((c) => isCFOP(c.build)) ?? ordered[0];
+  const cfopValid = !!cfopChosen && isCFOP(cfopChosen.build);
+
+  // Stage the solve as Roux (1st block -> 2nd block -> CMLL -> LSE) on every
+  // orientation. Each candidate fixes a side face and a perpendicular up face;
+  // buildForRoux assigns first/second block by which side finishes earliest.
+  // The "floating" slice that block/CMLL detection lets drift is the one
+  // perpendicular to the block axis: M for L/R blocks, E for U/D, S for F/B.
+  // Pick the valid candidate whose first block completes earliest.
+  const perms = getMovePermutations(size);
+  const axisSlicePerm = (face) => {
+    if (face === 1 || face === 3) return perms["M"].cw; // L/R axis
+    if (face === 0 || face === 5) return perms["E"].cw; // U/D axis
+    return perms["S"].cw; // F/B axis
+  };
+  const rouxCandidates = [];
+  for (let s = 0; s < 6; s++) {
+    for (const u of geo.neighbors[s]) {
+      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, axisSlicePerm(s)));
+    }
+  }
+  const rouxBuild =
+    rouxCandidates
+      .filter((b) => isRoux(b))
+      .sort((a, b) => a.fbIdx - b.fbIdx)[0] ?? null;
+
+  // A solved cube satisfies many orderings, so both stagings can be technically
+  // valid. Disambiguate by which method's FIRST milestone is genuinely reached
+  // early: a real CFOP cross is built up front, whereas on a Roux solve no cross
+  // completes until LSE; conversely a full 1x2x3 block only forms mid-CFOP. The
+  // structure that actually happened owns the earlier first milestone; ties go
+  // to CFOP.
+  let method = "unknown";
+  if (cfopValid && rouxBuild) {
+    method = cfopChosen.build.crossIdx <= rouxBuild.fbIdx ? "CFOP" : "Roux";
+  } else if (cfopValid) {
+    method = "CFOP";
+  } else if (rouxBuild) {
+    method = "Roux";
+  }
+  const total = seq[n - 1].t;
+  const base = {
+    size,
+    method,
+    solved,
+    total,
+    tps: total > 0 ? simplifiedCount / (total / 1000) : 0,
+    moves: simplifiedMoves,
+    cross: null,
+    f2l: [],
+    oll: null,
+    pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
+    allCrosses,
+    unsupported,
+  };
+
+  // Roux: report 1st block / 2nd block / CMLL / LSE, chaining durations.
+  if (method === "Roux") {
+    const fbM = milestone(rouxBuild.fbIdx, 0);
+    const sbM = milestone(rouxBuild.sbIdx, fbM.at);
+    const cmllM = milestone(rouxBuild.cmllIdx, sbM.at);
+    const lseM = milestone(rouxBuild.lseIdx, cmllM.at);
+    return {
+      ...base,
+      firstBlock: fbM.record
+        ? { side: finalCenters[rouxBuild.firstSide], ...fbM.record }
+        : null,
+      secondBlock: sbM.record
+        ? { side: finalCenters[rouxBuild.secondSide], ...sbM.record }
+        : null,
+      cmll: cmllM.record,
+      lse: lseM.record,
+    };
+  }
 
-  // Assemble timed records in solve order so durations chain correctly.
+  // CFOP (or unknown): report cross / F2L / OLL / PLL from the earliest cross.
+  const { color: crossColor, build } = cfopChosen;
   const crossM = milestone(build.crossIdx, 0);
   const cross = crossM.record
     ? { color: crossColor, ...crossM.record }
@@ -512,26 +716,15 @@ function analyzeSolution(moves, options = {}) {
   }
 
   const ollM = milestone(build.ollIdx, prevAt);
-  const oll = ollM.record;
   prevAt = ollM.at;
-
   const pllM = milestone(build.pllIdx, prevAt);
-  const pll = pllM.record;
 
-  const total = seq[n - 1].t;
   return {
-    size,
-    method,
-    solved,
-    total,
-    tps: total > 0 ? simplifiedCount / (total / 1000) : 0,
-    moves: simplifiedMoves,
+    ...base,
     cross,
     f2l,
-    oll,
-    pll,
-    allCrosses,
-    unsupported,
+    oll: ollM.record,
+    pll: pllM.record,
   };
 }
 

package/dist/index.js

@@ -270,6 +270,40 @@ function ollDone(st, geo, color) {
   }
   return true;
 }
+function rouxBlockPieces(geo, sideFace, upFace) {
+  const downFace = geo.opposite[upFace];
+  const edges = geo.edgesByFace(sideFace).filter((e) => !e.faces.includes(upFace));
+  const corners = geo.cornersByFace(sideFace).filter((c) => c.faces.includes(downFace));
+  return { edges, corners };
+}
+function rouxBlockDone(st, geo, sideFace, upFace, slicePerm) {
+  const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
+  if (edges.length !== 3 || corners.length !== 2) return false;
+  let cur = st;
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    const ok = edges.every((e) => slotCorrect(cur, centers, e.indices, geo.per)) && corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per));
+    if (ok) return true;
+  }
+  return false;
+}
+function applyPerm(st, perm) {
+  const out = new Array(st.length);
+  for (let i = 0; i < st.length; i++) out[i] = st[perm[i]];
+  return out;
+}
+function cmllDone(st, geo, upFace, slicePerm) {
+  let cur = st;
+  const corners = geo.cornersByFace(upFace);
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
+      return true;
+  }
+  return false;
+}
 function completionIndex(bools) {
   const n = bools.length;
   if (n === 0 || !bools[n - 1]) return null;
@@ -315,15 +349,53 @@ function isCFOP(build) {
   const lastF2L = f2lSlots[3].idx;
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
+function buildForRoux(snapshots, geo, sideA, upFace, slicePerm) {
+  const n = snapshots.length;
+  const sideB = geo.opposite[sideA];
+  const aDone = snapshots.map(
+    (st) => rouxBlockDone(st, geo, sideA, upFace, slicePerm)
+  );
+  const bDone = snapshots.map(
+    (st) => rouxBlockDone(st, geo, sideB, upFace, slicePerm)
+  );
+  const aIdx = completionIndex(aDone);
+  const bIdx = completionIndex(bDone);
+  let firstSide = sideA;
+  let secondSide = sideB;
+  let fbBools = aDone;
+  let sbBools = bDone;
+  if ((bIdx != null ? bIdx : Infinity) < (aIdx != null ? aIdx : Infinity)) {
+    firstSide = sideB;
+    secondSide = sideA;
+    fbBools = bDone;
+    sbBools = aDone;
+  }
+  const fbIdx = completionIndex(fbBools);
+  const secondBlockBools = snapshots.map((_, i) => fbBools[i] && sbBools[i]);
+  const sbIdx = completionIndex(secondBlockBools);
+  const cmllIdx = completionIndex(
+    snapshots.map(
+      (st, i) => secondBlockBools[i] && cmllDone(st, geo, upFace, slicePerm)
+    )
+  );
+  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
+  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+}
+function isRoux(build) {
+  const { fbIdx, sbIdx, cmllIdx, lseIdx } = build;
+  if (fbIdx == null || sbIdx == null || cmllIdx == null || lseIdx == null)
+    return false;
+  return fbIdx <= sbIdx && sbIdx <= cmllIdx && cmllIdx <= lseIdx;
+}
 function analyzeSolution(moves, options = {}) {
-  var _a;
+  var _a, _b;
   const size = options.size === 2 ? 2 : 3;
   const unsupported = [];
   const seq = (Array.isArray(moves) ? moves : []).map((x) => {
     var _a2;
     const m = String((_a2 = x == null ? void 0 : x.m) != null ? _a2 : "").trim();
-    const { token, base } = normalizeToken(m);
-    const supported = base != null && SUPPORTED_BASES.has(base);
+    const { token, base: base2 } = normalizeToken(m);
+    const supported = base2 != null && SUPPORTED_BASES.has(base2);
     if (m.length > 0 && !supported) unsupported.push(m);
     return { m, mm: supported ? token : "", t: Number(x == null ? void 0 : x.t) };
   }).filter((x) => x.m.length > 0);
@@ -343,6 +415,10 @@ function analyzeSolution(moves, options = {}) {
     f2l: [],
     oll: null,
     pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
     allCrosses: {},
     unsupported
   };
@@ -369,13 +445,13 @@ function analyzeSolution(moves, options = {}) {
     };
   };
   if (size !== 3) {
-    const pll2 = milestone(pllIdxOnly, 0);
+    const pll = milestone(pllIdxOnly, 0);
     const total2 = seq[n - 1].t;
     return __spreadProps(__spreadValues({}, empty), {
       solved,
       total: total2,
       tps: total2 > 0 ? simplifiedCount / (total2 / 1e3) : 0,
-      pll: pll2.record
+      pll: pll.record
     });
   }
   const finalCenters = centersOf(snapshots[n - 1], geo);
@@ -388,14 +464,66 @@ function analyzeSolution(moves, options = {}) {
     allCrosses[color] = idx == null ? null : { at: seq[idx].t, moveIndex: idx, move: seq[idx].m };
   }
   const ordered = colors.map((color) => ({ color, build: buildForCross(snapshots, geo, color) })).sort((a, b) => {
-    var _a2, _b;
+    var _a2, _b2;
     const ai = (_a2 = a.build.crossIdx) != null ? _a2 : Infinity;
-    const bi = (_b = b.build.crossIdx) != null ? _b : Infinity;
+    const bi = (_b2 = b.build.crossIdx) != null ? _b2 : Infinity;
     return ai - bi;
   });
-  let chosen = (_a = ordered.find((c) => isCFOP(c.build))) != null ? _a : ordered[0];
-  const method = chosen && isCFOP(chosen.build) ? "CFOP" : "unknown";
-  const { color: crossColor, build } = chosen;
+  const cfopChosen = (_a = ordered.find((c) => isCFOP(c.build))) != null ? _a : ordered[0];
+  const cfopValid = !!cfopChosen && isCFOP(cfopChosen.build);
+  const perms = getMovePermutations(size);
+  const axisSlicePerm = (face) => {
+    if (face === 1 || face === 3) return perms["M"].cw;
+    if (face === 0 || face === 5) return perms["E"].cw;
+    return perms["S"].cw;
+  };
+  const rouxCandidates = [];
+  for (let s = 0; s < 6; s++) {
+    for (const u of geo.neighbors[s]) {
+      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, axisSlicePerm(s)));
+    }
+  }
+  const rouxBuild = (_b = rouxCandidates.filter((b) => isRoux(b)).sort((a, b) => a.fbIdx - b.fbIdx)[0]) != null ? _b : null;
+  let method = "unknown";
+  if (cfopValid && rouxBuild) {
+    method = cfopChosen.build.crossIdx <= rouxBuild.fbIdx ? "CFOP" : "Roux";
+  } else if (cfopValid) {
+    method = "CFOP";
+  } else if (rouxBuild) {
+    method = "Roux";
+  }
+  const total = seq[n - 1].t;
+  const base = {
+    size,
+    method,
+    solved,
+    total,
+    tps: total > 0 ? simplifiedCount / (total / 1e3) : 0,
+    moves: simplifiedMoves,
+    cross: null,
+    f2l: [],
+    oll: null,
+    pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
+    allCrosses,
+    unsupported
+  };
+  if (method === "Roux") {
+    const fbM = milestone(rouxBuild.fbIdx, 0);
+    const sbM = milestone(rouxBuild.sbIdx, fbM.at);
+    const cmllM = milestone(rouxBuild.cmllIdx, sbM.at);
+    const lseM = milestone(rouxBuild.lseIdx, cmllM.at);
+    return __spreadProps(__spreadValues({}, base), {
+      firstBlock: fbM.record ? __spreadValues({ side: finalCenters[rouxBuild.firstSide] }, fbM.record) : null,
+      secondBlock: sbM.record ? __spreadValues({ side: finalCenters[rouxBuild.secondSide] }, sbM.record) : null,
+      cmll: cmllM.record,
+      lse: lseM.record
+    });
+  }
+  const { color: crossColor, build } = cfopChosen;
   const crossM = milestone(build.crossIdx, 0);
   const cross = crossM.record ? __spreadValues({ color: crossColor }, crossM.record) : null;
   let prevAt = crossM.at;
@@ -408,25 +536,14 @@ function analyzeSolution(moves, options = {}) {
     }
   }
   const ollM = milestone(build.ollIdx, prevAt);
-  const oll = ollM.record;
   prevAt = ollM.at;
   const pllM = milestone(build.pllIdx, prevAt);
-  const pll = pllM.record;
-  const total = seq[n - 1].t;
-  return {
-    size,
-    method,
-    solved,
-    total,
-    tps: total > 0 ? simplifiedCount / (total / 1e3) : 0,
-    moves: simplifiedMoves,
+  return __spreadProps(__spreadValues({}, base), {
     cross,
     f2l,
-    oll,
-    pll,
-    allCrosses,
-    unsupported
-  };
+    oll: ollM.record,
+    pll: pllM.record
+  });
 }
 
 // src/index.js

package/dist/index.mjs

@@ -242,6 +242,40 @@ function ollDone(st, geo, color) {
   }
   return true;
 }
+function rouxBlockPieces(geo, sideFace, upFace) {
+  const downFace = geo.opposite[upFace];
+  const edges = geo.edgesByFace(sideFace).filter((e) => !e.faces.includes(upFace));
+  const corners = geo.cornersByFace(sideFace).filter((c) => c.faces.includes(downFace));
+  return { edges, corners };
+}
+function rouxBlockDone(st, geo, sideFace, upFace, slicePerm) {
+  const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
+  if (edges.length !== 3 || corners.length !== 2) return false;
+  let cur = st;
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    const ok = edges.every((e) => slotCorrect(cur, centers, e.indices, geo.per)) && corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per));
+    if (ok) return true;
+  }
+  return false;
+}
+function applyPerm(st, perm) {
+  const out = new Array(st.length);
+  for (let i = 0; i < st.length; i++) out[i] = st[perm[i]];
+  return out;
+}
+function cmllDone(st, geo, upFace, slicePerm) {
+  let cur = st;
+  const corners = geo.cornersByFace(upFace);
+  for (let m = 0; m < 4; m++) {
+    if (m > 0) cur = applyPerm(cur, slicePerm);
+    const centers = centersOf(cur, geo);
+    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
+      return true;
+  }
+  return false;
+}
 function completionIndex(bools) {
   const n = bools.length;
   if (n === 0 || !bools[n - 1]) return null;
@@ -287,15 +321,53 @@ function isCFOP(build) {
   const lastF2L = f2lSlots[3].idx;
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
+function buildForRoux(snapshots, geo, sideA, upFace, slicePerm) {
+  const n = snapshots.length;
+  const sideB = geo.opposite[sideA];
+  const aDone = snapshots.map(
+    (st) => rouxBlockDone(st, geo, sideA, upFace, slicePerm)
+  );
+  const bDone = snapshots.map(
+    (st) => rouxBlockDone(st, geo, sideB, upFace, slicePerm)
+  );
+  const aIdx = completionIndex(aDone);
+  const bIdx = completionIndex(bDone);
+  let firstSide = sideA;
+  let secondSide = sideB;
+  let fbBools = aDone;
+  let sbBools = bDone;
+  if ((bIdx != null ? bIdx : Infinity) < (aIdx != null ? aIdx : Infinity)) {
+    firstSide = sideB;
+    secondSide = sideA;
+    fbBools = bDone;
+    sbBools = aDone;
+  }
+  const fbIdx = completionIndex(fbBools);
+  const secondBlockBools = snapshots.map((_, i) => fbBools[i] && sbBools[i]);
+  const sbIdx = completionIndex(secondBlockBools);
+  const cmllIdx = completionIndex(
+    snapshots.map(
+      (st, i) => secondBlockBools[i] && cmllDone(st, geo, upFace, slicePerm)
+    )
+  );
+  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
+  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+}
+function isRoux(build) {
+  const { fbIdx, sbIdx, cmllIdx, lseIdx } = build;
+  if (fbIdx == null || sbIdx == null || cmllIdx == null || lseIdx == null)
+    return false;
+  return fbIdx <= sbIdx && sbIdx <= cmllIdx && cmllIdx <= lseIdx;
+}
 function analyzeSolution(moves, options = {}) {
-  var _a;
+  var _a, _b;
   const size = options.size === 2 ? 2 : 3;
   const unsupported = [];
   const seq = (Array.isArray(moves) ? moves : []).map((x) => {
     var _a2;
     const m = String((_a2 = x == null ? void 0 : x.m) != null ? _a2 : "").trim();
-    const { token, base } = normalizeToken(m);
-    const supported = base != null && SUPPORTED_BASES.has(base);
+    const { token, base: base2 } = normalizeToken(m);
+    const supported = base2 != null && SUPPORTED_BASES.has(base2);
     if (m.length > 0 && !supported) unsupported.push(m);
     return { m, mm: supported ? token : "", t: Number(x == null ? void 0 : x.t) };
   }).filter((x) => x.m.length > 0);
@@ -315,6 +387,10 @@ function analyzeSolution(moves, options = {}) {
     f2l: [],
     oll: null,
     pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
     allCrosses: {},
     unsupported
   };
@@ -341,13 +417,13 @@ function analyzeSolution(moves, options = {}) {
     };
   };
   if (size !== 3) {
-    const pll2 = milestone(pllIdxOnly, 0);
+    const pll = milestone(pllIdxOnly, 0);
     const total2 = seq[n - 1].t;
     return __spreadProps(__spreadValues({}, empty), {
       solved,
       total: total2,
       tps: total2 > 0 ? simplifiedCount / (total2 / 1e3) : 0,
-      pll: pll2.record
+      pll: pll.record
     });
   }
   const finalCenters = centersOf(snapshots[n - 1], geo);
@@ -360,14 +436,66 @@ function analyzeSolution(moves, options = {}) {
     allCrosses[color] = idx == null ? null : { at: seq[idx].t, moveIndex: idx, move: seq[idx].m };
   }
   const ordered = colors.map((color) => ({ color, build: buildForCross(snapshots, geo, color) })).sort((a, b) => {
-    var _a2, _b;
+    var _a2, _b2;
     const ai = (_a2 = a.build.crossIdx) != null ? _a2 : Infinity;
-    const bi = (_b = b.build.crossIdx) != null ? _b : Infinity;
+    const bi = (_b2 = b.build.crossIdx) != null ? _b2 : Infinity;
     return ai - bi;
   });
-  let chosen = (_a = ordered.find((c) => isCFOP(c.build))) != null ? _a : ordered[0];
-  const method = chosen && isCFOP(chosen.build) ? "CFOP" : "unknown";
-  const { color: crossColor, build } = chosen;
+  const cfopChosen = (_a = ordered.find((c) => isCFOP(c.build))) != null ? _a : ordered[0];
+  const cfopValid = !!cfopChosen && isCFOP(cfopChosen.build);
+  const perms = getMovePermutations(size);
+  const axisSlicePerm = (face) => {
+    if (face === 1 || face === 3) return perms["M"].cw;
+    if (face === 0 || face === 5) return perms["E"].cw;
+    return perms["S"].cw;
+  };
+  const rouxCandidates = [];
+  for (let s = 0; s < 6; s++) {
+    for (const u of geo.neighbors[s]) {
+      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, axisSlicePerm(s)));
+    }
+  }
+  const rouxBuild = (_b = rouxCandidates.filter((b) => isRoux(b)).sort((a, b) => a.fbIdx - b.fbIdx)[0]) != null ? _b : null;
+  let method = "unknown";
+  if (cfopValid && rouxBuild) {
+    method = cfopChosen.build.crossIdx <= rouxBuild.fbIdx ? "CFOP" : "Roux";
+  } else if (cfopValid) {
+    method = "CFOP";
+  } else if (rouxBuild) {
+    method = "Roux";
+  }
+  const total = seq[n - 1].t;
+  const base = {
+    size,
+    method,
+    solved,
+    total,
+    tps: total > 0 ? simplifiedCount / (total / 1e3) : 0,
+    moves: simplifiedMoves,
+    cross: null,
+    f2l: [],
+    oll: null,
+    pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
+    allCrosses,
+    unsupported
+  };
+  if (method === "Roux") {
+    const fbM = milestone(rouxBuild.fbIdx, 0);
+    const sbM = milestone(rouxBuild.sbIdx, fbM.at);
+    const cmllM = milestone(rouxBuild.cmllIdx, sbM.at);
+    const lseM = milestone(rouxBuild.lseIdx, cmllM.at);
+    return __spreadProps(__spreadValues({}, base), {
+      firstBlock: fbM.record ? __spreadValues({ side: finalCenters[rouxBuild.firstSide] }, fbM.record) : null,
+      secondBlock: sbM.record ? __spreadValues({ side: finalCenters[rouxBuild.secondSide] }, sbM.record) : null,
+      cmll: cmllM.record,
+      lse: lseM.record
+    });
+  }
+  const { color: crossColor, build } = cfopChosen;
   const crossM = milestone(build.crossIdx, 0);
   const cross = crossM.record ? __spreadValues({ color: crossColor }, crossM.record) : null;
   let prevAt = crossM.at;
@@ -380,25 +508,14 @@ function analyzeSolution(moves, options = {}) {
     }
   }
   const ollM = milestone(build.ollIdx, prevAt);
-  const oll = ollM.record;
   prevAt = ollM.at;
   const pllM = milestone(build.pllIdx, prevAt);
-  const pll = pllM.record;
-  const total = seq[n - 1].t;
-  return {
-    size,
-    method,
-    solved,
-    total,
-    tps: total > 0 ? simplifiedCount / (total / 1e3) : 0,
-    moves: simplifiedMoves,
+  return __spreadProps(__spreadValues({}, base), {
     cross,
     f2l,
-    oll,
-    pll,
-    allCrosses,
-    unsupported
-  };
+    oll: ollM.record,
+    pll: pllM.record
+  });
 }
 
 // src/index.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cube-state-engine",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "description": "An efficient representation in memory for tracking the Rubik's cube state on each movement.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",