cube-state-engine 1.4.0 → 1.6.0

package/dist/index.js

@@ -1,6 +1,8 @@
 "use strict";
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -20,6 +22,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -35,24 +38,864 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
   COLOR: () => COLOR,
-  CubeEngine: () => CubeEngine
+  CubeEngine: () => CubeEngine,
+  analyzeSolution: () => analyzeSolution,
+  getMovePermutations: () => getMovePermutations,
+  invertSequence: () => invertSequence,
+  simplifyMoves: () => simplifyMoves
 });
 module.exports = __toCommonJS(src_exports);
-var _CubeEngine_instances, initializeState_fn, createFace_fn, rotateU_fn, rotateF_fn, rotateB_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
+
+// src/simplify.js
+function canMerge(a, b) {
+  return typeof a === "string" && a === b && !a.includes("2");
+}
+function doubled(tok) {
+  return tok.replace("'", "") + "2";
+}
+function simplifyTokens(tokens) {
+  const out = [];
+  for (let i = 0; i < tokens.length; ) {
+    const a = tokens[i];
+    const b = tokens[i + 1];
+    if (i + 1 < tokens.length && canMerge(a, b)) {
+      out.push(doubled(a));
+      i += 2;
+    } else {
+      out.push(a);
+      i += 1;
+    }
+  }
+  return out;
+}
+function simplifyTimed(moves) {
+  const out = [];
+  for (let i = 0; i < moves.length; ) {
+    const a = moves[i];
+    const b = moves[i + 1];
+    if (i + 1 < moves.length && canMerge(a == null ? void 0 : a.m, b == null ? void 0 : b.m)) {
+      out.push({ m: doubled(a.m), t: b.t });
+      i += 2;
+    } else {
+      out.push(a);
+      i += 1;
+    }
+  }
+  return out;
+}
+function simplifyMoves(moves) {
+  if (typeof moves === "string") {
+    const tokens = moves.split(/\s+/).filter((t) => t.length > 0);
+    return simplifyTokens(tokens).join(" ");
+  }
+  if (Array.isArray(moves)) {
+    if (moves.length === 0) return [];
+    if (typeof moves[0] === "string") return simplifyTokens(moves);
+    return simplifyTimed(moves);
+  }
+  return moves;
+}
+
+// src/analyzer.js
+var FACE_NAMES = ["UPPER", "LEFT", "FRONT", "RIGHT", "BACK", "DOWN"];
+var FACE_MOVE_TO_INDEX = { U: 0, L: 1, F: 2, R: 3, B: 4, D: 5 };
+var SUPPORTED_BASES = /* @__PURE__ */ new Set([
+  "U",
+  "D",
+  "L",
+  "R",
+  "F",
+  "B",
+  "x",
+  "y",
+  "z",
+  "M",
+  "E",
+  "S",
+  "Uw",
+  "Dw",
+  "Rw",
+  "Lw",
+  "Fw"
+]);
+var WIDE_LOWER = { r: "Rw", u: "Uw", f: "Fw", l: "Lw", d: "Dw", b: "Bw" };
+function normalizeToken(raw) {
+  const m = String(raw).trim().match(/^([A-Za-z]w?)('?2?|2?'?)$/);
+  if (!m) return { token: raw, base: null };
+  let base = m[1];
+  if (base.length === 1 && WIDE_LOWER[base]) base = WIDE_LOWER[base];
+  return { token: base + m[2], base };
+}
+var GEOMETRY_CACHE = /* @__PURE__ */ new Map();
+function buildGeometry(size) {
+  if (GEOMETRY_CACHE.has(size)) return GEOMETRY_CACHE.get(size);
+  const perms = getMovePermutations(size);
+  const per = size * size;
+  const total = per * 6;
+  const faceMoves = Object.keys(FACE_MOVE_TO_INDEX);
+  const edgeMap = /* @__PURE__ */ new Map();
+  const cornerMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < total; i++) {
+    const faces = [];
+    for (const mv of faceMoves) {
+      if (perms[mv].cw[i] !== i) faces.push(FACE_MOVE_TO_INDEX[mv]);
+    }
+    faces.sort((a, b) => a - b);
+    const key = faces.join(",");
+    if (faces.length === 2) {
+      if (!edgeMap.has(key)) edgeMap.set(key, []);
+      edgeMap.get(key).push(i);
+    } else if (faces.length === 3) {
+      if (!cornerMap.has(key)) cornerMap.set(key, []);
+      cornerMap.get(key).push(i);
+    }
+  }
+  const edges = [...edgeMap.entries()].map(([key, indices]) => ({
+    faces: key.split(",").map(Number),
+    indices
+  }));
+  const corners = [...cornerMap.entries()].map(([key, indices]) => ({
+    faces: key.split(",").map(Number),
+    indices
+  }));
+  const neighbors = Array.from({ length: 6 }, () => /* @__PURE__ */ new Set());
+  for (const e of edges) {
+    const [a, b] = e.faces;
+    neighbors[a].add(b);
+    neighbors[b].add(a);
+  }
+  const opposite = new Array(6).fill(-1);
+  for (let f = 0; f < 6; f++) {
+    for (let g = 0; g < 6; g++) {
+      if (g !== f && !neighbors[f].has(g)) {
+        opposite[f] = g;
+        break;
+      }
+    }
+  }
+  const geo = {
+    size,
+    per,
+    centerIndex: (f) => f * per + Math.floor(per / 2),
+    edges,
+    corners,
+    neighbors,
+    opposite,
+    edgesByFace: (f) => edges.filter((e) => e.faces.includes(f)),
+    cornersByFace: (f) => corners.filter((c) => c.faces.includes(f)),
+    edgeByPair: (a, b) => edges.find(
+      (e) => e.faces[0] === a && e.faces[1] === b || e.faces[0] === b && e.faces[1] === a
+    )
+  };
+  GEOMETRY_CACHE.set(size, geo);
+  return geo;
+}
+function invertToken(tok) {
+  if (tok.endsWith("2")) return tok;
+  if (tok.endsWith("'")) return tok.slice(0, -1);
+  return tok + "'";
+}
+function invertSequence(tokens) {
+  return tokens.slice().reverse().map(invertToken);
+}
+function flattenState(state) {
+  const out = [];
+  for (const name of FACE_NAMES) {
+    const matrix = state[name];
+    for (const row of matrix) {
+      for (const v of row) out.push(v);
+    }
+  }
+  return out;
+}
+function centersOf(st, geo) {
+  const centers = new Array(6);
+  for (let f = 0; f < 6; f++) centers[f] = st[geo.centerIndex(f)];
+  return centers;
+}
+function slotCorrect(st, centers, indices, per) {
+  for (const x of indices) {
+    if (st[x] !== centers[Math.floor(x / per)]) return false;
+  }
+  return true;
+}
+function isSolvedFlat(st, per) {
+  for (let f = 0; f < 6; f++) {
+    const base = f * per;
+    const c = st[base];
+    for (let i = 1; i < per; i++) if (st[base + i] !== c) return false;
+  }
+  return true;
+}
+function crossDone(st, geo, color) {
+  const centers = centersOf(st, geo);
+  const C = centers.indexOf(color);
+  if (C < 0) return false;
+  return geo.edgesByFace(C).every((e) => slotCorrect(st, centers, e.indices, geo.per));
+}
+function f2lSlotStates(st, geo, color) {
+  const centers = centersOf(st, geo);
+  const C = centers.indexOf(color);
+  const result = {};
+  if (C < 0) return result;
+  for (const corner of geo.cornersByFace(C)) {
+    const sides = corner.faces.filter((f) => f !== C);
+    if (sides.length !== 2) continue;
+    const [a, b] = sides;
+    const edge = geo.edgeByPair(a, b);
+    const cornerOk = slotCorrect(st, centers, corner.indices, geo.per);
+    const edgeOk = edge ? slotCorrect(st, centers, edge.indices, geo.per) : false;
+    const key = [centers[a], centers[b]].sort().join("-");
+    result[key] = cornerOk && edgeOk;
+  }
+  return result;
+}
+function ollDone(st, geo, color) {
+  const centers = centersOf(st, geo);
+  const C = centers.indexOf(color);
+  if (C < 0) return false;
+  const O = geo.opposite[C];
+  const base = O * geo.per;
+  for (let i = 0; i < geo.per; i++) {
+    if (st[base + i] !== centers[O]) return false;
+  }
+  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, centers, 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;
+}
+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 completionIndex(bools) {
+  const n = bools.length;
+  if (n === 0 || !bools[n - 1]) return null;
+  for (let i = 0; i < n; 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));
+  const crossIdx = completionIndex(crossBools);
+  const slotSeries = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const states = f2lSlotStates(snapshots[i], geo, color);
+    for (const [key, val] of Object.entries(states)) {
+      if (!slotSeries.has(key)) slotSeries.set(key, new Array(n).fill(false));
+      slotSeries.get(key)[i] = crossBools[i] && val;
+    }
+  }
+  const f2lSlots = [...slotSeries.entries()].map(([slot, bools]) => ({ slot, idx: completionIndex(bools) })).filter((s) => s.idx != null).sort((a, b) => a.idx - b.idx);
+  const f2lComplete = new Array(n).fill(false);
+  for (let i = 0; i < n; i++) {
+    if (!crossBools[i] || slotSeries.size < 4) continue;
+    let all = true;
+    for (const bools of slotSeries.values()) {
+      if (!bools[i]) {
+        all = false;
+        break;
+      }
+    }
+    f2lComplete[i] = all;
+  }
+  const ollIdx = completionIndex(
+    snapshots.map((st, i) => f2lComplete[i] && ollDone(st, geo, color))
+  );
+  const pllIdx = completionIndex(snapshots.map((st) => isSolvedFlat(st, geo.per)));
+  return { crossIdx, f2lSlots, ollIdx, pllIdx };
+}
+function isCFOP(build) {
+  const { crossIdx, f2lSlots, ollIdx, pllIdx } = build;
+  if (crossIdx == null || pllIdx == null || ollIdx == null) return false;
+  if (f2lSlots.length !== 4) return false;
+  if (!f2lSlots.every((s) => s.idx >= crossIdx)) return false;
+  const lastF2L = f2lSlots[3].idx;
+  return ollIdx >= lastF2L && pllIdx >= ollIdx;
+}
+function buildForRoux(snapshots, geo, sideA, upFace, mPerm) {
+  const n = snapshots.length;
+  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 };
+}
+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, _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: 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);
+  const n = seq.length;
+  const simplifiedMoves = simplifyMoves(
+    (Array.isArray(moves) ? moves : []).filter((x) => x == null ? void 0 : x.m)
+  );
+  const simplifiedCount = simplifiedMoves.length;
+  const empty = {
+    size,
+    method: "unknown",
+    solved: false,
+    total: n > 0 ? seq[n - 1].t : 0,
+    tps: 0,
+    moves: simplifiedMoves,
+    cross: null,
+    f2l: [],
+    oll: null,
+    pll: null,
+    firstBlock: null,
+    secondBlock: null,
+    cmll: null,
+    lse: null,
+    allCrosses: {},
+    unsupported
+  };
+  if (n === 0) return empty;
+  const engine = new CubeEngine("", { size });
+  const scramble = invertSequence(seq.map((x) => x.mm).filter(Boolean)).join(" ");
+  engine.applyMoves(scramble, { record: false });
+  const geo = buildGeometry(size);
+  const snapshots = new Array(n);
+  for (let i = 0; i < n; i++) {
+    if (seq[i].mm) engine.applyMoves(seq[i].mm, { record: false });
+    snapshots[i] = flattenState(engine.state());
+  }
+  const solved = isSolvedFlat(snapshots[n - 1], geo.per);
+  const pllIdxOnly = completionIndex(
+    snapshots.map((st) => isSolvedFlat(st, geo.per))
+  );
+  const milestone = (idx, prevAt2) => {
+    if (idx == null) return { record: null, at: prevAt2 };
+    const at = seq[idx].t;
+    return {
+      record: { at, duration: at - prevAt2, moveIndex: idx, move: seq[idx].m },
+      at
+    };
+  };
+  if (size !== 3) {
+    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: pll.record
+    });
+  }
+  const finalCenters = centersOf(snapshots[n - 1], geo);
+  const colors = [...new Set(finalCenters)];
+  const allCrosses = {};
+  for (const color of colors) {
+    const idx = completionIndex(
+      snapshots.map((st) => crossDone(st, geo, color))
+    );
+    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, _b2;
+    const ai = (_a2 = a.build.crossIdx) != null ? _a2 : Infinity;
+    const bi = (_b2 = b.build.crossIdx) != null ? _b2 : Infinity;
+    return ai - bi;
+  });
+  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 rouxCandidates = [];
+  for (let s = 0; s < 6; s++) {
+    for (const u of geo.neighbors[s]) {
+      rouxCandidates.push(buildForRoux(snapshots, geo, s, u, mPerm));
+    }
+  }
+  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;
+  const f2l = [];
+  for (const slot of build.f2lSlots) {
+    const m = milestone(slot.idx, prevAt);
+    if (m.record) {
+      f2l.push(__spreadValues({ slot: slot.slot }, m.record));
+      prevAt = m.at;
+    }
+  }
+  const ollM = milestone(build.ollIdx, prevAt);
+  prevAt = ollM.at;
+  const pllM = milestone(build.pllIdx, prevAt);
+  return __spreadProps(__spreadValues({}, base), {
+    cross,
+    f2l,
+    oll: ollM.record,
+    pll: pllM.record
+  });
+}
+
+// src/index.js
+var FACE_NAMES2 = ["UPPER", "LEFT", "FRONT", "RIGHT", "BACK", "DOWN"];
+var FACE_COLORS = ["W", "O", "G", "R", "B", "Y"];
+var NOOP_SIZE2 = /* @__PURE__ */ new Set(["Uw", "Dw", "Rw", "Lw", "Fw", "M", "E", "S"]);
+var MOVE_FNS = {
+  U: "rotateU",
+  D: "rotateD",
+  L: "rotateL",
+  R: "rotateR",
+  F: "rotateF",
+  B: "rotateB",
+  x: "rotateX",
+  y: "rotateY",
+  z: "rotateZ",
+  M: "rotateM",
+  E: "rotateE",
+  S: "rotateS",
+  Uw: "rotateUw",
+  Dw: "rotateDw",
+  Rw: "rotateRw",
+  Lw: "rotateLw",
+  Fw: "rotateFw"
+};
+var PERM_CACHE = /* @__PURE__ */ new Map();
+var _OracleCube = class {
+  constructor(size) {
+    this.size = size;
+    this.STATES = {};
+    for (let f = 0; f < FACE_NAMES2.length; f++) {
+      const face = [];
+      for (let r = 0; r < size; r++) {
+        const row = [];
+        for (let c = 0; c < size; c++) {
+          row.push(f * size * size + r * size + c);
+        }
+        face.push(row);
+      }
+      this.STATES[FACE_NAMES2[f]] = face;
+    }
+  }
+  // Concatenate every face row-major into a single flat array of tags.
+  flatten() {
+    const out = [];
+    for (const name of FACE_NAMES2) {
+      const face = this.STATES[name];
+      for (let r = 0; r < this.size; r++) {
+        for (let c = 0; c < this.size; c++) {
+          out.push(face[r][c]);
+        }
+      }
+    }
+    return out;
+  }
+  switchMatrix(matrix, clockwise = true) {
+    const clone = structuredClone(matrix);
+    const size = this.size;
+    let tempMatrix = [];
+    for (let i = 0; i < size; i++) {
+      tempMatrix = [...tempMatrix, ...clone[i]];
+    }
+    if (size === 2) {
+      if (clockwise) {
+        return [
+          [tempMatrix[2], tempMatrix[0]],
+          [tempMatrix[3], tempMatrix[1]]
+        ];
+      } else {
+        return [
+          [tempMatrix[1], tempMatrix[3]],
+          [tempMatrix[0], tempMatrix[2]]
+        ];
+      }
+    } else {
+      if (clockwise) {
+        return [
+          [tempMatrix[6], tempMatrix[3], tempMatrix[0]],
+          [tempMatrix[7], tempMatrix[4], tempMatrix[1]],
+          [tempMatrix[8], tempMatrix[5], tempMatrix[2]]
+        ];
+      } else {
+        return [
+          [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
+          [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
+          [tempMatrix[0], tempMatrix[3], tempMatrix[6]]
+        ];
+      }
+    }
+  }
+  specialFlip(matrix) {
+    return structuredClone(matrix).reverse().map((row) => [...row].reverse());
+  }
+  rotateU(clockwise = true) {
+    if (clockwise) {
+      this.STATES.UPPER = this.switchMatrix(this.STATES.UPPER, true);
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+      this.STATES.FRONT[0] = [...tempRight];
+      this.STATES.LEFT[0] = [...tempFront];
+      this.STATES.BACK[0] = [...tempLeft];
+      this.STATES.RIGHT[0] = [...tempBack];
+    } else {
+      this.STATES.UPPER = this.switchMatrix(this.STATES.UPPER, false);
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+      this.STATES.FRONT[0] = [...tempLeft];
+      this.STATES.LEFT[0] = [...tempBack];
+      this.STATES.BACK[0] = [...tempRight];
+      this.STATES.RIGHT[0] = [...tempFront];
+    }
+  }
+  rotateF(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+    }
+  }
+  rotateB(clockwise = true) {
+    this.rotateY(true);
+    this.rotateY(true);
+    if (clockwise) {
+      this.rotateF(true);
+    } else {
+      this.rotateF(false);
+    }
+    this.rotateY(false);
+    this.rotateY(false);
+  }
+  rotateR(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(false);
+    } else {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(false);
+    }
+  }
+  rotateL(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(true);
+    } else {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(true);
+    }
+  }
+  rotateD(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateF(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateF(false);
+      this.rotateX(false);
+    }
+  }
+  rotateDw(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateY(false);
+      this.rotateU(true);
+    } else {
+      this.rotateY(true);
+      this.rotateU(false);
+    }
+  }
+  rotateUw(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateY(true);
+      this.rotateD(true);
+    } else {
+      this.rotateY(false);
+      this.rotateD(false);
+    }
+  }
+  rotateRw(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateL(true);
+    } else {
+      this.rotateX(false);
+      this.rotateL(false);
+    }
+  }
+  rotateLw(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateX(false);
+      this.rotateR(true);
+    } else {
+      this.rotateX(true);
+      this.rotateR(false);
+    }
+  }
+  rotateM(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateLw(true);
+      this.rotateL(false);
+    } else {
+      this.rotateLw(false);
+      this.rotateL(true);
+    }
+  }
+  rotateE(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateDw(true);
+      this.rotateD(false);
+    } else {
+      this.rotateDw(false);
+      this.rotateD(true);
+    }
+  }
+  rotateFw(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateZ(true);
+      this.rotateB(true);
+    } else {
+      this.rotateZ(false);
+      this.rotateB(false);
+    }
+  }
+  rotateS(clockwise = true) {
+    if (this.size === 2) return;
+    if (clockwise) {
+      this.rotateFw(true);
+      this.rotateF(false);
+    } else {
+      this.rotateFw(false);
+      this.rotateF(true);
+    }
+  }
+  rotateX(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempDown = structuredClone(this.STATES.DOWN);
+    const tempUpper = structuredClone(this.STATES.UPPER);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    if (clockwise) {
+      this.STATES.LEFT = this.switchMatrix(tempLeft, false);
+      this.STATES.RIGHT = this.switchMatrix(tempRight, true);
+      this.STATES.FRONT = [...tempDown];
+      this.STATES.UPPER = [...tempFront];
+      this.STATES.BACK = this.specialFlip(tempUpper);
+      this.STATES.DOWN = this.specialFlip(tempBack);
+    } else {
+      this.STATES.LEFT = this.switchMatrix(tempLeft, true);
+      this.STATES.RIGHT = this.switchMatrix(tempRight, false);
+      this.STATES.FRONT = [...tempUpper];
+      this.STATES.DOWN = [...tempFront];
+      this.STATES.BACK = this.specialFlip(tempDown);
+      this.STATES.UPPER = this.specialFlip(tempBack);
+    }
+  }
+  rotateZ(clockwise = true) {
+    const tempUpper = structuredClone(this.STATES.UPPER);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    const tempDown = structuredClone(this.STATES.DOWN);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempBack = structuredClone(this.STATES.BACK);
+    if (clockwise) {
+      this.STATES.FRONT = this.switchMatrix(tempFront, true);
+      this.STATES.BACK = this.switchMatrix(tempBack, false);
+      this.STATES.RIGHT = this.switchMatrix(tempUpper, true);
+      this.STATES.DOWN = this.switchMatrix(tempRight, true);
+      this.STATES.LEFT = this.switchMatrix(tempDown, true);
+      this.STATES.UPPER = this.switchMatrix(tempLeft, true);
+    } else {
+      this.STATES.FRONT = this.switchMatrix(tempFront, false);
+      this.STATES.BACK = this.switchMatrix(tempBack, true);
+      this.STATES.RIGHT = this.switchMatrix(tempDown, false);
+      this.STATES.DOWN = this.switchMatrix(tempLeft, false);
+      this.STATES.LEFT = this.switchMatrix(tempUpper, false);
+      this.STATES.UPPER = this.switchMatrix(tempRight, false);
+    }
+  }
+  rotateY(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    if (clockwise) {
+      this.STATES.UPPER = this.switchMatrix(this.STATES.UPPER, true);
+      this.STATES.DOWN = this.switchMatrix(this.STATES.DOWN, false);
+      this.STATES.FRONT = [...tempRight];
+      this.STATES.RIGHT = [...tempBack];
+      this.STATES.LEFT = [...tempFront];
+      this.STATES.BACK = [...tempLeft];
+    } else {
+      this.STATES.UPPER = this.switchMatrix(this.STATES.UPPER, false);
+      this.STATES.DOWN = this.switchMatrix(this.STATES.DOWN, true);
+      this.STATES.FRONT = [...tempLeft];
+      this.STATES.RIGHT = [...tempFront];
+      this.STATES.LEFT = [...tempBack];
+      this.STATES.BACK = [...tempRight];
+    }
+  }
+};
+function buildPerm(size, fnName, clockwise) {
+  const oracle = new _OracleCube(size);
+  oracle[fnName](clockwise);
+  return oracle.flatten();
+}
+function getPerms(size) {
+  if (PERM_CACHE.has(size)) return PERM_CACHE.get(size);
+  const perms = {};
+  for (const key of Object.keys(MOVE_FNS)) {
+    perms[key] = {
+      cw: buildPerm(size, MOVE_FNS[key], true),
+      ccw: buildPerm(size, MOVE_FNS[key], false)
+    };
+  }
+  PERM_CACHE.set(size, perms);
+  return perms;
+}
+function getMovePermutations(size = 3) {
+  const allowedSizes = [2, 3];
+  return getPerms(allowedSizes.includes(size) ? size : 3);
+}
+var _stickers, _perms, _CubeEngine_instances, initializeState_fn, applyPerm_fn, apply_fn, faceMatrix_fn, applyMovesFromString_fn;
 var CubeEngine = class {
   constructor(initialScramble = "", options = { size: 3 }) {
     __privateAdd(this, _CubeEngine_instances);
     __publicField(this, "MOVES", []);
     __publicField(this, "size", 3);
+    __privateAdd(this, _stickers, []);
+    __privateAdd(this, _perms, null);
     const allowedSizes = [2, 3];
     this.size = allowedSizes.includes(options.size) ? options.size : 3;
+    __privateSet(this, _perms, getPerms(this.size));
     __privateMethod(this, _CubeEngine_instances, initializeState_fn).call(this);
     if (typeof initialScramble === "string" && initialScramble.trim().length > 0) {
       __privateMethod(this, _CubeEngine_instances, applyMovesFromString_fn).call(this, initialScramble, false);
@@ -63,195 +906,131 @@ var CubeEngine = class {
    * Rotates the (UPPER) layer clockwise or counterclockwise.
    */
   rotateU(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true);
-      this.MOVES.push("U");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false);
-      this.MOVES.push("U'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "U", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (FRONT) layer clockwise or counterclockwise.
    */
   rotateF(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true);
-      this.MOVES.push("F");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false);
-      this.MOVES.push("F'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "F", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (BACK) layer clockwise or counterclockwise.
    */
   rotateB(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true);
-      this.MOVES.push("B");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false);
-      this.MOVES.push("B'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "B", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (RIGHT) layer clockwise or counterclockwise.
    */
   rotateR(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, true);
-      this.MOVES.push("R");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, false);
-      this.MOVES.push("R'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "R", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (LEFT) layer clockwise or counterclockwise.
    */
   rotateL(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true);
-      this.MOVES.push("L");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false);
-      this.MOVES.push("L'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "L", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (DOWN) layer clockwise or counterclockwise.
    */
   rotateD(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, true);
-      this.MOVES.push("D");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, false);
-      this.MOVES.push("D'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "D", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the wide (DOWN two layers) clockwise or counterclockwise.
    */
   rotateDw(clockwise = true) {
-    if (this.size === 2) return;
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, true);
-      this.MOVES.push("Dw");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, false);
-      this.MOVES.push("Dw'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "Dw", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the wide (UPPER two layers) clockwise or counterclockwise.
    */
   rotateUw(clockwise = true) {
-    if (this.size === 2) return;
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, true);
-      this.MOVES.push("Uw");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, false);
-      this.MOVES.push("Uw'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "Uw", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the wide (RIGHT two layers) clockwise or counterclockwise.
    */
   rotateRw(clockwise = true) {
-    if (this.size === 2) return;
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, true);
-      this.MOVES.push("Rw");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, false);
-      this.MOVES.push("Rw'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "Rw", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the wide (LEFT two layers) clockwise or counterclockwise.
    */
   rotateLw(clockwise = true) {
-    if (this.size === 2) return;
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true);
-      this.MOVES.push("Lw");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false);
-      this.MOVES.push("Lw'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "Lw", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the middle slice (M) parallel to L/R. Clockwise corresponds to Lw followed by L'.
    */
   rotateM(clockwise = true) {
-    if (this.size === 2) return;
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, true);
-      this.MOVES.push("M");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, false);
-      this.MOVES.push("M'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "M", clockwise ? "cw" : "ccw", true);
+  }
+  /**
+   * Rotates the equatorial slice (E) parallel to U/D. Clockwise follows the D direction (E = Dw D').
+   */
+  rotateE(clockwise = true) {
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "E", clockwise ? "cw" : "ccw", true);
+  }
+  /**
+   * Rotates the wide (FRONT two layers) clockwise or counterclockwise. Equivalent to z B.
+   */
+  rotateFw(clockwise = true) {
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "Fw", clockwise ? "cw" : "ccw", true);
+  }
+  /**
+   * Rotates the standing slice (S) parallel to F/B. Clockwise follows the F direction (S = Fw F').
+   */
+  rotateS(clockwise = true) {
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "S", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (x) axis clockwise or counterclockwise.
    */
   rotateX(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-      this.MOVES.push("x");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-      this.MOVES.push("x'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "x", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (z) axis clockwise or counterclockwise.
    */
   rotateZ(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, true);
-      this.MOVES.push("z");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, false);
-      this.MOVES.push("z'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "z", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Rotates the (y) axis clockwise or counterclockwise.
    */
   rotateY(clockwise = true) {
-    if (clockwise) {
-      __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-      this.MOVES.push("y");
-    } else {
-      __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-      this.MOVES.push("y'");
-    }
+    __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, "y", clockwise ? "cw" : "ccw", true);
   }
   /**
    * Logs the current state of the cube.
    */
   state() {
-    return __spreadValues({}, this.STATES);
+    return {
+      UPPER: __privateMethod(this, _CubeEngine_instances, faceMatrix_fn).call(this, 0),
+      LEFT: __privateMethod(this, _CubeEngine_instances, faceMatrix_fn).call(this, 1),
+      FRONT: __privateMethod(this, _CubeEngine_instances, faceMatrix_fn).call(this, 2),
+      RIGHT: __privateMethod(this, _CubeEngine_instances, faceMatrix_fn).call(this, 3),
+      BACK: __privateMethod(this, _CubeEngine_instances, faceMatrix_fn).call(this, 4),
+      DOWN: __privateMethod(this, _CubeEngine_instances, faceMatrix_fn).call(this, 5)
+    };
   }
   /**
    * Indicates if the cube is solve or not in all layers.
    */
   isSolved() {
-    const temp = __spreadValues({}, this.STATES);
-    const layersSolved = Object.keys(temp).map((layer) => {
-      let mixedMatrix = [];
-      for (let i = 0; i < this.size; i++) {
-        mixedMatrix = [...mixedMatrix, ...temp[layer][i]];
+    const per = this.size * this.size;
+    const centerOffset = this.size === 2 ? 0 : 4;
+    for (let f = 0; f < FACE_COLORS.length; f++) {
+      const base = f * per;
+      const centerColor = __privateGet(this, _stickers)[base + centerOffset];
+      for (let i = 0; i < per; i++) {
+        if (__privateGet(this, _stickers)[base + i] !== centerColor) return false;
       }
-      const centerColor = this.size === 2 ? mixedMatrix[0] : mixedMatrix[4];
-      return mixedMatrix.every((currentColor) => currentColor === centerColor);
-    });
-    return layersSolved.every((isLayerSolved) => isLayerSolved);
+    }
+    return true;
   }
   /**
    * Returns the history of all movements made.
@@ -271,8 +1050,8 @@ var CubeEngine = class {
   }
   /**
    * Applies a sequence of moves provided as a string.
-   * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
-   * @param {string} sequence - e.g. "R U' F R2 D Dw Uw Rw Rw' Lw Lw2 M M' M2"
+   * Supports: U, D, L, R, F, B, x, y, z; slice moves: M, E, S; and wide moves: Dw, Uw, Rw, Lw, Fw with optional ' for counterclockwise and 2 for double turns.
+   * @param {string} sequence - e.g. "R U' F R2 D Dw Uw Rw Rw' Lw Lw2 M M' M2 E E' S S2 Fw"
    * @param {object} options - { record: boolean } whether to record moves in history (default true)
    */
   applyMoves(sequence, options = { record: false }) {
@@ -280,269 +1059,51 @@ var CubeEngine = class {
     __privateMethod(this, _CubeEngine_instances, applyMovesFromString_fn).call(this, sequence, record);
   }
 };
+_stickers = new WeakMap();
+_perms = new WeakMap();
 _CubeEngine_instances = new WeakSet();
 initializeState_fn = function() {
-  this.STATES = {
-    UPPER: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "W"),
-    LEFT: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "O"),
-    FRONT: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "G"),
-    RIGHT: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "R"),
-    BACK: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "B"),
-    DOWN: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "Y")
-  };
-};
-// Create a face matrix based on cube size
-createFace_fn = function(color) {
-  const face = [];
-  for (let i = 0; i < this.size; i++) {
-    const row = [];
-    for (let j = 0; j < this.size; j++) {
-      row.push(color);
+  const per = this.size * this.size;
+  const stickers = new Array(FACE_COLORS.length * per);
+  for (let f = 0; f < FACE_COLORS.length; f++) {
+    const color = FACE_COLORS[f];
+    const base = f * per;
+    for (let i = 0; i < per; i++) {
+      stickers[base + i] = color;
     }
-    face.push(row);
   }
-  return face;
+  __privateSet(this, _stickers, stickers);
 };
-rotateU_fn = function(clockwise = true) {
-  if (clockwise) {
-    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, true);
-    const tempFront = [...this.STATES.FRONT[0]];
-    const tempRight = [...this.STATES.RIGHT[0]];
-    const tempLeft = [...this.STATES.LEFT[0]];
-    const tempBack = [...this.STATES.BACK[0]];
-    this.STATES.FRONT[0] = [...tempRight];
-    this.STATES.LEFT[0] = [...tempFront];
-    this.STATES.BACK[0] = [...tempLeft];
-    this.STATES.RIGHT[0] = [...tempBack];
-  } else {
-    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, false);
-    const tempFront = [...this.STATES.FRONT[0]];
-    const tempRight = [...this.STATES.RIGHT[0]];
-    const tempLeft = [...this.STATES.LEFT[0]];
-    const tempBack = [...this.STATES.BACK[0]];
-    this.STATES.FRONT[0] = [...tempLeft];
-    this.STATES.LEFT[0] = [...tempBack];
-    this.STATES.BACK[0] = [...tempRight];
-    this.STATES.RIGHT[0] = [...tempFront];
+// Apply a precomputed permutation: newState[i] = oldState[perm[i]].
+applyPerm_fn = function(perm) {
+  const current = __privateGet(this, _stickers);
+  const next = new Array(current.length);
+  for (let i = 0; i < current.length; i++) {
+    next[i] = current[perm[i]];
   }
+  __privateSet(this, _stickers, next);
 };
-rotateF_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-  }
-};
-rotateB_fn = function(clockwise = true) {
-  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false);
-  }
-  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-};
-rotateR_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-  }
-};
-rotateL_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-  }
-};
-rotateD_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-  }
-};
-rotateDw_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false);
-  }
-};
-rotateUw_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, true);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, false);
-  }
+// Core move dispatch. dir is "cw" or "ccw"; record controls history logging.
+apply_fn = function(key, dir, record) {
+  if (this.size === 2 && NOOP_SIZE2.has(key)) return;
+  __privateMethod(this, _CubeEngine_instances, applyPerm_fn).call(this, __privateGet(this, _perms)[key][dir]);
+  if (record) this.MOVES.push(dir === "ccw" ? key + "'" : key);
 };
