cube-state-engine 1.6.0 → 1.7.1

package/.claude/settings.local.json

@@ -3,7 +3,13 @@
     "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)",
+      "Bash(npx jest *)"
     ]
   }
 }

package/dist/index.d.mts

@@ -327,15 +327,22 @@ function rouxBlockPieces(geo, sideFace, upFace) {
   return { edges, corners };
 }
 
-// A Roux block is done when its three edges and two corners are all placed.
-function rouxBlockDone(st, centers, geo, sideFace, upFace) {
+// A Roux block is done when its three edges and two corners all match the
+// centers. The block can be built while the slice between the two blocks is
+// rotated away from the centers; that offset is handled by the caller, which
+// evaluates each orientation against snapshots pre-rotated by a fixed slice
+// amount (see the candidate enumeration). Keeping the offset FIXED per
+// orientation -- rather than accepting any of the four rotations move-by-move --
+// is what makes detection match how the solve was actually framed instead of
+// firing on coincidental alignments.
+function rouxBlockDone(st, geo, sideFace, upFace) {
   const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
   if (edges.length !== 3 || corners.length !== 2) return false;
-  for (const e of edges)
-    if (!slotCorrect(st, centers, e.indices, geo.per)) return false;
-  for (const c of corners)
-    if (!slotCorrect(st, centers, c.indices, geo.per)) return false;
-  return true;
+  const centers = centersOf(st, geo);
+  return (
+    edges.every((e) => slotCorrect(st, centers, e.indices, geo.per)) &&
+    corners.every((c) => slotCorrect(st, centers, c.indices, geo.per))
+  );
 }
 
 // Applies a permutation (out[i] = st[perm[i]]) to a flat sticker array.
@@ -345,21 +352,14 @@ function applyPerm(st, perm) {
   return out;
 }
 
-// CMLL is done when the four corners touching the up face are solved, allowing
-// the M slice to be unaligned: we accept the state if ANY of the four M-slice
-// rotations makes those corners correct. M moves neither the corners nor the
-// L/R blocks, only the U/F/D/B centers (and M-slice edges), so this captures
-// exactly "last-layer corners solved, M not necessarily aligned yet".
-function cmllDone(st, geo, upFace, mPerm) {
-  let cur = st;
-  const corners = geo.cornersByFace(upFace);
-  for (let m = 0; m < 4; m++) {
-    if (m > 0) cur = applyPerm(cur, mPerm);
-    const centers = centersOf(cur, geo);
-    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
-      return true;
-  }
-  return false;
+// CMLL corners are done when the four corners touching the up face match the
+// centers. As with the blocks, any fixed slice offset is applied by the caller
+// via pre-rotated snapshots, so this is a plain match against the centers.
+function cmllCornersDone(st, geo, upFace) {
+  const centers = centersOf(st, geo);
+  return geo
+    .cornersByFace(upFace)
+    .every((c) => slotCorrect(st, centers, c.indices, geo.per));
 }
 
 // Index of the move that COMPLETES a stage: the first move after which the
@@ -374,6 +374,19 @@ function completionIndex(bools) {
   return null;
 }
 
+// Index of the FIRST move strictly after `after` at which the condition holds.
+// Used for a stage whose completion is "the first time X happens once the
+// previous stage is done" -- e.g. the last-layer corners getting solved after
+// the second block is built, even if the blocks are momentarily disturbed at
+// that instant. Returns null if `after` is null or the condition never holds.
+function firstIndexAfter(bools, after) {
+  if (after == null) return null;
+  for (let i = after + 1; i < bools.length; i++) {
+    if (bools[i]) return i;
+  }
+  return null;
+}
+
 // Builds the milestone indices for one assumed cross color. Detection is
 // cumulative: an F2L pair only counts while the cross is solved, and OLL only
 // counts once the full F2L is solved. This rejects transient false positives.
@@ -429,58 +442,65 @@ 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, mPerm) {
-  snapshots.length;
+// Builds the Roux milestone indices for one (sideFace, upFace) orientation,
+// using snapshots already pre-rotated by this orientation's fixed slice offset.
+//
+// Milestones are taken at FIRST achievement, not while a condition holds
+// continuously: once a stage is reached the solver moves on, and on face-move
+// Roux later stages routinely break and rebuild earlier ones (a CMLL alg breaks
+// a block; a face-move LSE breaks everything). So:
+//   1st block = first instant either side's block is built;
+//   2nd block = first instant the OTHER side's block is built afterwards -- NOT
+//               gated on the first block still being intact, which it often is
+//               not while the second is being inserted;
+//   CMLL      = first instant the last-layer corners are solved afterwards;
+//   LSE       = the fully solved cube (`lseIdx`, computed once by the caller and
+//               passed in, since "solved" is the same in every orientation).
+function buildForRoux(snapshots, geo, sideA, upFace, lseIdx) {
   const sideB = geo.opposite[sideA];
 
-  const centersAt = snapshots.map((st) => centersOf(st, geo));
-  const aDone = snapshots.map((st, i) =>
-    rouxBlockDone(st, centersAt[i], geo, sideA, upFace)
-  );
-  const bDone = snapshots.map((st, i) =>
-    rouxBlockDone(st, centersAt[i], geo, sideB, upFace)
-  );
-  const aIdx = completionIndex(aDone);
-  const bIdx = completionIndex(bDone);
+  const aDone = snapshots.map((st) => rouxBlockDone(st, geo, sideA, upFace));
+  const bDone = snapshots.map((st) => rouxBlockDone(st, geo, sideB, upFace));
+  const aIdx = firstIndexAfter(aDone, -1);
+  const bIdx = firstIndexAfter(bDone, -1);
+  if (aIdx == null || bIdx == null) return null;
 
-  // 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);
+  // First block = the side built earliest; the other side is the second block.
+  const aFirst = aIdx <= bIdx;
+  const firstSide = aFirst ? sideA : sideB;
+  const fbIdx = aFirst ? aIdx : bIdx;
+  const sbIdx = firstIndexAfter(aFirst ? bDone : aDone, fbIdx);
+  if (sbIdx == null) return null;
 
-  const cmllIdx = completionIndex(
-    snapshots.map(
-      (st, i) => secondBlockBools[i] && cmllDone(st, geo, upFace, mPerm)
-    )
-  );
-  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
+  const cornerBools = snapshots.map((st) => cmllCornersDone(st, geo, upFace));
+  const cmllIdx = firstIndexAfter(cornerBools, sbIdx);
+  if (cmllIdx == null) return null;
 
-  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+  return {
+    firstSide,
+    secondSide: aFirst ? sideB : sideA,
+    upFace,
+    fbIdx,
+    sbIdx,
+    cmllIdx,
+    lseIdx,
+  };
 }
 
 // Does this breakdown follow the Roux order: 1st block -> 2nd block -> CMLL -> LSE?
+// Shortest plausible length (in moves) of a genuine Roux stage. The block and
+// corner conditions flicker true at scattered transient instants throughout a
+// solve; a "stage" only a move or two long is one of those coincidences, not a
+// real second block or CMLL. Requiring a minimum span rejects them so a spurious
+// orientation cannot masquerade as a clean Roux staging.
+const ROUX_MIN_STAGE = 5;
+
 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;
+  if (!(fbIdx < sbIdx && sbIdx < cmllIdx && cmllIdx < lseIdx)) return false;
+  return sbIdx - fbIdx >= ROUX_MIN_STAGE && cmllIdx - sbIdx >= ROUX_MIN_STAGE;
 }
 
 /**
@@ -609,20 +629,60 @@ function analyzeSolution(moves, options = {}) {
   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.
-  // Pick the valid candidate whose first block completes earliest.
-  const mPerm = getMovePermutations(size)["M"].cw;
+  // orientation. A candidate fixes a side face, a perpendicular up face, and a
+  // slice offset `d`: the blocks can be assembled with the slice between them
+  // turned away from the centers, so each orientation is tested against
+  // snapshots pre-rotated by d quarter-turns of its axis slice (M for L/R blocks,
+  // E for U/D, S for F/B). Holding that offset fixed for the whole solve (rather
+  // than re-matching it move-by-move) is what stops a block reading as "built"
+  // on a coincidental alignment.
+  //
+  // Many orientations still yield a technically ordered staging. The one that
+  // reflects the real solve is the one whose three build milestones land
+  // EARLIEST in aggregate (smallest fb + sb + cmll): a false orientation only
+  // assembles its blocks and corners by coincidence, which does not happen
+  // earlier than the genuine build. (isRoux discards orientations whose stages
+  // are too short to be anything but a coincidence.) "Solved" is orientation-
+  // independent, so the LSE index is computed once and shared.
+  const perms = getMovePermutations(size);
+  const sliceCwOf = (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 lseIdx = completionIndex(
+    snapshots.map((st) => isSolvedFlat(st, geo.per))
+  );
+  // Snapshots rotated by d quarter-turns of a given slice, built incrementally
+  // and cached so each (axis, d) is computed once and reused across its up faces.
+  const rotCache = new Map();
+  const rotatedSnaps = (sliceCw, d) => {
+    const key = `${sliceCw}:${d}`;
+    if (rotCache.has(key)) return rotCache.get(key);
+    const snaps =
+      d === 0
+        ? snapshots
+        : rotatedSnaps(sliceCw, d - 1).map((st) => applyPerm(st, sliceCw));
+    rotCache.set(key, snaps);
+    return snaps;
+  };
   const rouxCandidates = [];
   for (let s = 0; s < 6; s++) {
+    const sliceCw = sliceCwOf(s);
     for (const u of geo.neighbors[s]) {
-      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, mPerm));
+      for (let d = 0; d < 4; d++) {
+        const build = buildForRoux(rotatedSnaps(sliceCw, d), geo, s, u, lseIdx);
+        if (build) rouxCandidates.push(build);
+      }
     }
   }
   const rouxBuild =
     rouxCandidates
       .filter((b) => isRoux(b))
-      .sort((a, b) => a.fbIdx - b.fbIdx)[0] ?? null;
+      .sort(
+        (a, b) =>
+          a.fbIdx + a.sbIdx + a.cmllIdx - (b.fbIdx + b.sbIdx + b.cmllIdx)
+      )[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

package/dist/index.d.ts

@@ -327,15 +327,22 @@ function rouxBlockPieces(geo, sideFace, upFace) {
   return { edges, corners };
 }
 
-// A Roux block is done when its three edges and two corners are all placed.
-function rouxBlockDone(st, centers, geo, sideFace, upFace) {
+// A Roux block is done when its three edges and two corners all match the
+// centers. The block can be built while the slice between the two blocks is
+// rotated away from the centers; that offset is handled by the caller, which
+// evaluates each orientation against snapshots pre-rotated by a fixed slice
+// amount (see the candidate enumeration). Keeping the offset FIXED per
+// orientation -- rather than accepting any of the four rotations move-by-move --
+// is what makes detection match how the solve was actually framed instead of
+// firing on coincidental alignments.
+function rouxBlockDone(st, geo, sideFace, upFace) {
   const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
   if (edges.length !== 3 || corners.length !== 2) return false;
-  for (const e of edges)
-    if (!slotCorrect(st, centers, e.indices, geo.per)) return false;
-  for (const c of corners)
-    if (!slotCorrect(st, centers, c.indices, geo.per)) return false;
-  return true;
+  const centers = centersOf(st, geo);
+  return (
+    edges.every((e) => slotCorrect(st, centers, e.indices, geo.per)) &&
+    corners.every((c) => slotCorrect(st, centers, c.indices, geo.per))
+  );
 }
 
 // Applies a permutation (out[i] = st[perm[i]]) to a flat sticker array.
@@ -345,21 +352,14 @@ function applyPerm(st, perm) {
   return out;
 }
 
-// CMLL is done when the four corners touching the up face are solved, allowing
-// the M slice to be unaligned: we accept the state if ANY of the four M-slice
-// rotations makes those corners correct. M moves neither the corners nor the
-// L/R blocks, only the U/F/D/B centers (and M-slice edges), so this captures
-// exactly "last-layer corners solved, M not necessarily aligned yet".
-function cmllDone(st, geo, upFace, mPerm) {
-  let cur = st;
-  const corners = geo.cornersByFace(upFace);
-  for (let m = 0; m < 4; m++) {
-    if (m > 0) cur = applyPerm(cur, mPerm);
-    const centers = centersOf(cur, geo);
-    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
-      return true;
-  }
-  return false;
+// CMLL corners are done when the four corners touching the up face match the
+// centers. As with the blocks, any fixed slice offset is applied by the caller
+// via pre-rotated snapshots, so this is a plain match against the centers.
+function cmllCornersDone(st, geo, upFace) {
+  const centers = centersOf(st, geo);
+  return geo
+    .cornersByFace(upFace)
+    .every((c) => slotCorrect(st, centers, c.indices, geo.per));
 }
 
 // Index of the move that COMPLETES a stage: the first move after which the
@@ -374,6 +374,19 @@ function completionIndex(bools) {
   return null;
 }
 
+// Index of the FIRST move strictly after `after` at which the condition holds.
+// Used for a stage whose completion is "the first time X happens once the
+// previous stage is done" -- e.g. the last-layer corners getting solved after
+// the second block is built, even if the blocks are momentarily disturbed at
+// that instant. Returns null if `after` is null or the condition never holds.
+function firstIndexAfter(bools, after) {
+  if (after == null) return null;
+  for (let i = after + 1; i < bools.length; i++) {
+    if (bools[i]) return i;
+  }
+  return null;
+}
+
 // Builds the milestone indices for one assumed cross color. Detection is
 // cumulative: an F2L pair only counts while the cross is solved, and OLL only
 // counts once the full F2L is solved. This rejects transient false positives.
@@ -429,58 +442,65 @@ 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, mPerm) {
-  snapshots.length;
+// Builds the Roux milestone indices for one (sideFace, upFace) orientation,
+// using snapshots already pre-rotated by this orientation's fixed slice offset.
+//
+// Milestones are taken at FIRST achievement, not while a condition holds
+// continuously: once a stage is reached the solver moves on, and on face-move
+// Roux later stages routinely break and rebuild earlier ones (a CMLL alg breaks
+// a block; a face-move LSE breaks everything). So:
+//   1st block = first instant either side's block is built;
+//   2nd block = first instant the OTHER side's block is built afterwards -- NOT
+//               gated on the first block still being intact, which it often is
+//               not while the second is being inserted;
+//   CMLL      = first instant the last-layer corners are solved afterwards;
+//   LSE       = the fully solved cube (`lseIdx`, computed once by the caller and
+//               passed in, since "solved" is the same in every orientation).
+function buildForRoux(snapshots, geo, sideA, upFace, lseIdx) {
   const sideB = geo.opposite[sideA];
 
-  const centersAt = snapshots.map((st) => centersOf(st, geo));
-  const aDone = snapshots.map((st, i) =>
-    rouxBlockDone(st, centersAt[i], geo, sideA, upFace)
-  );
-  const bDone = snapshots.map((st, i) =>
-    rouxBlockDone(st, centersAt[i], geo, sideB, upFace)
-  );
-  const aIdx = completionIndex(aDone);
-  const bIdx = completionIndex(bDone);
+  const aDone = snapshots.map((st) => rouxBlockDone(st, geo, sideA, upFace));
+  const bDone = snapshots.map((st) => rouxBlockDone(st, geo, sideB, upFace));
+  const aIdx = firstIndexAfter(aDone, -1);
+  const bIdx = firstIndexAfter(bDone, -1);
+  if (aIdx == null || bIdx == null) return null;
 
-  // 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);
+  // First block = the side built earliest; the other side is the second block.
+  const aFirst = aIdx <= bIdx;
+  const firstSide = aFirst ? sideA : sideB;
+  const fbIdx = aFirst ? aIdx : bIdx;
+  const sbIdx = firstIndexAfter(aFirst ? bDone : aDone, fbIdx);
+  if (sbIdx == null) return null;
 
-  const cmllIdx = completionIndex(
-    snapshots.map(
-      (st, i) => secondBlockBools[i] && cmllDone(st, geo, upFace, mPerm)
-    )
-  );
-  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
+  const cornerBools = snapshots.map((st) => cmllCornersDone(st, geo, upFace));
+  const cmllIdx = firstIndexAfter(cornerBools, sbIdx);
+  if (cmllIdx == null) return null;
 
-  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+  return {
+    firstSide,
+    secondSide: aFirst ? sideB : sideA,
+    upFace,
+    fbIdx,
+    sbIdx,
+    cmllIdx,
+    lseIdx,
+  };
 }
 
 // Does this breakdown follow the Roux order: 1st block -> 2nd block -> CMLL -> LSE?
+// Shortest plausible length (in moves) of a genuine Roux stage. The block and
+// corner conditions flicker true at scattered transient instants throughout a
+// solve; a "stage" only a move or two long is one of those coincidences, not a
+// real second block or CMLL. Requiring a minimum span rejects them so a spurious
+// orientation cannot masquerade as a clean Roux staging.
+const ROUX_MIN_STAGE = 5;
+
 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;
+  if (!(fbIdx < sbIdx && sbIdx < cmllIdx && cmllIdx < lseIdx)) return false;
+  return sbIdx - fbIdx >= ROUX_MIN_STAGE && cmllIdx - sbIdx >= ROUX_MIN_STAGE;
 }
 
 /**
@@ -609,20 +629,60 @@ function analyzeSolution(moves, options = {}) {
   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.
-  // Pick the valid candidate whose first block completes earliest.
-  const mPerm = getMovePermutations(size)["M"].cw;
+  // orientation. A candidate fixes a side face, a perpendicular up face, and a
+  // slice offset `d`: the blocks can be assembled with the slice between them
+  // turned away from the centers, so each orientation is tested against
+  // snapshots pre-rotated by d quarter-turns of its axis slice (M for L/R blocks,
+  // E for U/D, S for F/B). Holding that offset fixed for the whole solve (rather
+  // than re-matching it move-by-move) is what stops a block reading as "built"
+  // on a coincidental alignment.
+  //
+  // Many orientations still yield a technically ordered staging. The one that
+  // reflects the real solve is the one whose three build milestones land
+  // EARLIEST in aggregate (smallest fb + sb + cmll): a false orientation only
+  // assembles its blocks and corners by coincidence, which does not happen
+  // earlier than the genuine build. (isRoux discards orientations whose stages
+  // are too short to be anything but a coincidence.) "Solved" is orientation-
+  // independent, so the LSE index is computed once and shared.
+  const perms = getMovePermutations(size);
+  const sliceCwOf = (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 lseIdx = completionIndex(
+    snapshots.map((st) => isSolvedFlat(st, geo.per))
+  );
+  // Snapshots rotated by d quarter-turns of a given slice, built incrementally
+  // and cached so each (axis, d) is computed once and reused across its up faces.
+  const rotCache = new Map();
+  const rotatedSnaps = (sliceCw, d) => {
+    const key = `${sliceCw}:${d}`;
+    if (rotCache.has(key)) return rotCache.get(key);
+    const snaps =
+      d === 0
+        ? snapshots
+        : rotatedSnaps(sliceCw, d - 1).map((st) => applyPerm(st, sliceCw));
+    rotCache.set(key, snaps);
+    return snaps;
+  };
   const rouxCandidates = [];
   for (let s = 0; s < 6; s++) {
+    const sliceCw = sliceCwOf(s);
     for (const u of geo.neighbors[s]) {
-      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, mPerm));
+      for (let d = 0; d < 4; d++) {
+        const build = buildForRoux(rotatedSnaps(sliceCw, d), geo, s, u, lseIdx);
+        if (build) rouxCandidates.push(build);
+      }
     }
   }
   const rouxBuild =
     rouxCandidates
       .filter((b) => isRoux(b))
-      .sort((a, b) => a.fbIdx - b.fbIdx)[0] ?? null;
+      .sort(
+        (a, b) =>
+          a.fbIdx + a.sbIdx + a.cmllIdx - (b.fbIdx + b.sbIdx + b.cmllIdx)
+      )[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

package/dist/index.js

@@ -276,30 +276,20 @@ function rouxBlockPieces(geo, sideFace, upFace) {
   const corners = geo.cornersByFace(sideFace).filter((c) => c.faces.includes(downFace));
   return { edges, corners };
 }
-function rouxBlockDone(st, centers, geo, sideFace, upFace) {
+function rouxBlockDone(st, geo, sideFace, upFace) {
   const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
   if (edges.length !== 3 || corners.length !== 2) return false;
-  for (const e of edges)
-    if (!slotCorrect(st, centers, e.indices, geo.per)) return false;
-  for (const c of corners)
-    if (!slotCorrect(st, centers, c.indices, geo.per)) return false;
-  return true;
+  const centers = centersOf(st, geo);
+  return edges.every((e) => slotCorrect(st, centers, e.indices, geo.per)) && corners.every((c) => slotCorrect(st, centers, c.indices, geo.per));
 }
 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, mPerm) {
-  let cur = st;
-  const corners = geo.cornersByFace(upFace);
-  for (let m = 0; m < 4; m++) {
-    if (m > 0) cur = applyPerm(cur, mPerm);
-    const centers = centersOf(cur, geo);
-    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
-      return true;
-  }
-  return false;
+function cmllCornersDone(st, geo, upFace) {
+  const centers = centersOf(st, geo);
+  return geo.cornersByFace(upFace).every((c) => slotCorrect(st, centers, c.indices, geo.per));
 }
 function completionIndex(bools) {
   const n = bools.length;
@@ -307,6 +297,13 @@ function completionIndex(bools) {
   for (let i = 0; i < n; i++) if (bools[i]) return i;
   return null;
 }
+function firstIndexAfter(bools, after) {
+  if (after == null) return null;
+  for (let i = after + 1; i < bools.length; i++) {
+    if (bools[i]) return i;
+  }
+  return null;
+}
 function buildForCross(snapshots, geo, color) {
   const n = snapshots.length;
   const crossBools = snapshots.map((st) => crossDone(st, geo, color));
@@ -346,44 +343,38 @@ function isCFOP(build) {
   const lastF2L = f2lSlots[3].idx;
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
-function buildForRoux(snapshots, geo, sideA, upFace, mPerm) {
-  const n = snapshots.length;
+function buildForRoux(snapshots, geo, sideA, upFace, lseIdx) {
   const sideB = geo.opposite[sideA];
-  const centersAt = snapshots.map((st) => centersOf(st, geo));
-  const aDone = snapshots.map(
-    (st, i) => rouxBlockDone(st, centersAt[i], geo, sideA, upFace)
-  );
-  const bDone = snapshots.map(
-    (st, i) => rouxBlockDone(st, centersAt[i], geo, sideB, upFace)
-  );
-  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, mPerm)
-    )
-  );
-  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
-  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+  const aDone = snapshots.map((st) => rouxBlockDone(st, geo, sideA, upFace));
+  const bDone = snapshots.map((st) => rouxBlockDone(st, geo, sideB, upFace));
+  const aIdx = firstIndexAfter(aDone, -1);
+  const bIdx = firstIndexAfter(bDone, -1);
+  if (aIdx == null || bIdx == null) return null;
+  const aFirst = aIdx <= bIdx;
+  const firstSide = aFirst ? sideA : sideB;
+  const fbIdx = aFirst ? aIdx : bIdx;
+  const sbIdx = firstIndexAfter(aFirst ? bDone : aDone, fbIdx);
+  if (sbIdx == null) return null;
+  const cornerBools = snapshots.map((st) => cmllCornersDone(st, geo, upFace));
+  const cmllIdx = firstIndexAfter(cornerBools, sbIdx);
+  if (cmllIdx == null) return null;
+  return {
+    firstSide,
+    secondSide: aFirst ? sideB : sideA,
+    upFace,
+    fbIdx,
+    sbIdx,
+    cmllIdx,
+    lseIdx
+  };
 }
+var ROUX_MIN_STAGE = 5;
 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;
+  if (!(fbIdx < sbIdx && sbIdx < cmllIdx && cmllIdx < lseIdx)) return false;
+  return sbIdx - fbIdx >= ROUX_MIN_STAGE && cmllIdx - sbIdx >= ROUX_MIN_STAGE;
 }
 function analyzeSolution(moves, options = {}) {
   var _a, _b;
@@ -469,14 +460,36 @@ function analyzeSolution(moves, options = {}) {
   });
   const cfopChosen = (_a = ordered.find((c) => isCFOP(c.build))) != null ? _a : ordered[0];
   const cfopValid = !!cfopChosen && isCFOP(cfopChosen.build);
-  const mPerm = getMovePermutations(size)["M"].cw;
+  const perms = getMovePermutations(size);
+  const sliceCwOf = (face) => {
+    if (face === 1 || face === 3) return perms["M"].cw;
+    if (face === 0 || face === 5) return perms["E"].cw;
+    return perms["S"].cw;
+  };
+  const lseIdx = completionIndex(
+    snapshots.map((st) => isSolvedFlat(st, geo.per))
+  );
+  const rotCache = /* @__PURE__ */ new Map();
+  const rotatedSnaps = (sliceCw, d) => {
+    const key = `${sliceCw}:${d}`;
+    if (rotCache.has(key)) return rotCache.get(key);
+    const snaps = d === 0 ? snapshots : rotatedSnaps(sliceCw, d - 1).map((st) => applyPerm(st, sliceCw));
+    rotCache.set(key, snaps);
+    return snaps;
+  };
   const rouxCandidates = [];
   for (let s = 0; s < 6; s++) {
+    const sliceCw = sliceCwOf(s);
     for (const u of geo.neighbors[s]) {
-      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, mPerm));
+      for (let d = 0; d < 4; d++) {
+        const build2 = buildForRoux(rotatedSnaps(sliceCw, d), geo, s, u, lseIdx);
+        if (build2) rouxCandidates.push(build2);
+      }
     }
   }
