@cubingcenter/scrambler 0.6.3 → 0.8.0

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

@@ -1,10 +1,11 @@
-import { applyCube3Algorithm } from "../moves.js";
-import { isSolvedCube3State } from "../state.js";
+import { applyCube3Algorithm, invertCube3Algorithm } from "../moves.js";
+import { createSolvedCube3State, isSolvedCube3State } from "../state.js";
 import { encodePermutation, encodeSlicePermutation, encodeUdEdgePermutation } from "./coordinates.js";
-import { isCube3Phase1Solved, solveCube3Phase1 } from "./phase1.js";
+import { isCube3Phase1Solved, solveCube3Phase1, collectCube3Phase1Solutions, encodeCube3Phase1Coordinates } from "./phase1.js";
 import { loadCube3Phase1Tables, loadCube3Phase2Tables, CUBE3_PHASE1_MOVES, CUBE3_PHASE2_MOVES } from "./tables.js";
 import { getMoveFace, getMoveFaceByIndex, shouldSkipCube3SearchMove } from "./search-utils.js";
 import { loadCube3PairTables, pairBound } from "./pair-tables.js";
+import { CUBE3_ORIENTATIONS_24, invertCube3RotationSequence, rotateCube3AlgorithmBySequence } from "./symmetry.js";
 export class Cube3Phase2SearchError extends Error {
     visitedNodes;
     constructor(message, visitedNodes) {
@@ -41,17 +42,11 @@ export async function solveCube3Phase2(state, options = {}) {
         throw new Cube3Phase2SearchError("3x3 Phase 2 requires a state already in G1.", 0);
     }
     const tables = options.tables ?? await loadCube3Phase2Tables();
-    const pairTables = options.pairTables ?? await loadCube3PairTables();
+    const pairTables = options.pairTables ?? (options.skipPairTables ? undefined : await 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, options.maxNodes);
     const spRange = tables.moveTables.slicePermutation.range;
     const cpspTable = tables.pruningTables.cornerPermutationSlicePermutation.values;
     const epspTable = tables.pruningTables.udEdgePermutationSlicePermutation.values;
@@ -82,6 +77,9 @@ export async function solveCube3Phase2(state, options = {}) {
                 visitedNodes: context.visitedNodes
             };
         }
+        if (context.nodesExceeded) {
+            throw new Cube3Phase2SearchError(`3x3 Phase 2 node budget exceeded (${options.maxNodes} nodes).`, context.visitedNodes);
+        }
         if (context.timedOut) {
             throw new Cube3Phase2SearchError(`3x3 Phase 2 search timed out after ${options.timeoutMs}ms.`, context.visitedNodes);
         }
@@ -89,6 +87,11 @@ export async function solveCube3Phase2(state, options = {}) {
     throw new Cube3Phase2SearchError(`3x3 Phase 2 solution not found within depth ${maxDepth}.`, context.visitedNodes);
 }
 export 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 solveCube3Phase1(state, options.phase1);
     let previousFace = -1;
     let previousPreviousFace = -1;
@@ -107,6 +110,154 @@ export 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 loadCube3Phase1Tables();
+        const p2Tables = options.phase2?.tables ?? await loadCube3Phase2Tables();
+        const scoredPairTables = options.phase2?.pairTables ??
+            (options.phase2?.skipPairTables ? undefined : await loadCube3PairTables());
+        // Work budget for the improvement loop. Preferred: `improveMaxNodes`
+        // (deterministic node counter — the wall deadline stays unarmed so the
+        // outcome cannot depend on CPU load/clock). Legacy: `timeoutMs ?? 800`
+        // wall deadline, kept for existing callers.
+        const nodeMode = options.improveMaxNodes !== undefined;
+        let remainingNodes = options.improveMaxNodes ?? 0;
+        const deadline = nodeMode ? undefined : performance.now() + (options.timeoutMs ?? 800);
+        const budgetExhausted = () => nodeMode ? remainingNodes <= 0 : performance.now() > deadline;
+        const spendNodes = (used) => {
+            if (nodeMode) {
+                remainingNodes = Math.max(0, remainingNodes - used);
+            }
+        };
+        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 (budgetExhausted())
+                break;
+            const { solutions: p1Solutions, visitedNodes } = await collectCube3Phase1Solutions(state, d, {
+                tables: p1Tables,
+                limit: solutionLimit,
+                ...(nodeMode
+                    ? { maxNodes: Math.max(1, remainingNodes) }
+                    : { timeoutMs: Math.max(1, deadline - performance.now()) })
+            });
+            improvementNodes += visitedNodes;
+            spendNodes(visitedNodes);
+            if (budgetExhausted())
+                break;
+            for (const p1Moves of p1Solutions) {
+                if (budgetExhausted())
+                    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 = 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 = 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 ? getMoveFace(p1Moves[p1Moves.length - 1]) : -1;
+                const ppFace = p1Moves.length > 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 (budgetExhausted())
+                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 {
+                // Strip any legacy wall `timeoutMs` from the spread: in node mode
+                // the wall deadline must not be armed at all (pure function of
+                // budgets); in wall mode the per-candidate cap below re-adds it.
+                const phase2Source = options.phase2 ?? {};
+                const { timeoutMs: legacyPhase2Wall, ...phase2CandidateBase } = phase2Source;
+                // Per-candidate budget: node cap (deterministic) when the loop runs
+                // on `improveMaxNodes`, else the legacy wall cap.
+                const candidateCap = nodeMode
+                    ? {
+                        maxNodes: Math.max(1, Math.min(options.improvePhase2MaxNodes ?? phase2CandidateBase.maxNodes ?? remainingNodes, remainingNodes))
+                    }
+                    : {
+                        timeoutMs: Math.min(options.improvePhase2TimeoutMs ?? legacyPhase2Wall ?? 25, Math.max(1, deadline - performance.now()))
+                    };
+                const candP2 = await solveCube3Phase2(cand.state, {
+                    ...phase2CandidateBase,
+                    pairTables: scoredPairTables,
+                    tables: p2Tables,
+                    maxDepth: maxP2,
+                    previousFace: cand.pFace,
+                    previousPreviousFace: cand.ppFace,
+                    ...candidateCap
+                });
+                improvementNodes += candP2.visitedNodes;
+                spendNodes(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: 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,
@@ -116,6 +267,39 @@ export 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), CUBE3_ORIENTATIONS_24.length);
+    const singleOptions = { ...options, orientations: 1 };
+    let best = await solveCube3State(state, singleOptions);
+    let visitedNodes = best.visitedNodes;
+    const scramble = invertCube3Algorithm(best.moves);
+    const sequences = CUBE3_ORIENTATIONS_24.slice(1, count);
+    for (const sequence of sequences) {
+        try {
+            const rotatedState = applyCube3Algorithm(createSolvedCube3State(), rotateCube3AlgorithmBySequence(scramble, sequence));
+            const candidate = await solveCube3State(rotatedState, singleOptions);
+            visitedNodes += candidate.visitedNodes;
+            if (candidate.moves.length < best.moves.length) {
+                best = {
+                    ...candidate,
+                    moves: rotateCube3AlgorithmBySequence(candidate.moves, invertCube3RotationSequence(sequence)),
+                    depth: candidate.moves.length,
+                    visitedNodes
+                };
+            }
+        }
+        catch {
+            // A flaky orientation must never fail the whole solve.
+        }
+    }
+    return { ...best, visitedNodes };
+}
 export function encodeCube3Phase2Coordinates(state) {
     return {
         cornerPermutation: encodeCornerPermutationForPhase2(state),
@@ -138,10 +322,38 @@ const PHASE2_MOVE_FACES = 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, nodeCap = undefined) {
+    const scratchLevels = maxDepth + 1;
+    const scratchSize = scratchLevels * CUBE3_PHASE2_MOVES.length;
+    return {
+        tables,
+        pairTables,
+        maxDepth,
+        deadline,
+        nodeCap,
+        visitedNodes: 0,
+        timedOut: false,
+        nodesExceeded: 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) {
+    if (context.nodeCap !== undefined &&
+        context.visitedNodes > context.nodeCap) {
+        context.nodesExceeded = true;
+    }
+    if (!context.nodesExceeded &&
+        context.deadline !== undefined &&
+        (context.visitedNodes & 1023) === 0 &&
+        performance.now() > context.deadline) {
         context.timedOut = true;
+    }
+    if (context.timedOut || context.nodesExceeded) {
         return false;
     }
     if (remainingDepth === 0) {
@@ -157,41 +369,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];
@@ -205,29 +399,52 @@ function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, pr
         if (nextLowerBound > remainingDepth - 1) {
             continue;
         }
-        const pair = pairBound(pairTables, nextCornerPermutation, nextUdEdgePermutation);
-        if (pair > nextLowerBound) {
-            nextLowerBound = pair;
+        if (pairTables !== undefined) {
+            const pair = 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();
-        if (context.timedOut) {
+        if (context.timedOut || context.nodesExceeded) {
             return false;
         }
     }
@@ -272,13 +489,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/puzzles/cube3/solver/search-utils.d.ts

@@ -5,5 +5,5 @@ export declare function getMoveFaceByIndex(moveIndex: number, moves: readonly Cu
 export declare const ARE_OPPOSITE_FACES: readonly boolean[];
 export declare function areOppositeFaces(left: Cube3SearchFace, right: Cube3SearchFace): boolean;
 export declare function shouldSkipCube3SearchMove(face: Cube3SearchFace, previousFace: Cube3SearchFace | undefined, previousPreviousFace: Cube3SearchFace | undefined): boolean;
-export declare function lookupMoveTableByIndex(values: Int32Array, coordinate: number, moveIndex: number, moveCount: number): number;
+export declare function lookupMoveTableByIndex(values: Int32Array | Uint16Array, coordinate: number, moveIndex: number, moveCount: number): number;
 //# sourceMappingURL=search-utils.d.ts.map

package/dist/puzzles/cube3/solver/search-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-utils.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/search-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAYrC,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,eAAe,CAElG;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,OAAO,EAOhD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAEvF;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,eAAe,GAAG,SAAS,EACzC,oBAAoB,EAAE,eAAe,GAAG,SAAS,GAChD,OAAO,CAcT;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAER"}
+{"version":3,"file":"search-utils.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/search-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAYrC,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,eAAe,CAElG;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,OAAO,EAOhD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAEvF;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,eAAe,GAAG,SAAS,EACzC,oBAAoB,EAAE,eAAe,GAAG,SAAS,GAChD,OAAO,CAcT;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,UAAU,GAAG,WAAW,EAChC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAER"}

package/dist/puzzles/cube3/solver/symmetry.d.ts

@@ -0,0 +1,24 @@
+import type { Cube3Move } from "../types.js";
+/**
+ * Whole-cube rotations for 3x3 move sequences.
+ *
+ * Face maps ported from the 4x4 solver's `ROT_MAP`
+ * (`puzzles/cube4/reduction/solve.ts`), restricted to the six basic faces —
+ * kept cube3-local so `solver/` never imports from `cube4` (which itself
+ * depends on this solver).
+ */
+export type Cube3Rotation = "x" | "x'" | "z" | "z'";
+export declare const CUBE3_ROTATION_INVERSE: Record<Cube3Rotation, Cube3Rotation>;
+export type Cube3RotationSequence = readonly string[];
+/**
+ * 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.
+ */
+export declare const CUBE3_ORIENTATIONS_24: readonly Cube3RotationSequence[];
+export declare function invertCube3RotationSequence(sequence: Cube3RotationSequence): string[];
+export declare function rotateCube3AlgorithmBySequence(moves: readonly Cube3Move[], sequence: Cube3RotationSequence): Cube3Move[];
+export declare function rotateCube3Algorithm(moves: readonly Cube3Move[], rotation: Cube3Rotation): Cube3Move[];
+//# sourceMappingURL=symmetry.d.ts.map

package/dist/puzzles/cube3/solver/symmetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetry.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/symmetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC;AAqBpD,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,aAAa,EAAE,aAAa,CAKvE,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,SAAS,MAAM,EAAE,CAAC;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,qBAAqB,EA4B9D,CAAC;AAEL,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,EAAE,CAErF;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,QAAQ,EAAE,qBAAqB,GAC9B,SAAS,EAAE,CAOb;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,QAAQ,EAAE,aAAa,GACtB,SAAS,EAAE,CAGb"}

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

@@ -0,0 +1,74 @@
+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"
+};
+export const 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.
+ */
+export const 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];
+})();
+export function invertCube3RotationSequence(sequence) {
+    return [...sequence].reverse().map((rotation) => INVERT_ROTATION[rotation]);
+}
+export 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;
+}
+export function rotateCube3Algorithm(moves, rotation) {
+    const map = ROT_FACE[rotation];
+    return moves.map((move) => `${map[move[0]]}${move.slice(1)}`);
+}

package/dist/puzzles/cube3/solver/tables.d.ts

@@ -7,7 +7,12 @@ export interface Cube3MoveTable {
     moves: readonly Cube3Move[];
     range: number;
     solvedCoordinate: number;
-    values: Int32Array;
+    /**
+     * Move-table values. Every coordinate fits in 16 bits (max range 40320),
+     * so loaders store `Uint16Array` (half the RAM/cache of the int32 wire
+     * format); table generation still builds `Int32Array`.
+     */
+    values: Int32Array | Uint16Array;
     checksum: number;
 }
 export interface Cube3PruningTable {

package/dist/puzzles/cube3/solver/tables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/tables.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/tables.ts"],"names":[],"mappings":"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"}

package/dist/puzzles/cube3/solver/tables.js

@@ -2,6 +2,7 @@ import { CUBE3_MOVES } from "../types.js";
 import { CUBE3_COORDINATE_RANGES, encodeCube3Coordinates, moveCoordinate } from "./coordinates.js";
 import { createSolvedCube3State } from "../state.js";
 import { loadGeneratedCube3Phase1Tables, loadGeneratedCube3Phase2Tables, loadGeneratedCube3SolverTables } from "./generated-assets.js";
+import { loadOnce } from "../../shared/load-once.js";
 export const CUBE3_PHASE1_MOVES = CUBE3_MOVES;
 export const CUBE3_PHASE2_MOVES = [
     "U",
@@ -15,20 +16,21 @@ export const CUBE3_PHASE2_MOVES = [
     "F2",
     "B2"
 ];
-let cachedTables;
-let cachedPhase1Tables;
-let cachedPhase2Tables;
-export async function loadCube3SolverTables() {
-    cachedTables ??= await loadGeneratedCube3SolverTables();
-    return cachedTables;
+// Promise slots (shared helper, see shared/load-once.ts): concurrent cold
+// calls share ONE in-flight load instead of racing several loads and
+// clobbering each other's results; a rejection purges the slot so the next
+// call can retry.
+const solverTablesSlot = { promise: undefined };
+const phase1TablesSlot = { promise: undefined };
+const phase2TablesSlot = { promise: undefined };
+export function loadCube3SolverTables() {
+    return loadOnce(solverTablesSlot, loadGeneratedCube3SolverTables);
 }
-export async function loadCube3Phase1Tables() {
-    cachedPhase1Tables ??= await loadGeneratedCube3Phase1Tables();
-    return cachedPhase1Tables;
+export function loadCube3Phase1Tables() {
+    return loadOnce(phase1TablesSlot, loadGeneratedCube3Phase1Tables);
 }
-export async function loadCube3Phase2Tables() {
-    cachedPhase2Tables ??= await loadGeneratedCube3Phase2Tables();
-    return cachedPhase2Tables;
+export function loadCube3Phase2Tables() {
+    return loadOnce(phase2TablesSlot, loadGeneratedCube3Phase2Tables);
 }
 export function generateCube3Phase1Tables() {
     const cornerOrientation = generateCube3MoveTable("cornerOrientation", CUBE3_COORDINATE_RANGES.cornerOrientation, CUBE3_PHASE1_MOVES);

package/dist/puzzles/cube3/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CA+B3E;AASD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAExE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CA+B3E;AASD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAExE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAmBvE"}