-rotateRw_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false);
-  }
-};
-rotateLw_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, true);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, false);
-  }
-};
-rotateM_fn = function(clockwise = true) {
-  if (clockwise) {
-    __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true);
-    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false);
-  } else {
-    __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false);
-    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true);
-  }
-};
-rotateX_fn = function(clockwise = true) {
-  const tempFront = structuredClone(this.STATES.FRONT);
-  const tempDown = structuredClone(this.STATES.DOWN);
-  const tempUpper = structuredClone(this.STATES.UPPER);
-  const tempBack = structuredClone(this.STATES.BACK);
-  const tempLeft = structuredClone(this.STATES.LEFT);
-  const tempRight = structuredClone(this.STATES.RIGHT);
-  if (clockwise) {
-    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, false);
-    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, true);
-    this.STATES.FRONT = [...tempDown];
-    this.STATES.UPPER = [...tempFront];
-    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempUpper);
-    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
-  } else {
-    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, true);
-    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, false);
-    this.STATES.FRONT = [...tempUpper];
-    this.STATES.DOWN = [...tempFront];
-    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempDown);
-    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
-  }
-};
-rotateZ_fn = function(clockwise = true) {
-  const tempUpper = structuredClone(this.STATES.UPPER);
-  const tempRight = structuredClone(this.STATES.RIGHT);
-  const tempDown = structuredClone(this.STATES.DOWN);
-  const tempLeft = structuredClone(this.STATES.LEFT);
-  const tempFront = structuredClone(this.STATES.FRONT);
-  const tempBack = structuredClone(this.STATES.BACK);
-  if (clockwise) {
-    this.STATES.FRONT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempFront, true);
-    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempBack, false);
-    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempUpper, true);
-    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, true);
-    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempDown, true);
-    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, true);
-  } else {
-    this.STATES.FRONT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempFront, false);
-    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempBack, true);
-    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempDown, false);
-    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, false);
-    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempUpper, false);
-    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, false);
-  }
-};
-rotateY_fn = function(clockwise = true) {
-  const tempFront = structuredClone(this.STATES.FRONT);
-  const tempRight = structuredClone(this.STATES.RIGHT);
-  const tempBack = structuredClone(this.STATES.BACK);
-  const tempLeft = structuredClone(this.STATES.LEFT);
-  if (clockwise) {
-    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, true);
-    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.DOWN, false);
-    this.STATES.FRONT = [...tempRight];
-    this.STATES.RIGHT = [...tempBack];
-    this.STATES.LEFT = [...tempFront];
-    this.STATES.BACK = [...tempLeft];
-  } else {
-    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, false);
-    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.DOWN, true);
-    this.STATES.FRONT = [...tempLeft];
-    this.STATES.RIGHT = [...tempFront];
-    this.STATES.LEFT = [...tempBack];
-    this.STATES.BACK = [...tempRight];
-  }
-};
-/**
- * Rotate the entire face in the direction set
- */
-switchMatrix_fn = function(matrix, clockwise = true) {
-  const clone = structuredClone(matrix);
+// Build a single face matrix from the flat sticker array.
+faceMatrix_fn = function(faceIndex) {
   const size = this.size;
-  let tempMatrix = [];
-  for (let i = 0; i < size; i++) {
-    tempMatrix = [...tempMatrix, ...clone[i]];
-  }
-  if (size === 2) {
-    if (clockwise) {
-      return [
-        [tempMatrix[2], tempMatrix[0]],
-        [tempMatrix[3], tempMatrix[1]]
-      ];
-    } else {
-      return [
-        [tempMatrix[1], tempMatrix[3]],
-        [tempMatrix[0], tempMatrix[2]]
-      ];
-    }
-  } else {
-    if (clockwise) {
-      return [
-        [tempMatrix[6], tempMatrix[3], tempMatrix[0]],
-        [tempMatrix[7], tempMatrix[4], tempMatrix[1]],
-        [tempMatrix[8], tempMatrix[5], tempMatrix[2]]
-      ];
-    } else {
-      return [
-        [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
-        [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
-        [tempMatrix[0], tempMatrix[3], tempMatrix[6]]
-      ];
+  const base = faceIndex * size * size;
+  const matrix = [];
+  for (let r = 0; r < size; r++) {
+    const row = [];
+    for (let c = 0; c < size; c++) {
+      row.push(__privateGet(this, _stickers)[base + r * size + c]);
     }
+    matrix.push(row);
   }
+  return matrix;
 };
-specialFlip_fn = function(matrix) {
-  return structuredClone(matrix).reverse().map((row) => [...row].reverse());
-};
-// Internal: parses and applies moves. If record=false, uses private methods to avoid logging.
+// Internal: parses and applies moves, optionally recording them in history.
 applyMovesFromString_fn = function(sequence, record = true) {
   if (typeof sequence !== "string") return;
   const tokens = sequence.split(/\s+/).map((t) => t.trim()).filter((t) => t.length > 0);
@@ -551,121 +1112,55 @@ applyMovesFromString_fn = function(sequence, record = true) {
     const rest = token.slice(1);
     const isDouble = rest.includes("2");
     const isPrime = rest.includes("'");
-    const exec = (fnClockwise, fnCounter) => {
-      if (isDouble) {
-        fnClockwise();
-        fnClockwise();
-      } else {
-        if (isPrime) {
-          fnCounter();
-        } else {
-          fnClockwise();
-        }
-      }
-    };
+    const isWide = /w/i.test(rest);
+    let key;
     switch (base) {
       case "U":
-        {
-          const isWide = /w/i.test(rest);
-          if (isWide) {
-            exec(
-              () => record ? this.rotateUw(true) : __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, true),
-              () => record ? this.rotateUw(false) : __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, false)
-            );
-          } else {
-            exec(
-              () => record ? this.rotateU(true) : __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true),
-              () => record ? this.rotateU(false) : __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false)
-            );
-          }
-        }
+        key = isWide ? "Uw" : "U";
         break;
       case "D":
-        {
-          const isWide = /w/i.test(rest);
-          if (isWide) {
-            exec(
-              () => record ? this.rotateDw(true) : __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, true),
-              () => record ? this.rotateDw(false) : __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, false)
-            );
-          } else {
-            exec(
-              () => record ? this.rotateD(true) : __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, true),
-              () => record ? this.rotateD(false) : __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, false)
-            );
-          }
-        }
+        key = isWide ? "Dw" : "D";
         break;
       case "L":
