cube-state-engine 1.7.0 → 1.7.1

package/.claude/settings.local.json

@@ -8,7 +8,8 @@
       "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(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,28 +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.
-// 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) {
+// 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;
-  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;
+  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.
@@ -358,23 +352,14 @@ function applyPerm(st, perm) {
   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;
+// 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
@@ -389,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.
@@ -444,57 +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, slicePerm) {
-  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 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 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 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, slicePerm)
-    )
-  );
-  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;
 }
 
 /**
@@ -623,27 +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.
-  // 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.
+  // 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 axisSlicePerm = (face) => {
+  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, axisSlicePerm(s)));
+      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,28 +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.
-// 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) {
+// 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;
-  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;
+  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.
@@ -358,23 +352,14 @@ function applyPerm(st, perm) {
   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;
+// 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
@@ -389,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.
@@ -444,57 +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, slicePerm) {
-  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 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 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 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, slicePerm)
-    )
-  );
-  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;
 }
 
 /**
@@ -623,27 +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.
-  // 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.
+  // 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 axisSlicePerm = (face) => {
+  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, axisSlicePerm(s)));
+      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,33 +276,20 @@ function rouxBlockPieces(geo, sideFace, upFace) {
   const corners = geo.cornersByFace(sideFace).filter((c) => c.faces.includes(downFace));
   return { edges, corners };
 }
-function rouxBlockDone(st, geo, sideFace, upFace, slicePerm) {
+function rouxBlockDone(st, geo, sideFace, upFace) {
   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;
+  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, 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 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;
@@ -310,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));
@@ -349,43 +343,38 @@ function isCFOP(build) {
   const lastF2L = f2lSlots[3].idx;
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
-function buildForRoux(snapshots, geo, sideA, upFace, slicePerm) {
-  const n = snapshots.length;
+function buildForRoux(snapshots, geo, sideA, upFace, lseIdx) {
   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 };
+  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;
@@ -472,18 +461,35 @@ function analyzeSolution(moves, options = {}) {
   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) => {
+  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, axisSlicePerm(s)));
+      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,33 +248,20 @@ function rouxBlockPieces(geo, sideFace, upFace) {
   const corners = geo.cornersByFace(sideFace).filter((c) => c.faces.includes(downFace));
   return { edges, corners };
 }
-function rouxBlockDone(st, geo, sideFace, upFace, slicePerm) {
+function rouxBlockDone(st, geo, sideFace, upFace) {
   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;
+  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, 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 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;
@@ -282,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));
@@ -321,43 +315,38 @@ function isCFOP(build) {
   const lastF2L = f2lSlots[3].idx;
   return ollIdx >= lastF2L && pllIdx >= ollIdx;
 }
-function buildForRoux(snapshots, geo, sideA, upFace, slicePerm) {
-  const n = snapshots.length;
+function buildForRoux(snapshots, geo, sideA, upFace, lseIdx) {
   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 };
+  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;
@@ -444,18 +433,35 @@ function analyzeSolution(moves, options = {}) {
   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) => {
+  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, axisSlicePerm(s)));
+      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.7.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",