-  const rouxBuild = (_b = rouxCandidates.filter((b) => isRoux(b)).sort((a, b) => a.fbIdx - b.fbIdx)[0]) != null ? _b : null;
+  const rouxBuild = (_b = rouxCandidates.filter((b) => isRoux(b)).sort(
+    (a, b) => a.fbIdx + a.sbIdx + a.cmllIdx - (b.fbIdx + b.sbIdx + b.cmllIdx)
+  )[0]) != null ? _b : null;
   let method = "unknown";
   if (cfopValid && rouxBuild) {
     method = cfopChosen.build.crossIdx <= rouxBuild.fbIdx ? "CFOP" : "Roux";

package/dist/index.mjs

@@ -248,30 +248,20 @@ function rouxBlockPieces(geo, sideFace, upFace) {
   const corners = geo.cornersByFace(sideFace).filter((c) => c.faces.includes(downFace));
   return { edges, corners };
 }
-function rouxBlockDone(st, centers, geo, sideFace, upFace) {
+function rouxBlockDone(st, geo, sideFace, upFace) {
   const { edges, corners } = rouxBlockPieces(geo, sideFace, upFace);
   if (edges.length !== 3 || corners.length !== 2) return false;
-  for (const e of edges)
-    if (!slotCorrect(st, centers, e.indices, geo.per)) return false;
-  for (const c of corners)
-    if (!slotCorrect(st, centers, c.indices, geo.per)) return false;
-  return true;
+  const centers = centersOf(st, geo);
+  return edges.every((e) => slotCorrect(st, centers, e.indices, geo.per)) && corners.every((c) => slotCorrect(st, centers, c.indices, geo.per));
 }
 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, mPerm) {
-  let cur = st;
-  const corners = geo.cornersByFace(upFace);
-  for (let m = 0; m < 4; m++) {
-    if (m > 0) cur = applyPerm(cur, mPerm);
-    const centers = centersOf(cur, geo);
-    if (corners.every((c) => slotCorrect(cur, centers, c.indices, geo.per)))
-      return true;
-  }
-  return false;
+function cmllCornersDone(st, geo, upFace) {
+  const centers = centersOf(st, geo);
+  return geo.cornersByFace(upFace).every((c) => slotCorrect(st, centers, c.indices, geo.per));
 }
 function completionIndex(bools) {
   const n = bools.length;
@@ -279,6 +269,13 @@ function completionIndex(bools) {
   for (let i = 0; i < n; i++) if (bools[i]) return i;
   return null;
 }
+function firstIndexAfter(bools, after) {
+  if (after == null) return null;
+  for (let i = after + 1; i < bools.length; i++) {
+    if (bools[i]) return i;
+  }
+  return null;
+}
 function buildForCross(snapshots, geo, color) {
   const n = snapshots.length;
   const crossBools = snapshots.map((st) => crossDone(st, geo, color));
@@ -318,44 +315,38 @@ function isCFOP(build) {
   const lastF2L = f2lSlots[3].idx;
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
-function buildForRoux(snapshots, geo, sideA, upFace, mPerm) {
-  const n = snapshots.length;
+function buildForRoux(snapshots, geo, sideA, upFace, lseIdx) {
   const sideB = geo.opposite[sideA];
-  const centersAt = snapshots.map((st) => centersOf(st, geo));
-  const aDone = snapshots.map(
-    (st, i) => rouxBlockDone(st, centersAt[i], geo, sideA, upFace)
-  );
-  const bDone = snapshots.map(
-    (st, i) => rouxBlockDone(st, centersAt[i], geo, sideB, upFace)
-  );
-  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, mPerm)
-    )
-  );
-  const lseIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
-  return { firstSide, secondSide, upFace, fbIdx, sbIdx, cmllIdx, lseIdx };
+  const aDone = snapshots.map((st) => rouxBlockDone(st, geo, sideA, upFace));
+  const bDone = snapshots.map((st) => rouxBlockDone(st, geo, sideB, upFace));
+  const aIdx = firstIndexAfter(aDone, -1);
+  const bIdx = firstIndexAfter(bDone, -1);
+  if (aIdx == null || bIdx == null) return null;
+  const aFirst = aIdx <= bIdx;
+  const firstSide = aFirst ? sideA : sideB;
+  const fbIdx = aFirst ? aIdx : bIdx;
+  const sbIdx = firstIndexAfter(aFirst ? bDone : aDone, fbIdx);
+  if (sbIdx == null) return null;
+  const cornerBools = snapshots.map((st) => cmllCornersDone(st, geo, upFace));
+  const cmllIdx = firstIndexAfter(cornerBools, sbIdx);
+  if (cmllIdx == null) return null;
+  return {
+    firstSide,
+    secondSide: aFirst ? sideB : sideA,
+    upFace,
+    fbIdx,
+    sbIdx,
+    cmllIdx,
+    lseIdx
+  };
 }
+var ROUX_MIN_STAGE = 5;
 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;
+  if (!(fbIdx < sbIdx && sbIdx < cmllIdx && cmllIdx < lseIdx)) return false;
+  return sbIdx - fbIdx >= ROUX_MIN_STAGE && cmllIdx - sbIdx >= ROUX_MIN_STAGE;
 }
 function analyzeSolution(moves, options = {}) {
   var _a, _b;
@@ -441,14 +432,36 @@ function analyzeSolution(moves, options = {}) {
   });
   const cfopChosen = (_a = ordered.find((c) => isCFOP(c.build))) != null ? _a : ordered[0];
   const cfopValid = !!cfopChosen && isCFOP(cfopChosen.build);
-  const mPerm = getMovePermutations(size)["M"].cw;
+  const perms = getMovePermutations(size);
+  const sliceCwOf = (face) => {
+    if (face === 1 || face === 3) return perms["M"].cw;
+    if (face === 0 || face === 5) return perms["E"].cw;
+    return perms["S"].cw;
+  };
+  const lseIdx = completionIndex(
+    snapshots.map((st) => isSolvedFlat(st, geo.per))
+  );
+  const rotCache = /* @__PURE__ */ new Map();
+  const rotatedSnaps = (sliceCw, d) => {
+    const key = `${sliceCw}:${d}`;
+    if (rotCache.has(key)) return rotCache.get(key);
+    const snaps = d === 0 ? snapshots : rotatedSnaps(sliceCw, d - 1).map((st) => applyPerm(st, sliceCw));
+    rotCache.set(key, snaps);
+    return snaps;
+  };
   const rouxCandidates = [];
   for (let s = 0; s < 6; s++) {
+    const sliceCw = sliceCwOf(s);
     for (const u of geo.neighbors[s]) {
-      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, mPerm));
+      for (let d = 0; d < 4; d++) {
+        const build2 = buildForRoux(rotatedSnaps(sliceCw, d), geo, s, u, lseIdx);
+        if (build2) rouxCandidates.push(build2);
+      }
     }
   }
-  const rouxBuild = (_b = rouxCandidates.filter((b) => isRoux(b)).sort((a, b) => a.fbIdx - b.fbIdx)[0]) != null ? _b : null;
+  const rouxBuild = (_b = rouxCandidates.filter((b) => isRoux(b)).sort(
+    (a, b) => a.fbIdx + a.sbIdx + a.cmllIdx - (b.fbIdx + b.sbIdx + b.cmllIdx)
+  )[0]) != null ? _b : null;
   let method = "unknown";
   if (cfopValid && rouxBuild) {
     method = cfopChosen.build.crossIdx <= rouxBuild.fbIdx ? "CFOP" : "Roux";

package/package.json

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