-        {
-          const isWide = /w/i.test(rest);
-          if (isWide) {
-            exec(
-              () => record ? this.rotateLw(true) : __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true),
-              () => record ? this.rotateLw(false) : __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false)
-            );
-          } else {
-            exec(
-              () => record ? this.rotateL(true) : __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true),
-              () => record ? this.rotateL(false) : __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false)
-            );
-          }
-        }
+        key = isWide ? "Lw" : "L";
         break;
       case "R":
-        {
-          const isWide = /w/i.test(rest);
-          if (isWide) {
-            exec(
-              () => record ? this.rotateRw(true) : __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, true),
-              () => record ? this.rotateRw(false) : __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, false)
-            );
-          } else {
-            exec(
-              () => record ? this.rotateR(true) : __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, true),
-              () => record ? this.rotateR(false) : __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, false)
-            );
-          }
-        }
+        key = isWide ? "Rw" : "R";
         break;
       case "F":
-        exec(
-          () => record ? this.rotateF(true) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true),
-          () => record ? this.rotateF(false) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false)
-        );
+        key = isWide ? "Fw" : "F";
         break;
       case "B":
-        exec(
-          () => record ? this.rotateB(true) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true),
-          () => record ? this.rotateB(false) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false)
-        );
+        key = "B";
         break;
       case "x":
