@cubingcenter/scrambler 0.6.3 → 0.7.0

package/dist-cjs/puzzles/cube3/solver/phase2.js

@@ -13,6 +13,7 @@ const phase1_js_1 = require("./phase1.js");
 const tables_js_1 = require("./tables.js");
 const search_utils_js_1 = require("./search-utils.js");
 const pair_tables_js_1 = require("./pair-tables.js");
+const symmetry_js_1 = require("./symmetry.js");
 class Cube3Phase2SearchError extends Error {
     visitedNodes;
     constructor(message, visitedNodes) {
@@ -50,17 +51,11 @@ async function solveCube3Phase2(state, options = {}) {
         throw new Cube3Phase2SearchError("3x3 Phase 2 requires a state already in G1.", 0);
     }
     const tables = options.tables ?? await (0, tables_js_1.loadCube3Phase2Tables)();
-    const pairTables = options.pairTables ?? await (0, pair_tables_js_1.loadCube3PairTables)();
+    const pairTables = options.pairTables ?? (options.skipPairTables ? undefined : await (0, pair_tables_js_1.loadCube3PairTables)());
     const maxDepth = options.maxDepth ?? 18;
     const start = encodeCube3Phase2Coordinates(state);
     const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
-    const context = {
-        tables,
-        pairTables,
-        deadline,
-        visitedNodes: 0,
-        timedOut: false
-    };
+    const context = createPhase2SearchContext(tables, pairTables, maxDepth, deadline);
     const spRange = tables.moveTables.slicePermutation.range;
     const cpspTable = tables.pruningTables.cornerPermutationSlicePermutation.values;
     const epspTable = tables.pruningTables.udEdgePermutationSlicePermutation.values;
@@ -98,6 +93,11 @@ async function solveCube3Phase2(state, options = {}) {
     throw new Cube3Phase2SearchError(`3x3 Phase 2 solution not found within depth ${maxDepth}.`, context.visitedNodes);
 }
 async function solveCube3State(state, options = {}) {
+    const quality = options.quality ?? "short";
+    const orientations = options.orientations ?? (quality === "best" ? 3 : 1);
+    if (orientations >= 3) {
+        return solveCube3TripleOrientation(state, { ...options, orientations });
+    }
     const phase1 = await (0, phase1_js_1.solveCube3Phase1)(state, options.phase1);
     let previousFace = -1;
     let previousPreviousFace = -1;
@@ -116,6 +116,127 @@ async function solveCube3State(state, options = {}) {
     };
     const phase2 = await solveCube3Phase2(phase1.state, phase2Options);
     const moves = [...phase1.moves, ...phase2.moves];
+    const targetLength = options.targetLength;
+    const extraDepth = options.phase1ExtraDepth ?? (quality === "fast" ? 0 : 1);
+    const solutionLimit = options.phase1SolutionLimit ?? (targetLength !== undefined ? 32 : 8);
+    const improveDepths = targetLength !== undefined ? Math.max(4, extraDepth) : extraDepth;
+    const needsTarget = targetLength !== undefined && moves.length > targetLength;
+    if (needsTarget || (targetLength === undefined && extraDepth > 0)) {
+        const p1Tables = options.phase1?.tables ?? await (0, tables_js_1.loadCube3Phase1Tables)();
+        const p2Tables = options.phase2?.tables ?? await (0, tables_js_1.loadCube3Phase2Tables)();
+        const scoredPairTables = options.phase2?.pairTables ??
+            (options.phase2?.skipPairTables ? undefined : await (0, pair_tables_js_1.loadCube3PairTables)());
+        const deadline = performance.now() + (options.timeoutMs ?? 800);
+        const p2SpRange = p2Tables.moveTables.slicePermutation.range;
+        const p2cpsp = p2Tables.pruningTables.cornerPermutationSlicePermutation.values;
+        const p2uepsp = p2Tables.pruningTables.udEdgePermutationSlicePermutation.values;
+        const seenG1 = new Set();
+        let bestP1 = phase1;
+        let bestP2 = phase2;
+        let bestMoves = moves;
+        let improvementNodes = 0;
+        const minDepth = phase1.depth;
+        const scored = [];
+        for (let d = minDepth; d <= minDepth + improveDepths && d < bestMoves.length; d++) {
+            if (performance.now() > deadline)
+                break;
+            const { solutions: p1Solutions, visitedNodes } = await (0, phase1_js_1.collectCube3Phase1Solutions)(state, d, {
+                tables: p1Tables,
+                limit: solutionLimit,
+                timeoutMs: Math.max(1, deadline - performance.now())
+            });
+            improvementNodes += visitedNodes;
+            if (performance.now() > deadline)
+                break;
+            for (const p1Moves of p1Solutions) {
+                if (performance.now() > deadline)
+                    break;
+                if (p1Moves.length >= bestMoves.length)
+                    continue;
+                // Skip the phase-1 solution the initial search already completed.
+                if (p1Moves.length === phase1.moves.length &&
+                    p1Moves.every((move, index) => move === phase1.moves[index])) {
+                    continue;
+                }
+                const s1 = (0, moves_js_1.applyCube3Algorithm)(state, p1Moves);
+                const coords = encodeCube3Phase2Coordinates(s1);
+                const estKey = `${coords.cornerPermutation},${coords.udEdgePermutation},${coords.slicePermutation}`;
+                if (seenG1.has(estKey))
+                    continue;
+                seenG1.add(estKey);
+                const cpIndex = coords.cornerPermutation * p2SpRange + coords.slicePermutation;
+                const epIndex = coords.udEdgePermutation * p2SpRange + coords.slicePermutation;
+                const cpDist = (p2cpsp[cpIndex >> 1] >> ((cpIndex & 1) << 2)) & 0x0f;
+                const epDist = (p2uepsp[epIndex >> 1] >> ((epIndex & 1) << 2)) & 0x0f;
+                let est = p1Moves.length + (cpDist > epDist ? cpDist : epDist);
+                if (scoredPairTables !== undefined) {
+                    const pair = (0, pair_tables_js_1.pairBound)(scoredPairTables, coords.cornerPermutation, coords.udEdgePermutation);
+                    const pairEst = p1Moves.length + pair;
+                    if (pairEst > est)
+                        est = pairEst;
+                }
+                // A lower bound at or above the best total can never strictly improve it.
+                if (est >= bestMoves.length)
+                    continue;
+                const pFace = p1Moves.length > 0 ? (0, search_utils_js_1.getMoveFace)(p1Moves[p1Moves.length - 1]) : -1;
+                const ppFace = p1Moves.length > 1 ? (0, search_utils_js_1.getMoveFace)(p1Moves[p1Moves.length - 2]) : -1;
+                scored.push({ moves: p1Moves, state: s1, est, pFace, ppFace });
+            }
+        }
+        // Sort ALL candidates globally across depths by admissible total lower bound
+        scored.sort((left, right) => left.est - right.est);
+        for (const cand of scored) {
+            if (performance.now() > deadline)
+                break;
+            // Prune: since candidates are sorted by est, no subsequent candidate can beat bestMoves.length
+            if (cand.est >= bestMoves.length)
+                break;
+            const maxP2 = Math.min(bestMoves.length - cand.moves.length - 1, 15);
+            if (maxP2 <= 0)
+                continue;
+            try {
+                const remainingBudget = Math.max(1, deadline - performance.now());
+                const attemptTimeout = options.improvePhase2TimeoutMs ??
+                    options.phase2?.timeoutMs ?? 25;
+                const candP2 = await solveCube3Phase2(cand.state, {
+                    ...options.phase2,
+                    pairTables: scoredPairTables,
+                    tables: p2Tables,
+                    maxDepth: maxP2,
+                    previousFace: cand.pFace,
+                    previousPreviousFace: cand.ppFace,
+                    timeoutMs: Math.min(attemptTimeout, remainingBudget)
+                });
+                improvementNodes += candP2.visitedNodes;
+                const candTotal = cand.moves.length + candP2.moves.length;
+                if (candTotal < bestMoves.length) {
+                    bestMoves = [...cand.moves, ...candP2.moves];
+                    bestP1 = {
+                        moves: cand.moves,
+                        depth: cand.moves.length,
+                        state: cand.state,
+                        coordinates: (0, phase1_js_1.encodeCube3Phase1Coordinates)(cand.state),
+                        visitedNodes: 0
+                    };
+                    bestP2 = candP2;
+                    if (targetLength !== undefined && bestMoves.length <= targetLength) {
+                        break;
+                    }
+                }
+            }
+            catch {
+                // continue
+            }
+        }
+        return {
+            phase1: bestP1,
+            phase2: bestP2,
+            moves: bestMoves,
+            depth: bestMoves.length,
+            state: bestP2.state,
+            visitedNodes: phase1.visitedNodes + phase2.visitedNodes + improvementNodes
+        };
+    }
     return {
         phase1,
         phase2,
@@ -125,6 +246,39 @@ async function solveCube3State(state, options = {}) {
         visitedNodes: phase1.visitedNodes + phase2.visitedNodes
     };
 }
+/**
+ * Best-of-N-orientations solve: UD plus rotated copies, mapped back with
+ * the inverse rotation. Rotating a solution conjugates the whole picture,
+ * so the mapped-back moves solve the original state with their length
+ * preserved. Deterministic: ties keep the earliest orientation (UD first).
+ */
+async function solveCube3TripleOrientation(state, options) {
+    const count = Math.min(Math.max(options.orientations ?? 1, 1), symmetry_js_1.CUBE3_ORIENTATIONS_24.length);
+    const singleOptions = { ...options, orientations: 1 };
+    let best = await solveCube3State(state, singleOptions);
+    let visitedNodes = best.visitedNodes;
+    const scramble = (0, moves_js_1.invertCube3Algorithm)(best.moves);
+    const sequences = symmetry_js_1.CUBE3_ORIENTATIONS_24.slice(1, count);
+    for (const sequence of sequences) {
+        try {
+            const rotatedState = (0, moves_js_1.applyCube3Algorithm)((0, state_js_1.createSolvedCube3State)(), (0, symmetry_js_1.rotateCube3AlgorithmBySequence)(scramble, sequence));
+            const candidate = await solveCube3State(rotatedState, singleOptions);
+            visitedNodes += candidate.visitedNodes;
+            if (candidate.moves.length < best.moves.length) {
+                best = {
+                    ...candidate,
+                    moves: (0, symmetry_js_1.rotateCube3AlgorithmBySequence)(candidate.moves, (0, symmetry_js_1.invertCube3RotationSequence)(sequence)),
+                    depth: candidate.moves.length,
+                    visitedNodes
+                };
+            }
+        }
+        catch {
+            // A flaky orientation must never fail the whole solve.
+        }
+    }
+    return { ...best, visitedNodes };
+}
 function encodeCube3Phase2Coordinates(state) {
     return {
         cornerPermutation: encodeCornerPermutationForPhase2(state),
@@ -147,6 +301,23 @@ const PHASE2_MOVE_FACES = tables_js_1.CUBE3_PHASE2_MOVES.map((move) => {
     const char = move[0];
     return char === "U" ? 0 : char === "D" ? 1 : char === "R" ? 2 : char === "L" ? 3 : char === "F" ? 4 : 5;
 });
+function createPhase2SearchContext(tables, pairTables, maxDepth, deadline) {
+    const scratchLevels = maxDepth + 1;
+    const scratchSize = scratchLevels * tables_js_1.CUBE3_PHASE2_MOVES.length;
+    return {
+        tables,
+        pairTables,
+        maxDepth,
+        deadline,
+        visitedNodes: 0,
+        timedOut: false,
+        scratchMove: new Int32Array(scratchSize),
+        scratchBound: new Int32Array(scratchSize),
+        scratchCp: new Int32Array(scratchSize),
+        scratchUep: new Int32Array(scratchSize),
+        scratchSp: new Int32Array(scratchSize)
+    };
+}
 function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, previousFace, previousPreviousFace, remainingDepth, path, context) {
     context.visitedNodes += 1;
     if (context.deadline !== undefined && (context.visitedNodes & 1023) === 0 && performance.now() > context.deadline) {
@@ -166,41 +337,23 @@ function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, pr
     const spRange = context.tables.moveTables.slicePermutation.range;
     const cpspTable = context.tables.pruningTables.cornerPermutationSlicePermutation.values;
     const epspTable = context.tables.pruningTables.udEdgePermutationSlicePermutation.values;
+    const pairTables = context.pairTables;
     const cpOffset = cornerPermutation * moveCount;
     const epOffset = udEdgePermutation * moveCount;
     const spOffset = slicePermutation * moveCount;
-    // Without the pair tables (the default npm package), keep the exact
-    // reference traversal — zero overhead. With them (turbo tier), collect the
-    // children with the pair-distance bound and explore in ascending bound
-    // order (stable: ties keep the reference move order): same depth-minimal
-    // solutions, far fewer nodes.
-    if (context.pairTables === undefined) {
-        for (let i = 0; i < validMoves.length; i += 1) {
-            const moveIndex = validMoves[i];
-            const nextCornerPermutation = cpTable[cpOffset + moveIndex];
-            const nextUdEdgePermutation = epTable[epOffset + moveIndex];
-            const nextSlicePermutation = spTable[spOffset + moveIndex];
-            const combinedCPIndex = nextCornerPermutation * spRange + nextSlicePermutation;
-            const combinedEPIndex = nextUdEdgePermutation * spRange + nextSlicePermutation;
-            const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
-            const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
-            const nextLowerBound = cpDist > epDist ? cpDist : epDist;
-            if (nextLowerBound > remainingDepth - 1) {
-                continue;
-            }
-            path.push(context.tables.phase2Moves[moveIndex]);
-            if (searchPhase2(nextCornerPermutation, nextUdEdgePermutation, nextSlicePermutation, PHASE2_MOVE_FACES[moveIndex], previousFace, remainingDepth - 1, path, context)) {
-                return true;
-            }
-            path.pop();
-            if (context.timedOut) {
-                return false;
-            }
-        }
-        return false;
-    }
-    const pairTables = context.pairTables;
-    const children = [];
+    // Collect the surviving children with the pair-tightened lower bound and
+    // explore them in ascending bound order (stable: ties keep the reference
+    // move order). Without the pair tables this reduces to ordering by
+    // max(cpsp, uepsp) — same depth-minimal solutions, far fewer nodes than
+    // the reference traversal. With them, same set and order as before but
+    // without per-node allocation.
+    const slot = remainingDepth * moveCount;
+    const scratchMove = context.scratchMove;
+    const scratchBound = context.scratchBound;
+    const scratchCp = context.scratchCp;
+    const scratchUep = context.scratchUep;
+    const scratchSp = context.scratchSp;
+    let childCount = 0;
     for (let i = 0; i < validMoves.length; i += 1) {
         const moveIndex = validMoves[i];
         const nextCornerPermutation = cpTable[cpOffset + moveIndex];
@@ -214,25 +367,48 @@ function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, pr
         if (nextLowerBound > remainingDepth - 1) {
             continue;
         }
-        const pair = (0, pair_tables_js_1.pairBound)(pairTables, nextCornerPermutation, nextUdEdgePermutation);
-        if (pair > nextLowerBound) {
-            nextLowerBound = pair;
+        if (pairTables !== undefined) {
+            const pair = (0, pair_tables_js_1.pairBound)(pairTables, nextCornerPermutation, nextUdEdgePermutation);
+            if (pair > nextLowerBound) {
+                nextLowerBound = pair;
+            }
+            if (nextLowerBound > remainingDepth - 1) {
+                continue;
+            }
         }
-        if (nextLowerBound > remainingDepth - 1) {
-            continue;
+        scratchMove[slot + childCount] = moveIndex;
+        scratchBound[slot + childCount] = nextLowerBound;
+        scratchCp[slot + childCount] = nextCornerPermutation;
+        scratchUep[slot + childCount] = nextUdEdgePermutation;
+        scratchSp[slot + childCount] = nextSlicePermutation;
+        childCount += 1;
+    }
+    // Stable insertion sort by bound (n <= 10; ties keep reference order).
+    for (let i = 1; i < childCount; i += 1) {
+        const move = scratchMove[slot + i];
+        const bound = scratchBound[slot + i];
+        const cp = scratchCp[slot + i];
+        const uep = scratchUep[slot + i];
+        const sp = scratchSp[slot + i];
+        let j = i - 1;
+        while (j >= 0 && scratchBound[slot + j] > bound) {
+            scratchMove[slot + j + 1] = scratchMove[slot + j];
+            scratchBound[slot + j + 1] = scratchBound[slot + j];
+            scratchCp[slot + j + 1] = scratchCp[slot + j];
+            scratchUep[slot + j + 1] = scratchUep[slot + j];
+            scratchSp[slot + j + 1] = scratchSp[slot + j];
+            j -= 1;
         }
-        children.push({
-            moveIndex,
-            lowerBound: nextLowerBound,
-            cornerPermutation: nextCornerPermutation,
-            udEdgePermutation: nextUdEdgePermutation,
-            slicePermutation: nextSlicePermutation
-        });
+        scratchMove[slot + j + 1] = move;
+        scratchBound[slot + j + 1] = bound;
+        scratchCp[slot + j + 1] = cp;
+        scratchUep[slot + j + 1] = uep;
+        scratchSp[slot + j + 1] = sp;
     }
-    children.sort((left, right) => left.lowerBound - right.lowerBound);
-    for (const child of children) {
-        path.push(context.tables.phase2Moves[child.moveIndex]);
-        if (searchPhase2(child.cornerPermutation, child.udEdgePermutation, child.slicePermutation, PHASE2_MOVE_FACES[child.moveIndex], previousFace, remainingDepth - 1, path, context)) {
+    for (let i = 0; i < childCount; i += 1) {
+        const moveIndex = scratchMove[slot + i];
+        path.push(context.tables.phase2Moves[moveIndex]);
+        if (searchPhase2(scratchCp[slot + i], scratchUep[slot + i], scratchSp[slot + i], PHASE2_MOVE_FACES[moveIndex], previousFace, remainingDepth - 1, path, context)) {
             return true;
         }
         path.pop();
@@ -281,13 +457,7 @@ function searchPhase1Interleaved(cornerOrientation, edgeOrientation, udSlice, pr
         const g1State = applyCube3Phase2Moves(context.originalState, path);
         const start2 = encodeCube3Phase2Coordinates(g1State);
         const maxPhase2Depth = 6;
-        const phase2Context = {
-            tables: context.phase2Tables,
-            pairTables: undefined,
-            deadline: context.deadline,
-            visitedNodes: 0,
-            timedOut: false
-        };
+        const phase2Context = createPhase2SearchContext(context.phase2Tables, undefined, maxPhase2Depth, context.deadline);
         for (let d2 = 0; d2 <= maxPhase2Depth; d2 += 1) {
             const path2 = [];
             const solved2 = searchPhase2(start2.cornerPermutation, start2.udEdgePermutation, start2.slicePermutation, -1, -1, d2, path2, phase2Context);

package/dist-cjs/puzzles/cube3/solver/symmetry.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUBE3_ORIENTATIONS_24 = exports.CUBE3_ROTATION_INVERSE = void 0;
+exports.invertCube3RotationSequence = invertCube3RotationSequence;
+exports.rotateCube3AlgorithmBySequence = rotateCube3AlgorithmBySequence;
+exports.rotateCube3Algorithm = rotateCube3Algorithm;
+const ROT_FACE = {
+    "x": { "U": "B", "R": "R", "F": "U", "D": "F", "L": "L", "B": "D" },
+    "x'": { "U": "F", "R": "R", "F": "D", "D": "B", "L": "L", "B": "U" },
+    "y": { "U": "U", "R": "F", "F": "L", "D": "D", "L": "B", "B": "R" },
+    "y'": { "U": "U", "R": "B", "F": "R", "D": "D", "L": "F", "B": "L" },
+    "z": { "U": "R", "R": "D", "F": "F", "D": "L", "L": "U", "B": "B" },
+    "z'": { "U": "L", "R": "U", "F": "F", "D": "R", "L": "D", "B": "B" },
+    "x2": { "U": "D", "R": "R", "F": "B", "D": "U", "L": "L", "B": "F" },
+    "y2": { "U": "U", "R": "L", "F": "B", "D": "D", "L": "R", "B": "F" },
+    "z2": { "U": "D", "R": "L", "F": "F", "D": "U", "L": "R", "B": "B" }
+};
+const INVERT_ROTATION = {
+    "x": "x'", "x'": "x",
+    "y": "y'", "y'": "y",
+    "z": "z'", "z'": "z",
+    "x2": "x2", "y2": "y2", "z2": "z2"
+};
+exports.CUBE3_ROTATION_INVERSE = {
+    "x": "x'",
+    "x'": "x",
+    "z": "z'",
+    "z'": "z"
+};
+/**
+ * 24 whole-cube orientations as rotation sequences, discovered by BFS over
+ * the group generated by x/y/z (canonicalized by face map, so all 24 are
+ * geometrically distinct by construction).
+ * The first three are identity, x, z — so `orientations: 3` keeps the
+ * legacy UD/x/z triple exactly.
+ */
+exports.CUBE3_ORIENTATIONS_24 = (() => {
+    const faces = ["U", "R", "F", "D", "L", "B"];
+    const identity = "URFDLB";
+    const composeKey = (key, gen) => {
+        const map = ROT_FACE[gen];
+        return faces.map((face, index) => map[key[index]]).join("");
+    };
+    const seen = new Map([[identity, []]]);
+    const queue = [identity];
+    while (queue.length > 0) {
+        const key = queue.shift();
+        const sequence = seen.get(key);
+        for (const gen of ["x", "y", "z"]) {
+            const next = composeKey(key, gen);
+            if (!seen.has(next)) {
+                seen.set(next, [...sequence, gen]);
+                queue.push(next);
+            }
+        }
+    }
+    const isLegacyTriple = (sequence) => sequence.length === 0 ||
+        (sequence.length === 1 && (sequence[0] === "x" || sequence[0] === "z"));
+    const rest = [];
+    for (const sequence of seen.values()) {
+        if (!isLegacyTriple(sequence))
+            rest.push(sequence);
+    }
+    return [[], ["x"], ["z"], ...rest];
+})();
+function invertCube3RotationSequence(sequence) {
+    return [...sequence].reverse().map((rotation) => INVERT_ROTATION[rotation]);
+}
+function rotateCube3AlgorithmBySequence(moves, sequence) {
+    let result = [...moves];
+    for (const rotation of sequence) {
+        const map = ROT_FACE[rotation];
+        result = result.map((move) => `${map[move[0]]}${move.slice(1)}`);
+    }
+    return result;
+}
+function rotateCube3Algorithm(moves, rotation) {
+    const map = ROT_FACE[rotation];
+    return moves.map((move) => `${map[move[0]]}${move.slice(1)}`);
+}

package/dist-cjs/puzzles/cube3/validation.js

@@ -47,15 +47,23 @@ function isAllowedRandomCube3State(state) {
         !isOneMoveFromSolvedCube3State(state);
 }
 function permutationParity(permutation) {
-    let inversions = 0;
-    for (let left = 0; left < permutation.length; left += 1) {
-        for (let right = left + 1; right < permutation.length; right += 1) {
-            if (permutation[left] > permutation[right]) {
-                inversions += 1;
-            }
+    // Cycle-decomposition parity in O(n) instead of O(n²) inversion counting
+    // (identical result: parity = (n − cycles) mod 2).
+    const visited = new Array(permutation.length).fill(false);
+    let parity = 0;
+    for (let start = 0; start < permutation.length; start += 1) {
+        if (visited[start] || permutation[start] === start)
+            continue;
+        let length = 0;
+        let current = start;
+        while (!visited[current]) {
+            visited[current] = true;
+            current = permutation[current];
+            length += 1;
         }
+        parity ^= (length - 1) & 1;
     }
-    return (inversions % 2);
+    return parity;
 }
 function validatePermutation(label, permutation, length) {
     const errors = [];

package/dist-cjs/puzzles/cube4/index.js

@@ -3,7 +3,7 @@
 // cube4 barrel exports
 // ---------------------------------------------------------------------------
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.getCube4FaceOrder = exports.formatCube4Facelets = exports.toCube4Facelets = exports.isAllowedRandomCube4State = exports.isTrivialCube4State = exports.isOneMoveFromSolvedCube4State = exports.validateCube4State = exports.generateRandomCube4State = exports.FACE_MOVE_EFFECTS = exports.parseMove = exports.parseCube4Move = exports.parseCube4Algorithm = exports.formatCube4Algorithm = exports.invertCube4Algorithm = exports.invertCube4Move = exports.applyCube4Algorithm = exports.applyCube4Move = exports.generateCube4Scramble = exports.cube4ScrambleGenerator = exports.areWingsPaired = exports.areCentersReduced = exports.isSolvedCube4State = exports.cube4StatesEqual = exports.cloneCube4State = exports.createSolvedCube4State = exports.CUBE4_OUTER_MOVES = exports.CUBE4_ALL_MOVES = exports.CUBE4_FACE_MOVES = exports.B = exports.L = exports.D = exports.F = exports.R = exports.U = exports.CENTERS_PER_FACE = exports.FACE_COUNT = exports.CENTER_COUNT = exports.WING_COUNT = exports.CORNER_COUNT = void 0;
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.getCube4FaceOrder = exports.formatCube4Facelets = exports.toCube4Facelets = exports.isAllowedRandomCube4State = exports.isTrivialCube4State = exports.isOneMoveFromSolvedCube4State = exports.validateCube4State = exports.generateRandomCube4State = exports.FACE_MOVE_EFFECTS = exports.parseMove = exports.parseCube4Move = exports.parseCube4Algorithm = exports.formatCube4Algorithm = exports.simplifyCube4Algorithm = exports.invertCube4Algorithm = exports.invertCube4Move = exports.applyCube4Algorithm = exports.applyCube4Move = exports.generateCube4Attempt = exports.generateCube4Scramble = exports.cube4ScrambleGenerator = exports.areWingsPaired = exports.areCentersReduced = exports.isSolvedCube4State = exports.cube4StatesEqual = exports.cloneCube4State = exports.createSolvedCube4State = exports.CUBE4_OUTER_MOVES = exports.CUBE4_ALL_MOVES = exports.CUBE4_FACE_MOVES = exports.B = exports.L = exports.D = exports.F = exports.R = exports.U = exports.CENTERS_PER_FACE = exports.FACE_COUNT = exports.CENTER_COUNT = exports.WING_COUNT = exports.CORNER_COUNT = void 0;
 const index_js_1 = require("../../core/index.js");
 const scrambler_js_1 = require("./scrambler.js");
 (0, index_js_1.registerScrambleGenerator)(scrambler_js_1.cube4ScrambleGenerator);
@@ -32,11 +32,13 @@ Object.defineProperty(exports, "areWingsPaired", { enumerable: true, get: functi
 var scrambler_js_2 = require("./scrambler.js");
 Object.defineProperty(exports, "cube4ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.cube4ScrambleGenerator; } });
 Object.defineProperty(exports, "generateCube4Scramble", { enumerable: true, get: function () { return scrambler_js_2.generateCube4Scramble; } });
+Object.defineProperty(exports, "generateCube4Attempt", { enumerable: true, get: function () { return scrambler_js_2.generateCube4Attempt; } });
 var moves_js_1 = require("./moves.js");
 Object.defineProperty(exports, "applyCube4Move", { enumerable: true, get: function () { return moves_js_1.applyCube4Move; } });
 Object.defineProperty(exports, "applyCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.applyCube4Algorithm; } });
 Object.defineProperty(exports, "invertCube4Move", { enumerable: true, get: function () { return moves_js_1.invertCube4Move; } });
 Object.defineProperty(exports, "invertCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.invertCube4Algorithm; } });
+Object.defineProperty(exports, "simplifyCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.simplifyCube4Algorithm; } });
 Object.defineProperty(exports, "formatCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.formatCube4Algorithm; } });
 Object.defineProperty(exports, "parseCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.parseCube4Algorithm; } });
 Object.defineProperty(exports, "parseCube4Move", { enumerable: true, get: function () { return moves_js_1.parseCube4Move; } });

package/dist-cjs/puzzles/cube4/moves.js

@@ -20,6 +20,7 @@ exports.invertCube4Algorithm = invertCube4Algorithm;
 exports.formatCube4Algorithm = formatCube4Algorithm;
 exports.parseCube4Algorithm = parseCube4Algorithm;
 exports.parseCube4Move = parseCube4Move;
+exports.simplifyCube4Algorithm = simplifyCube4Algorithm;
 const types_js_1 = require("./types.js");
 // ---------------------------------------------------------------------------
 // Identity arrays
@@ -170,6 +171,32 @@ const FACE_MOVE_EFFECTS = {
 };
 exports.FACE_MOVE_EFFECTS = FACE_MOVE_EFFECTS;
 // ---------------------------------------------------------------------------
+// Precomposed total effect per move string ("R'" = R x3, "U2" = U x2),
+// built once at module load. applyCube4Algorithm then costs one lookup +
+// one pass per move: no per-move string parsing, no repeated
+// quarter-turn passes (average ~2 passes collapse into exactly 1).
+// ---------------------------------------------------------------------------
+function composePower(face, turns) {
+    const quarter = FACE_MOVE_EFFECTS[face];
+    if (turns === 2)
+        return composeEffects(quarter, quarter);
+    if (turns === 3)
+        return composeEffects(composeEffects(quarter, quarter), quarter);
+    return quarter;
+}
+const COMPOSED_EFFECTS = Object.fromEntries(types_js_1.CUBE4_ALL_MOVES.map((move) => {
+    const { face, turns } = parseMove(move);
+    return [move, composePower(face, turns)];
+}));
+/** Total effect for one move string (precomposed fast path + parse fallback). */
+function effectForMove(move) {
+    const hit = COMPOSED_EFFECTS[move];
+    if (hit !== undefined)
+        return hit;
+    const { face, turns } = parseMove(move);
+    return composePower(face, turns);
+}
+// ---------------------------------------------------------------------------
 // Apply a single move to a state
 // ---------------------------------------------------------------------------
 function applyEffect(state, effect) {
@@ -204,20 +231,52 @@ function parseMove(move) {
     return { face: face, suffix, turns };
 }
 function applyCube4Move(state, move) {
-    const { face, turns } = parseMove(move);
-    const effect = FACE_MOVE_EFFECTS[face];
-    let current = state;
-    for (let i = 0; i < turns; i++) {
-        current = applyEffect(current, effect);
-    }
-    return current;
+    // Single-pass fast path through the precomposed total effect: one lookup
+    // + one pass, no string re-parsing, no repeated quarter-turn passes, no
+    // intermediate states.
+    return applyEffect(state, effectForMove(move));
 }
 function applyCube4Algorithm(state, moves) {
-    let current = state;
-    for (const move of moves) {
-        current = applyCube4Move(current, move);
+    if (moves.length === 0)
+        return state;
+    const bufA = {
+        cp: new Uint8Array(state.cp),
+        co: new Uint8Array(state.co),
+        wp: new Uint8Array(state.wp),
+        centers: new Uint8Array(state.centers)
+    };
+    const bufB = {
+        cp: new Uint8Array(8),
+        co: new Uint8Array(8),
+        wp: new Uint8Array(24),
+        centers: new Uint8Array(24)
+    };
+    let cur = bufA;
+    let nxt = bufB;
+    for (let mIdx = 0; mIdx < moves.length; mIdx++) {
+        const move = moves[mIdx];
+        const eff = effectForMove(move);
+        for (let i = 0; i < 8; i++) {
+            const from = eff.cperm[i];
+            nxt.cp[i] = cur.cp[from];
+            nxt.co[i] = (cur.co[from] + eff.corient[i]) % 3;
+        }
+        for (let i = 0; i < 24; i++) {
+            nxt.wp[i] = cur.wp[eff.wperm[i]];
+        }
+        for (let i = 0; i < 24; i++) {
+            nxt.centers[i] = cur.centers[eff.ctperm[i]];
+        }
+        const tmp = cur;
+        cur = nxt;
+        nxt = tmp;
     }
-    return current;
+    return {
+        cp: cur.cp,
+        co: cur.co,
+        wp: cur.wp,
+        centers: cur.centers
+    };
 }
 // ---------------------------------------------------------------------------
 // Move inversion
@@ -249,3 +308,54 @@ function parseCube4Move(value) {
     }
     throw new Error(`Invalid 4x4 move: ${value}`);
 }
+function parse4Move(m) {
+    const match = m.match(/^([UDFBLR]w?)(2|')?$/);
+    if (!match)
+        throw new Error(`Invalid move format: ${m}`);
+    const base = match[1];
+    const suffix = match[2] ?? "";
+    const amount = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    const axis = (base[0] === "U" || base[0] === "D") ? 0 :
+        (base[0] === "R" || base[0] === "L") ? 1 : 2;
+    return { base, axis, amount };
+}
+function format4Move(base, amount) {
+    const amt = ((amount % 4) + 4) % 4;
+    if (amt === 0)
+        return null;
+    const suffix = amt === 1 ? "" : amt === 2 ? "2" : "'";
+    return (base + suffix);
+}
+function movesCommute4(a, b) {
+    return a.axis === b.axis && a.base !== b.base;
+}
+/**
+ * Simplifies a 4x4 algorithm by canceling inverse moves and merging redundant
+ * turns on the same face or across commuting parallel faces.
+ */
+function simplifyCube4Algorithm(moves) {
+    // Single left-to-right pass with an output stack: each move merges with
+    // the nearest same-base entry across trailing commuting parallel-face
+    // moves (verified equivalent to the old restart-from-zero loop on 20000
+    // random algorithms). O(n·window) instead of O(n²) restarts with splices.
+    const out = [];
+    for (const move of moves) {
+        const current = parse4Move(move);
+        let index = out.length - 1;
+        while (index >= 0 && movesCommute4(out[index], current))
+            index--;
+        if (index >= 0 && out[index].base === current.base) {
+            const merged = (out[index].amount + current.amount) % 4;
+            if (merged === 0)
+                out.splice(index, 1);
+            else
+                out[index].amount = merged;
+        }
+        else {
+            out.push(current);
+        }
+    }
+    return out
+        .map((p) => format4Move(p.base, p.amount))
+        .filter((m) => m !== null);
+}