@cubingcenter/scrambler 0.5.0 → 0.5.2

package/dist/puzzles/cube2/facelets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AA4BrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAehE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,SAAS,EAAE,CAExD"}
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AAgErF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAqBhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,SAAS,EAAE,CAExD"}

package/dist/puzzles/cube2/facelets.js

@@ -1,4 +1,6 @@
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const STICKERS = ["U", "R", "F", "D", "L", "B"];
+const STICKER_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 const CORNER_PIECE_STICKERS = [
     ["U", "R", "F"],
     ["U", "F", "L"],
@@ -19,12 +21,48 @@ const CORNER_POSITION_SLOTS = [
     [["D", 2], ["B", 3], ["L", 2]],
     [["D", 3], ["R", 3], ["B", 2]]
 ];
-export function toCube2Facelets(state) {
-    const facelets = createEmptyFacelets();
+const CORNER_CELLS = buildCells();
+function buildCells() {
+    const cells = [];
     for (let position = 0; position < CORNER_POSITION_SLOTS.length; position += 1) {
-        const piece = state.corners.permutation[position];
-        const orientation = state.corners.orientation[position];
-        placeOrientedStickers(facelets, CORNER_POSITION_SLOTS[position], CORNER_PIECE_STICKERS[piece], orientation);
+        const byPiece = [];
+        for (let piece = 0; piece < CORNER_PIECE_STICKERS.length; piece += 1) {
+            const byOrientation = [];
+            for (let orientation = 0; orientation < 3; orientation += 1) {
+                const stickers = CORNER_PIECE_STICKERS[piece];
+                const slotList = CORNER_POSITION_SLOTS[position];
+                const cell = [];
+                for (let index = 0; index < slotList.length; index += 1) {
+                    const [face, stickerIndex] = slotList[index];
+                    cell.push(FACE_ORDER.indexOf(face));
+                    cell.push(stickerIndex);
+                    cell.push(STICKER_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
+export function toCube2Facelets(state) {
+    const facelets = {
+        U: Array(4),
+        R: Array(4),
+        F: Array(4),
+        D: Array(4),
+        L: Array(4),
+        B: Array(4)
+    };
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    const permutation = state.corners.permutation;
+    const orientation = state.corners.orientation;
+    for (let position = 0; position < CORNER_CELLS.length; position += 1) {
+        const cells = CORNER_CELLS[position][permutation[position]][orientation[position]];
+        for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+            faces[cells[cellIndex]][cells[cellIndex + 1]] = STICKERS[cells[cellIndex + 2]];
+        }
     }
     return facelets;
 }
@@ -34,20 +72,3 @@ export function formatCube2Facelets(facelets) {
 export function getCube2FaceOrder() {
     return FACE_ORDER;
 }
-function createEmptyFacelets() {
-    return {
-        U: Array(4).fill("U"),
-        R: Array(4).fill("R"),
-        F: Array(4).fill("F"),
-        D: Array(4).fill("D"),
-        L: Array(4).fill("L"),
-        B: Array(4).fill("B")
-    };
-}
-function placeOrientedStickers(facelets, slots, stickers, orientation) {
-    for (let index = 0; index < slots.length; index += 1) {
-        const [face, stickerIndex] = slots[index];
-        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
-        facelets[face][stickerIndex] = sticker;
-    }
-}

package/dist/puzzles/cube2/random-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/random-state.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGtE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAa1F"}
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAItE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAsB1F"}

package/dist/puzzles/cube2/random-state.js

@@ -1,51 +1,61 @@
 import { createRandomSource } from "../../random/index.js";
-import { CORNER_COUNT } from "./types.js";
-import { isAllowedRandomCube2State } from "./validation.js";
+import { isTrivialSamplingCube2State } from "./validation.js";
+import { encodePermutation, encodeOrientation } from "./solver/tables.js";
 export function generateRandomCube2State(options = {}) {
     const random = createRandomSource(options.seed);
     const rejectTrivial = options.rejectTrivial ?? true;
     for (let attempt = 0; attempt < 100; attempt += 1) {
+        // The state is legal by construction (DBL corner fixed, even
+        // permutation, orientation sum divisible by 3, values in range), so the
+        // only meaningful rejection is the trivial set: solved + the 18
+        // single-move states (scrambles shorter than 2 moves). Coordinates are
+        // encoded once for both checks.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || isAllowedRandomCube2State(state)) {
+        if (!rejectTrivial) {
+            return state;
+        }
+        const p = encodePermutation(state.corners.permutation);
+        const o = encodeOrientation(state.corners.orientation);
+        if (!isTrivialSamplingCube2State(p, o)) {
             return state;
         }
     }
     throw new Error("Unable to generate a non-trivial random 2x2 state.");
 }
 function createLegalRandomState(random) {
-    const perm7 = shuffledRange(CORNER_COUNT - 1, random);
-    const mappedPerm = perm7.map((val) => (val >= 6 ? val + 1 : val));
-    mappedPerm.splice(6, 0, 6);
-    const orient7 = randomOrientations(CORNER_COUNT - 1, 3, random);
-    orient7.splice(6, 0, 0);
-    return {
-        corners: {
-            permutation: mappedPerm,
-            orientation: orient7
-        }
-    };
-}
-function shuffledRange(length, random) {
-    const values = Array.from({ length }, (_, index) => index);
-    for (let index = values.length - 1; index > 0; index -= 1) {
+    // 7 free corners (piece 6 = DBL stays fixed at position 6)
+    const perm7 = [0, 1, 2, 3, 4, 5, 6];
+    for (let index = 6; index > 0; index -= 1) {
         const swapIndex = random.nextInt(index + 1);
-        swap(values, index, swapIndex);
+        if (swapIndex < index) {
+            const temporary = perm7[index];
+            perm7[index] = perm7[swapIndex];
+            perm7[swapIndex] = temporary;
+        }
     }
-    return values;
-}
-function randomOrientations(length, modulo, random) {
-    const orientations = Array(length).fill(0);
+    // Map the shuffle domain {0..6} to {0..5,7} and insert 6 at position 6
+    // (DBL fixed). Single allocation, no intermediate arrays.
+    const last = perm7[6] >= 6 ? perm7[6] + 1 : perm7[6];
+    const permutation = new Array(8);
+    for (let index = 0; index < 6; index += 1) {
+        const value = perm7[index];
+        permutation[index] = value >= 6 ? value + 1 : value;
+    }
+    permutation[6] = 6;
+    permutation[7] = last;
+    // 7 free orientations with sum divisible by 3; DBL stays oriented
+    const orientation = [0, 0, 0, 0, 0, 0, 0, 0];
     let total = 0;
-    for (let index = 0; index < length - 1; index += 1) {
-        const orientation = random.nextInt(modulo);
-        orientations[index] = orientation;
-        total += orientation;
+    for (let index = 0; index < 6; index += 1) {
+        const value = random.nextInt(3);
+        orientation[index] = value;
+        total += value;
     }
-    orientations[length - 1] = (modulo - (total % modulo)) % modulo;
-    return orientations;
-}
-function swap(values, left, right) {
-    const temporary = values[left];
-    values[left] = values[right];
-    values[right] = temporary;
+    orientation[7] = (3 - (total % 3)) % 3;
+    return {
+        corners: {
+            permutation,
+            orientation
+        }
+    };
 }

package/dist/puzzles/cube2/scrambler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAS9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CAwCzB"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAiB9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CAqDzB"}

package/dist/puzzles/cube2/scrambler.js

@@ -1,7 +1,10 @@
-import { formatCube2Algorithm, invertCube2Algorithm } from "./moves.js";
+import { formatCube2Algorithm } from "./moves.js";
 import { generateRandomCube2State } from "./random-state.js";
 import { formatCube2Facelets, toCube2Facelets } from "./facelets.js";
-import { solveCube2State, verifyCube2Scramble, verifyCube2Solution } from "./solver/index.js";
+import { areCube2TablesLoaded, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2SolutionIndices, BFS_MOVES } from "./solver/index.js";
+// BFS_MOVES = [U, U2, U', R, R2, R', F, F2, F'] — the inverse of index m is
+// CUBE2_MOVE_INVERSE[m] (U2/R2/F2 are self-inverse, so m ^ 1 does not apply).
+const CUBE2_MOVE_INVERSE = [2, 1, 0, 5, 4, 3, 8, 7, 6];
 export const cube2ScrambleGenerator = {
     info: {
         eventId: "222",
@@ -17,20 +20,31 @@ export const cube2ScrambleGenerator = {
 };
 export async function generateCube2Scramble(options = {}) {
     const state = generateRandomCube2State(options);
-    const solution = await solveCube2State(state);
-    const scrambleMoves = invertCube2Algorithm(solution.moves);
+    const solution = areCube2TablesLoaded()
+        ? solveCube2StateIndicesSync(state)
+        : await solveCube2StateIndices(state);
+    const depth = solution.length;
+    // Scramble = inverse of the solution, reversed.
+    const scrambleMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        scrambleMoves[index] = BFS_MOVES[CUBE2_MOVE_INVERSE[solution[depth - 1 - index]]];
+    }
     if (!options.skipValidation) {
-        if (!verifyCube2Scramble(state, scrambleMoves)) {
+        // The scramble is the exact inverse of the solution, so verifying that
+        // the solution solves the target state is equivalent to verifying that
+        // the scramble reproduces it — a single numeric walk suffices.
+        if (!verifyCube2SolutionIndices(state, solution)) {
             throw new Error("Generated 2x2 scramble does not reproduce the target random state.");
         }
-        if (!verifyCube2Solution(state, solution.moves)) {
-            throw new Error("Generated 2x2 solution does not solve the target random state.");
-        }
         if (scrambleMoves.length < 2) {
             throw new Error("Generated 2x2 scramble is too short.");
         }
     }
     const facelets = toCube2Facelets(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = BFS_MOVES[solution[index]];
+    }
     const result = {
         eventId: "222",
         scramble: formatCube2Algorithm(scrambleMoves),
@@ -41,8 +55,8 @@ export async function generateCube2Scramble(options = {}) {
             state,
             facelets,
             faceletString: formatCube2Facelets(facelets),
-            solutionMoves: solution.moves,
-            solutionDepth: solution.depth
+            solutionMoves,
+            solutionDepth: depth
         }
     };
     if (options.seed !== undefined) {

package/dist/puzzles/cube2/solver/index.d.ts

@@ -1,3 +1,4 @@
-export { solveCube2State, verifyCube2Scramble, verifyCube2Solution } from "./search.js";
+export { solveCube2State, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2Scramble, verifyCube2Solution, verifyCube2SolutionIndices } from "./search.js";
 export type { Cube2Solution } from "./search.js";
+export { areCube2TablesLoaded, BFS_MOVES, DISTANCES, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/puzzles/cube2/solver/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACxF,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,wBAAwB,EACxB,wBAAwB,EACxB,UAAU,EACV,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC"}

package/dist/puzzles/cube2/solver/index.js

@@ -1 +1,2 @@
-export { solveCube2State, verifyCube2Scramble, verifyCube2Solution } from "./search.js";
+export { solveCube2State, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2Scramble, verifyCube2Solution, verifyCube2SolutionIndices } from "./search.js";
+export { areCube2TablesLoaded, BFS_MOVES, DISTANCES, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";

package/dist/puzzles/cube2/solver/search.d.ts

@@ -5,6 +5,9 @@ export interface Cube2Solution {
     state: Cube2State;
 }
 export declare function solveCube2State(state: Cube2State): Promise<Cube2Solution>;
+export declare function solveCube2StateIndices(state: Cube2State): Promise<number[]>;
+export declare function solveCube2StateIndicesSync(state: Cube2State): number[];
 export declare function verifyCube2Scramble(state: Cube2State, scrambleMoves: readonly Cube2Move[]): boolean;
 export declare function verifyCube2Solution(state: Cube2State, solutionMoves: readonly Cube2Move[]): boolean;
+export declare function verifyCube2SolutionIndices(state: Cube2State, solution: readonly number[]): boolean;
 //# sourceMappingURL=search.d.ts.map

package/dist/puzzles/cube2/solver/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CA6D/E;AAoBD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAQ/E;AAKD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKtE;AA6ED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAMD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAclG"}

package/dist/puzzles/cube2/solver/search.js

@@ -2,6 +2,27 @@ import { createSolvedCube2State } from "../state.js";
 import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, DISTANCES, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
 export async function solveCube2State(state) {
     await ensureTablesLoaded();
+    const indices = solveWithTablesIndices(state);
+    return {
+        moves: indices.map((index) => BFS_MOVES[index]),
+        depth: indices.length,
+        state: createSolvedCube2State()
+    };
+}
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..8) in walk order. The inverse of index m is CUBE2_MOVE_INVERSE[m]
+// (U2/R2/F2 are self-inverse, so m ^ 1 does not apply here).
+export async function solveCube2StateIndices(state) {
+    await ensureTablesLoaded();
+    return solveWithTablesIndices(state);
+}
+export function solveCube2StateIndicesSync(state) {
+    if (!DISTANCES) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTablesIndices(state);
+}
+function solveWithTablesIndices(state) {
     if (state.corners.permutation[6] !== 6 || state.corners.orientation[6] !== 0) {
         throw new Error("The 2x2 solver requires the DBL corner (index 6) to be solved " +
             "as the frame of reference. Please normalize the state before solving.");
@@ -16,7 +37,7 @@ export async function solveCube2State(state) {
     const initialCombined = permIndex * ORIENTATION_COUNT + orientIndex;
     let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
     if (distance === 0) {
-        return { moves, depth: 0, state: createSolvedCube2State() };
+        return moves;
     }
     while (distance > 0) {
         let foundNext = false;
@@ -30,7 +51,7 @@ export async function solveCube2State(state) {
             const combined = nextPerm * ORIENTATION_COUNT + nextOrient;
             const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
             if (nextDist === nextDistance) {
-                moves.push(BFS_MOVES[m]);
+                moves.push(m);
                 permIndex = nextPerm;
                 orientIndex = nextOrient;
                 distance = nextDistance;
@@ -42,11 +63,7 @@ export async function solveCube2State(state) {
             throw new Error("BFS distance table corrupted or unreachable state.");
         }
     }
-    return {
-        moves,
-        depth: moves.length,
-        state: createSolvedCube2State()
-    };
+    return moves;
 }
 const MOVE_INDEX = {};
 for (let i = 0; i < BFS_MOVES.length; i++) {
@@ -74,3 +91,21 @@ export function verifyCube2Solution(state, solutionMoves) {
     const { permIndex, orientIndex } = walkCube2Coordinates(encodePermutation(state.corners.permutation), encodeOrientation(state.corners.orientation), solutionMoves);
     return permIndex === 0 && orientIndex === 0;
 }
+// Numeric verification for the hot scramble path: walks the solution (move
+// indices, walk order) from the target state to solved. The scramble is the
+// exact inverse of the solution, so this is equivalent to verifying that the
+// scramble reproduces the target state — one walk, no string parsing.
+export function verifyCube2SolutionIndices(state, solution) {
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    if (!permTable || !orientTable) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let permIndex = encodePermutation(state.corners.permutation);
+    let orientIndex = encodeOrientation(state.corners.orientation);
+    for (const m of solution) {
+        permIndex = permTable[permIndex * MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * MOVE_COUNT + m];
+    }
+    return permIndex === 0 && orientIndex === 0;
+}

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

@@ -7,6 +7,7 @@ export declare let PERMUTATION_TABLE: Uint16Array | null;
 export declare let ORIENTATION_TABLE: Uint16Array | null;
 export declare let DISTANCES: Uint8Array | null;
 export declare function ensureTablesLoaded(): Promise<void>;
+export declare function areCube2TablesLoaded(): boolean;
 export declare function getDistance(permIndex: number, orientIndex: number): number;
 export declare function getPermutationTransition(move: number, permIndex: number): number;
 export declare function getOrientationTransition(move: number, orientIndex: number): number;

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

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAM5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAexE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,SAAS,EAAE,UAAU,GAAG,IAAW,CAAC;AAE/C,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAO1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAM5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAexE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,SAAS,EAAE,UAAU,GAAG,IAAW,CAAC;AAE/C,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAO1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}

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

@@ -52,6 +52,9 @@ export async function ensureTablesLoaded() {
     DISTANCES = tables.distances;
     tablesLoaded = true;
 }
+export function areCube2TablesLoaded() {
+    return tablesLoaded;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

package/dist/puzzles/cube2/validation.d.ts

@@ -1,6 +1,7 @@
 import type { Cube2State, Cube2ValidationResult } from "./types.js";
 export declare function validateCube2State(state: Cube2State): Cube2ValidationResult;
 export declare function isOneMoveFromSolvedCube2State(state: Cube2State): boolean;
+export declare function isTrivialSamplingCube2State(p: number, o: number): boolean;
 export declare function isAllowedRandomCube2State(state: Cube2State): boolean;
 export declare function permutationParity(permutation: readonly number[]): 0 | 1;
 //# sourceMappingURL=validation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAgBpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAkB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIxE;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/cube2/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAgBpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAkB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIxE;AAKD,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}

package/dist/puzzles/cube2/validation.js

@@ -31,7 +31,13 @@ export function validateCube2State(state) {
 export function isOneMoveFromSolvedCube2State(state) {
     const p = encodePermutation(state.corners.permutation);
     const o = encodeOrientation(state.corners.orientation);
-    return ONE_MOVE_FROM_SOLVED_ENCODED.some((entry) => entry.p === p && entry.o === o);
+    return isTrivialSamplingCube2State(p, o);
+}
+// Cheap trivial check for random-state sampling: the caller has already
+// encoded the coordinates once. True for the solved state and the 18
+// single-move states (which would produce scrambles shorter than 2 moves).
+export function isTrivialSamplingCube2State(p, o) {
+    return (p === 0 && o === 0) || ONE_MOVE_FROM_SOLVED_ENCODED.some((entry) => entry.p === p && entry.o === o);
 }
 export function isAllowedRandomCube2State(state) {
     return validateCube2State(state).valid &&

package/dist/puzzles/pyraminx/facelets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAUhD,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AA6DhF,wBAAgB,4BAA4B,IAAI,gBAAgB,CAO/D;AAyBD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAiCzE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAEzE;AAED,wBAAgB,oBAAoB,IAAI,SAAS,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAEzE"}
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAUhD,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AAsGhF,wBAAgB,4BAA4B,IAAI,gBAAgB,CAO/D;AAoBD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAezE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAEzE;AAED,wBAAgB,oBAAoB,IAAI,SAAS,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAEzE"}

package/dist/puzzles/pyraminx/facelets.js

@@ -1,4 +1,6 @@
 const FACE_ORDER = ["F", "L", "R", "D"];
+const COLORS = ["F", "L", "R", "D"];
+const COLOR_INDEX = { F: 0, L: 1, R: 2, D: 3 };
 // positionId -> sticker slots (each slot = one triangle cell of the grid).
 // Positions follow the scrambler piece model (moves.ts):
 //   edges 0..5 = UL, UR, UB, LR, LB, RB
@@ -48,6 +50,33 @@ const TIP_PIECE_STICKERS = [
     ["F", "R", "D"], // 2 R
     ["L", "D", "R"], // 3 B
 ];
+const EDGE_CELLS = buildCells(EDGE_POSITION_SLOTS, EDGE_PIECE_STICKERS, 6, 2);
+const CENTER_CELLS = buildCells(CENTER_POSITION_SLOTS, CENTER_PIECE_STICKERS, 4, 3);
+const TIP_CELLS = buildCells(TIP_POSITION_SLOTS, TIP_PIECE_STICKERS, 4, 3);
+function buildCells(slots, stickersTable, pieceCount, orientationCount) {
+    const cells = [];
+    for (let position = 0; position < slots.length; position += 1) {
+        const byPiece = [];
+        for (let piece = 0; piece < pieceCount; piece += 1) {
+            const byOrientation = [];
+            for (let orientation = 0; orientation < orientationCount; orientation += 1) {
+                const stickers = stickersTable[piece];
+                const slotList = slots[position];
+                const cell = [];
+                for (let index = 0; index < slotList.length; index += 1) {
+                    const [face, stickerIndex] = slotList[index];
+                    cell.push(FACE_ORDER.indexOf(face));
+                    cell.push(stickerIndex);
+                    cell.push(COLOR_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
 export function createSolvedPyraminxFacelets() {
     return {
         F: Array.from({ length: 9 }, () => "F"),
@@ -56,36 +85,33 @@ export function createSolvedPyraminxFacelets() {
         D: Array.from({ length: 9 }, () => "D"),
     };
 }
+// Sparse arrays: every one of the 36 sticker cells is overwritten by the
+// three placement loops below (12 edges + 12 centers + 12 tips), so no fill
+// is needed. Coverage is enforced by test/pyraminx-facelets.test.ts.
 function createEmptyPyraminxFacelets() {
     return {
-        F: Array(9).fill("?"),
-        L: Array(9).fill("?"),
-        R: Array(9).fill("?"),
-        D: Array(9).fill("?"),
+        F: Array(9),
+        L: Array(9),
+        R: Array(9),
+        D: Array(9),
     };
 }
-function placeOrientedStickers(facelets, slots, stickers, orientation) {
-    for (let index = 0; index < slots.length; index += 1) {
-        const [face, stickerIndex] = slots[index];
-        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
-        const arr = facelets[face];
-        arr[stickerIndex] = sticker;
+function placeCells(faces, cells) {
+    for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+        faces[cells[cellIndex]][cells[cellIndex + 1]] = COLORS[cells[cellIndex + 2]];
     }
 }
 export function toPyraminxFacelets(state) {
     const facelets = createEmptyPyraminxFacelets();
+    const faces = [facelets.F, facelets.L, facelets.R, facelets.D];
     for (let position = 0; position < 6; position += 1) {
-        const piece = state.edgesPerm[position];
-        const orientation = state.edgesOrient[position];
-        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+        placeCells(faces, EDGE_CELLS[position][state.edgesPerm[position]][state.edgesOrient[position]]);
     }
     for (let position = 0; position < 4; position += 1) {
-        const orientation = state.centers[position];
-        placeOrientedStickers(facelets, CENTER_POSITION_SLOTS[position], CENTER_PIECE_STICKERS[position], orientation);
+        placeCells(faces, CENTER_CELLS[position][position][state.centers[position]]);
     }
     for (let position = 0; position < 4; position += 1) {
-        const orientation = state.tips[position];
-        placeOrientedStickers(facelets, TIP_POSITION_SLOTS[position], TIP_PIECE_STICKERS[position], orientation);
+        placeCells(faces, TIP_CELLS[position][position][state.tips[position]]);
     }
     return facelets;
 }

package/dist/puzzles/pyraminx/random-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG5E,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAYnG"}
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA2B5E,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAenG"}