-        exec(
-          () => record ? this.rotateX(true) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true),
-          () => record ? this.rotateX(false) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false)
-        );
+        key = "x";
         break;
       case "y":
-        exec(
-          () => record ? this.rotateY(true) : __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true),
-          () => record ? this.rotateY(false) : __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false)
-        );
+        key = "y";
         break;
       case "z":
-        exec(
-          () => record ? this.rotateZ(true) : __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, true),
-          () => record ? this.rotateZ(false) : __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, false)
-        );
+        key = "z";
         break;
       case "M":
-        exec(
-          () => record ? this.rotateM(true) : __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, true),
-          () => record ? this.rotateM(false) : __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, false)
-        );
+        key = "M";
         break;
-      default:
+      case "E":
+        key = "E";
         break;
+      case "S":
+        key = "S";
+        break;
+      default:
+        continue;
+    }
+    if (isDouble) {
+      __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, key, "cw", record);
+      __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, key, "cw", record);
+    } else if (isPrime) {
+      __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, key, "ccw", record);
+    } else {
+      __privateMethod(this, _CubeEngine_instances, apply_fn).call(this, key, "cw", record);
     }
   }
 };
@@ -680,5 +1175,9 @@ var COLOR = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   COLOR,
-  CubeEngine
+  CubeEngine,
+  analyzeSolution,
+  getMovePermutations,
+  invertSequence,
+  simplifyMoves
 });