@cubingcenter/scrambler 0.6.3 → 0.7.0

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

@@ -261,6 +261,12 @@ export let CENTERS_TABLE = null;
 export let PERMUTATION_TABLE = null;
 export let ORIENTATION_TABLE = null;
 export let POLICY_TABLE = null;
+/**
+ * Byte-expanded policy (one optimal move per state, no bit-unpacking in
+ * the hot walk). Built at load from the 3-bit packed table: +0.9 MB RAM,
+ * zero wire/format change.
+ */
+export let POLICY_TABLE_EXPANDED = null;
 export async function ensureTablesLoaded() {
     if (tablesLoaded)
         return;
@@ -269,8 +275,18 @@ export async function ensureTablesLoaded() {
     PERMUTATION_TABLE = tables.permutationTable;
     ORIENTATION_TABLE = tables.orientationTable;
     POLICY_TABLE = tables.policyTable;
+    POLICY_TABLE_EXPANDED = expandPolicy3Bit(tables.policyTable, STATE_COUNT);
     tablesLoaded = true;
 }
+function expandPolicy3Bit(packed, count) {
+    const expanded = new Uint8Array(count);
+    for (let index = 0; index < count; index += 1) {
+        const bits = index * 3;
+        const byteIndex = bits >> 3;
+        expanded[index] = (((packed[byteIndex] | ((packed[byteIndex + 1] ?? 0) << 8)) >> (bits & 7)) & 0x07);
+    }
+    return expanded;
+}
 export function arePyraminxTablesLoaded() {
     return tablesLoaded;
 }
@@ -300,4 +316,5 @@ export function resetTablesForTests() {
     PERMUTATION_TABLE = null;
     ORIENTATION_TABLE = null;
     POLICY_TABLE = null;
+    POLICY_TABLE_EXPANDED = null;
 }

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

@@ -1,4 +1,4 @@
-import { ensureTablesLoaded, getCenterIndex, getOrientationIndex, getPerm7Index, getPolicyMoveFromPacked, MOVE_COUNT, PERMUTATION_TABLE, ORIENTATION_TABLE, CENTERS_TABLE, POLICY_TABLE, rankFromComponents, SKEWB_MOVES, SOLVED_RANK } from "./tables.js";
+import { ensureTablesLoaded, getCenterIndex, getOrientationIndex, getPerm7Index, MOVE_COUNT, PERMUTATION_TABLE, ORIENTATION_TABLE, CENTERS_TABLE, POLICY_TABLE, POLICY_TABLE_EXPANDED, rankFromComponents, SKEWB_MOVES, SOLVED_RANK } from "./tables.js";
 export async function solveSkewb(state) {
     await ensureTablesLoaded();
     return solveWithTables(state).moves;
@@ -33,7 +33,7 @@ function solveWithTables(state) {
     return { moves, depth: moves.length };
 }
 function solveWithTablesIndices(state) {
-    const policy = POLICY_TABLE;
+    const policy = POLICY_TABLE_EXPANDED;
     const permTable = PERMUTATION_TABLE;
     const orientTable = ORIENTATION_TABLE;
     const centersTable = CENTERS_TABLE;
@@ -50,7 +50,7 @@ function solveWithTablesIndices(state) {
     }
     const moves = [];
     while (rank !== SOLVED_RANK) {
-        const m = getPolicyMoveFromPacked(policy, rank);
+        const m = policy[rank];
         moves.push(m);
         r7 = permTable[r7 * MOVE_COUNT + m];
         rO = orientTable[rO * MOVE_COUNT + m];

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

@@ -23,6 +23,12 @@ export declare let PERMUTATION_TABLE: Uint16Array | null;
 export declare let ORIENTATION_TABLE: Uint16Array | null;
 export declare let CENTERS_TABLE: Uint16Array | null;
 export declare let POLICY_TABLE: Uint8Array | null;
+/**
+ * Byte-expanded policy (one optimal move per rank, no bit-unpacking in
+ * the hot walk). Built at load from the 3-bit packed table: +3.1 MB RAM,
+ * zero wire/format change.
+ */
+export declare let POLICY_TABLE_EXPANDED: Uint8Array | null;
 export declare let EVEN_CENTER_RANK: Uint16Array | null;
 export declare let EVEN_CENTER_FULL: Uint16Array | null;
 export declare let ORIENT_CLASS: Uint8Array | null;

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

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/tables.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/tables.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAazD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAanE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAY1E;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAOrE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWjE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAE1D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAOvD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAY3D;AAYD,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,WAAW,QAAuD,CAAC;AAChF,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AAEtE,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAAiD,CAAC;AAE9F,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAa7D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAYzD;AAOD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,aAAa,EAAE,WAAW,GAAG,IAAW,CAAC;AACpD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAClD;;;;GAIG;AACH,eAAO,IAAI,qBAAqB,EAAE,UAAU,GAAG,IAAW,CAAC;AAC3D,eAAO,IAAI,gBAAgB,EAAE,WAAW,GAAG,IAAW,CAAC;AACvD,eAAO,IAAI,gBAAgB,EAAE,WAAW,GAAG,IAAW,CAAC;AACvD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAClD,eAAO,IAAI,OAAO,EAAE,WAAW,GAAG,IAAW,CAAC;AAC9C,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAClD,eAAO,IAAI,aAAa,EAAE,UAAU,GAAG,IAAW,CAAC;AACnD,eAAO,IAAI,aAAa,EAAE,UAAU,GAAG,IAAW,CAAC;AACnD,eAAO,IAAI,WAAW,QAAI,CAAC;AAE3B,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAIxD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE;IACnC,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,UAAU,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;CACrB,GAAG,IAAI,CA+BP;AAYD,wBAAgB,mBAAmB,IAAI,IAAI,CAc1C;AAMD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAc7E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAWtD;AAID,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAuBzD;AAGD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAMrF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAK9E;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAK5E;AAMD,wBAAgB,wBAAwB,IAAI,WAAW,CActD;AAED,wBAAgB,wBAAwB,IAAI,WAAW,CActD;AAED,wBAAgB,oBAAoB,IAAI,WAAW,CAclD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQjE;AAED,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,WAAW,CAAC;IAC5B,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;IACpB,cAAc,EAAE,WAAW,CAAC;CAC7B;AAMD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,WAAW,EACtB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,WAAW,GACxB,iBAAiB,CAwFnB;AAKD,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,WAAW,EACtB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,WAAW,EACzB,OAAO,EAAE,iBAAiB,GACzB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiE1C;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAO1D"}

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

@@ -143,6 +143,12 @@ export let PERMUTATION_TABLE = null; // r7 * MOVE_COUNT + m
 export let ORIENTATION_TABLE = null; // rO * MOVE_COUNT + m
 export let CENTERS_TABLE = null; // rC * MOVE_COUNT + m
 export let POLICY_TABLE = null; // optimal move per rank, 3-bit packed
+/**
+ * Byte-expanded policy (one optimal move per rank, no bit-unpacking in
+ * the hot walk). Built at load from the 3-bit packed table: +3.1 MB RAM,
+ * zero wire/format change.
+ */
+export let POLICY_TABLE_EXPANDED = null;
 export let EVEN_CENTER_RANK = null; // rC -> compact 0..359 (65535 = odd)
 export let EVEN_CENTER_FULL = null; // compact 0..359 -> rC (derived at load)
 export let ORIENT_CLASS = null; // rO -> class 0..8
@@ -192,9 +198,19 @@ export function assignTables(tables) {
         for (let i = 0; i < 7; i++)
             ORIENT_UNRANK[rO * 7 + i] = orient[i + 1];
     }
+    POLICY_TABLE_EXPANDED = expandPolicy3Bit(tables.policyTable, STATE_COUNT);
     SOLVED_RANK = rankFromComponents(0, 0, 0);
     tablesLoaded = true;
 }
+function expandPolicy3Bit(packed, count) {
+    const expanded = new Uint8Array(count);
+    for (let index = 0; index < count; index += 1) {
+        const bits = index * 3;
+        const byteIndex = bits >> 3;
+        expanded[index] = (((packed[byteIndex] | ((packed[byteIndex + 1] ?? 0) << 8)) >> (bits & 7)) & 0x07);
+    }
+    return expanded;
+}
 export function resetTablesForTests() {
     tablesLoaded = false;
     PERMUTATION_TABLE = null;
@@ -208,6 +224,7 @@ export function resetTablesForTests() {
     PERM7_UNRANK = null;
     CENTER_UNRANK = null;
     ORIENT_UNRANK = null;
+    POLICY_TABLE_EXPANDED = null;
 }
 // ---------------------------------------------------------------------------
 // Compact rank helpers

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

@@ -37,7 +37,7 @@ function solveWithTablesIndices(state) {
     }
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
-    const policy = tables_js_1.POLICY_TABLE;
+    const policy = tables_js_1.POLICY_TABLE_EXPANDED;
     let permIndex = (0, tables_js_1.encodePermutation)(state.corners.permutation);
     let orientIndex = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
     const moves = [];
@@ -45,7 +45,7 @@ function solveWithTablesIndices(state) {
     // candidate scanning (the old BFS-distance gradient walk) is needed.
     let combined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
     while (combined !== 0) {
-        const m = (policy[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        const m = policy[combined];
         moves.push(m);
         permIndex = permTable[permIndex * tables_js_1.MOVE_COUNT + m];
         orientIndex = orientTable[orientIndex * tables_js_1.MOVE_COUNT + m];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BFS_MOVES = exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
+exports.BFS_MOVES = exports.POLICY_TABLE_EXPANDED = exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
 exports.encodePermutation = encodePermutation;
 exports.encodeOrientation = encodeOrientation;
 exports.ensureTablesLoaded = ensureTablesLoaded;
@@ -64,6 +64,12 @@ let tablesLoaded = false;
 exports.PERMUTATION_TABLE = null;
 exports.ORIENTATION_TABLE = null;
 exports.POLICY_TABLE = null;
+/**
+ * Byte-expanded policy (one optimal move per state, no bit-unpacking in
+ * the hot walk). Built at load from the packed table: +3.7 MB RAM,
+ * zero wire/format change.
+ */
+exports.POLICY_TABLE_EXPANDED = null;
 async function ensureTablesLoaded() {
     if (tablesLoaded) {
         return;
@@ -72,8 +78,16 @@ async function ensureTablesLoaded() {
     exports.PERMUTATION_TABLE = tables.permutationTable;
     exports.ORIENTATION_TABLE = tables.orientationTable;
     exports.POLICY_TABLE = tables.policyTable;
+    exports.POLICY_TABLE_EXPANDED = expandNibblePolicy(tables.policyTable, exports.PERMUTATION_COUNT * exports.ORIENTATION_COUNT);
     tablesLoaded = true;
 }
+function expandNibblePolicy(packed, count) {
+    const expanded = new Uint8Array(count);
+    for (let index = 0; index < count; index += 1) {
+        expanded[index] = (packed[index >> 1] >> ((index & 1) << 2)) & 0x0f;
+    }
+    return expanded;
+}
 function areCube2TablesLoaded() {
     return tablesLoaded;
 }
@@ -81,7 +95,7 @@ function areCube2TablesLoaded() {
 // Public API
 // ---------------------------------------------------------------------------
 function getDistance(permIndex, orientIndex) {
-    if (!exports.POLICY_TABLE) {
+    if (!exports.POLICY_TABLE_EXPANDED) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
     const permTable = exports.PERMUTATION_TABLE;
@@ -91,7 +105,7 @@ function getDistance(permIndex, orientIndex) {
     let combined = p * exports.ORIENTATION_COUNT + o;
     let distance = 0;
     while (combined !== 0) {
-        const m = (exports.POLICY_TABLE[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        const m = exports.POLICY_TABLE_EXPANDED[combined];
         p = permTable[p * exports.MOVE_COUNT + m];
         o = orientTable[o * exports.MOVE_COUNT + m];
         combined = p * exports.ORIENTATION_COUNT + o;

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

@@ -35,16 +35,114 @@ const FACE_MOVE_TABLES = {
         edges: { permutation: [0, 1, 2, 11, 4, 5, 6, 10, 8, 9, 3, 7], orientation: [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1] }
     }
 };
-function applyCube3Move(state, move) {
+function quarterEffect(face) {
+    const table = FACE_MOVE_TABLES[face];
+    return {
+        cornerPermutation: table.corners.permutation,
+        cornerOrientation: table.corners.orientation,
+        edgePermutation: table.edges.permutation,
+        edgeOrientation: table.edges.orientation
+    };
+}
+// Compose two effects (apply `first`, then `second`) into one so a move of
+// any suffix costs exactly one pass over the state — no per-quarter-turn
+// cloning, no intermediate states, no closure allocations.
+function composeEffects(first, second) {
+    const cornerPermutation = new Array(8);
+    const cornerOrientation = new Array(8);
+    const edgePermutation = new Array(12);
+    const edgeOrientation = new Array(12);
+    for (let i = 0; i < 8; i++) {
+        const source = second.cornerPermutation[i];
+        cornerPermutation[i] = first.cornerPermutation[source];
+        cornerOrientation[i] = (first.cornerOrientation[source] + second.cornerOrientation[i]) % 3;
+    }
+    for (let i = 0; i < 12; i++) {
+        const source = second.edgePermutation[i];
+        edgePermutation[i] = first.edgePermutation[source];
+        edgeOrientation[i] = (first.edgeOrientation[source] + second.edgeOrientation[i]) % 2;
+    }
+    return { cornerPermutation, cornerOrientation, edgePermutation, edgeOrientation };
+}
+function powerEffect(face, turns) {
+    const quarter = quarterEffect(face);
+    if (turns === 1)
+        return quarter;
+    const half = composeEffects(quarter, quarter);
+    if (turns === 2)
+        return half;
+    return composeEffects(half, quarter);
+}
+// Total effect per move string, built once at module load (mirrors the 4x4
+// fast path): one lookup + one pass per move.
+const COMPOSED_EFFECTS = Object.fromEntries(types_js_1.CUBE3_MOVES.map((move) => {
+    const face = move[0];
+    const suffix = move.slice(1);
+    const turns = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    return [move, powerEffect(face, turns)];
+}));
+function effectForMove(move) {
+    const hit = COMPOSED_EFFECTS[move];
+    if (hit !== undefined)
+        return hit;
     const { face, turns } = parseMoveParts(move);
-    let next = (0, state_js_1.cloneCube3State)(state);
-    for (let index = 0; index < turns; index += 1) {
-        next = applyFaceMove(next, FACE_MOVE_TABLES[face]);
+    return powerEffect(face, turns);
+}
+function applyCube3Move(state, move) {
+    const effect = effectForMove(move);
+    const cornerPermutation = new Array(8);
+    const cornerOrientation = new Array(8);
+    const edgePermutation = new Array(12);
+    const edgeOrientation = new Array(12);
+    for (let i = 0; i < 8; i++) {
+        const source = effect.cornerPermutation[i];
+        cornerPermutation[i] = state.corners.permutation[source];
+        cornerOrientation[i] =
+            (state.corners.orientation[source] + effect.cornerOrientation[i]) % 3;
     }
-    return next;
+    for (let i = 0; i < 12; i++) {
+        const source = effect.edgePermutation[i];
+        edgePermutation[i] = state.edges.permutation[source];
+        edgeOrientation[i] =
+            (state.edges.orientation[source] + effect.edgeOrientation[i]) % 2;
+    }
+    return {
+        corners: { permutation: cornerPermutation, orientation: cornerOrientation },
+        edges: { permutation: edgePermutation, orientation: edgeOrientation }
+    };
 }
 function applyCube3Algorithm(state, moves) {
-    return moves.reduce((current, move) => applyCube3Move(current, move), state);
+    if (moves.length === 0)
+        return (0, state_js_1.cloneCube3State)(state);
+    let curCp = [...state.corners.permutation];
+    let curCo = [...state.corners.orientation];
+    let curEp = [...state.edges.permutation];
+    let curEo = [...state.edges.orientation];
+    let nxtCp = new Array(8);
+    let nxtCo = new Array(8);
+    let nxtEp = new Array(12);
+    let nxtEo = new Array(12);
+    for (const move of moves) {
+        const effect = effectForMove(move);
+        for (let i = 0; i < 8; i++) {
+            const source = effect.cornerPermutation[i];
+            nxtCp[i] = curCp[source];
+            nxtCo[i] = (curCo[source] + effect.cornerOrientation[i]) % 3;
+        }
+        for (let i = 0; i < 12; i++) {
+            const source = effect.edgePermutation[i];
+            nxtEp[i] = curEp[source];
+            nxtEo[i] = (curEo[source] + effect.edgeOrientation[i]) % 2;
+        }
+        [curCp, nxtCp] = [nxtCp, curCp];
+        [curCo, nxtCo] = [nxtCo, curCo];
+        [curEp, nxtEp] = [nxtEp, curEp];
+        [curEo, nxtEo] = [nxtEo, curEo];
+    }
+    return {
+        corners: { permutation: curCp, orientation: curCo },
+        edges: { permutation: curEp, orientation: curEo }
+    };
 }
 function invertCube3Algorithm(moves) {
     return [...moves].reverse().map(invertCube3Move);
@@ -199,18 +297,6 @@ function invertCube3Move(move) {
     }
     return `${face}${suffix === "'" ? "" : "'"}`;
 }
-function applyFaceMove(state, table) {
-    return {
-        corners: {
-            permutation: table.corners.permutation.map((source) => state.corners.permutation[source]),
-            orientation: table.corners.permutation.map((source, target) => ((state.corners.orientation[source] + table.corners.orientation[target]) % 3))
-        },
-        edges: {
-            permutation: table.edges.permutation.map((source) => state.edges.permutation[source]),
-            orientation: table.edges.permutation.map((source, target) => ((state.edges.orientation[source] + table.edges.orientation[target]) % 2))
-        }
-    };
-}
 function parseMoveParts(move) {
     const face = move[0];
     const suffix = move.slice(1);

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

@@ -22,7 +22,7 @@ exports.cube3ScrambleGenerator = {
 };
 async function generateCube3Scramble(options = {}) {
     const state = (0, random_state_js_1.generateRandomCube3State)(options);
-    const solution = await (0, index_js_1.solveCube3State)(state);
+    const solution = await (0, index_js_1.solveCube3State)(state, options.solver ?? {});
     const scrambleMoves = (0, moves_js_1.invertCube3Algorithm)(solution.moves);
     if (!options.skipValidation) {
         const scrambledState = (0, moves_js_1.applyCube3Algorithm)((0, state_js_1.createSolvedCube3State)(), scrambleMoves);

package/dist-cjs/puzzles/cube3/solver/browser-loader.js

@@ -100,10 +100,14 @@ async function fetchMoveTable(baseUrl, entry) {
     if (buffer.byteLength !== expectedBytes) {
         throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
     }
-    const values = new Int32Array(entry.range * entry.moves.length);
+    const values = new Uint16Array(entry.range * entry.moves.length);
     const view = new DataView(buffer);
     for (let index = 0; index < values.length; index += 1) {
-        values[index] = view.getInt32(index * 4, true);
+        const value = view.getInt32(index * 4, true);
+        if (value < 0 || value > 0xffff) {
+            throw new Error(`Move table value out of range for ${entry.coordinate}: ${value}.`);
+        }
+        values[index] = value;
     }
     return {
         coordinate: entry.coordinate,

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lookupCube3MoveTable = exports.loadCube3SolverTables = exports.loadCube3Phase2Tables = exports.loadCube3Phase1Tables = exports.generateCube3SolverTables = exports.generateCube3PruningTable = exports.generateCube3MoveTable = exports.generateCube3Phase2Tables = exports.generateCube3Phase1Tables = exports.checksum = exports.CUBE3_PHASE2_MOVES = exports.CUBE3_PHASE1_MOVES = exports.CUBE3_SOLVER_TABLE_METADATA = exports.moveCoordinate = exports.encodeUdSlice = exports.encodeUdEdgePermutation = exports.encodeSlicePermutation = exports.encodePermutation = exports.encodeEdgeOrientation = exports.encodeCube3Coordinates = exports.encodeCornerOrientation = exports.encodeCube3Coordinate = exports.decodeUdSlice = exports.decodeUdEdgePermutation = exports.decodeSlicePermutation = exports.decodePermutation = exports.decodeEdgeOrientation = exports.decodeCornerOrientation = exports.createRepresentativeStateForCoordinate = exports.CUBE3_COORDINATE_RANGES = exports.Cube3Phase1SearchError = exports.solveCube3Phase1 = exports.isCube3Phase1Solved = exports.encodeCube3Phase1Coordinates = exports.applyCube3Phase1Moves = exports.Cube3Phase2SearchError = exports.solveCube3State = exports.solveCube3Phase2 = exports.isCube3Phase2Solved = exports.encodeCube3Phase2Coordinates = exports.applyCube3Phase2Moves = void 0;
+exports.lookupCube3MoveTable = exports.loadCube3SolverTables = exports.loadCube3Phase2Tables = exports.loadCube3Phase1Tables = exports.generateCube3SolverTables = exports.generateCube3PruningTable = exports.generateCube3MoveTable = exports.generateCube3Phase2Tables = exports.generateCube3Phase1Tables = exports.checksum = exports.CUBE3_PHASE2_MOVES = exports.CUBE3_PHASE1_MOVES = exports.CUBE3_SOLVER_TABLE_METADATA = exports.moveCoordinate = exports.encodeUdSlice = exports.encodeUdEdgePermutation = exports.encodeSlicePermutation = exports.encodePermutation = exports.encodeEdgeOrientation = exports.encodeCube3Coordinates = exports.encodeCornerOrientation = exports.encodeCube3Coordinate = exports.decodeUdSlice = exports.decodeUdEdgePermutation = exports.decodeSlicePermutation = exports.decodePermutation = exports.decodeEdgeOrientation = exports.decodeCornerOrientation = exports.createRepresentativeStateForCoordinate = exports.CUBE3_COORDINATE_RANGES = exports.rotateCube3AlgorithmBySequence = exports.rotateCube3Algorithm = exports.invertCube3RotationSequence = exports.CUBE3_ROTATION_INVERSE = exports.CUBE3_ORIENTATIONS_24 = exports.Cube3Phase1SearchError = exports.solveCube3Phase1 = exports.isCube3Phase1Solved = exports.encodeCube3Phase1Coordinates = exports.collectCube3Phase1Solutions = exports.applyCube3Phase1Moves = exports.Cube3Phase2SearchError = exports.solveCube3State = exports.solveCube3Phase2 = exports.isCube3Phase2Solved = exports.encodeCube3Phase2Coordinates = exports.applyCube3Phase2Moves = void 0;
 var phase2_js_1 = require("./phase2.js");
 Object.defineProperty(exports, "applyCube3Phase2Moves", { enumerable: true, get: function () { return phase2_js_1.applyCube3Phase2Moves; } });
 Object.defineProperty(exports, "encodeCube3Phase2Coordinates", { enumerable: true, get: function () { return phase2_js_1.encodeCube3Phase2Coordinates; } });
@@ -10,10 +10,17 @@ Object.defineProperty(exports, "solveCube3State", { enumerable: true, get: funct
 Object.defineProperty(exports, "Cube3Phase2SearchError", { enumerable: true, get: function () { return phase2_js_1.Cube3Phase2SearchError; } });
 var phase1_js_1 = require("./phase1.js");
 Object.defineProperty(exports, "applyCube3Phase1Moves", { enumerable: true, get: function () { return phase1_js_1.applyCube3Phase1Moves; } });
+Object.defineProperty(exports, "collectCube3Phase1Solutions", { enumerable: true, get: function () { return phase1_js_1.collectCube3Phase1Solutions; } });
 Object.defineProperty(exports, "encodeCube3Phase1Coordinates", { enumerable: true, get: function () { return phase1_js_1.encodeCube3Phase1Coordinates; } });
 Object.defineProperty(exports, "isCube3Phase1Solved", { enumerable: true, get: function () { return phase1_js_1.isCube3Phase1Solved; } });
 Object.defineProperty(exports, "solveCube3Phase1", { enumerable: true, get: function () { return phase1_js_1.solveCube3Phase1; } });
 Object.defineProperty(exports, "Cube3Phase1SearchError", { enumerable: true, get: function () { return phase1_js_1.Cube3Phase1SearchError; } });
+var symmetry_js_1 = require("./symmetry.js");
+Object.defineProperty(exports, "CUBE3_ORIENTATIONS_24", { enumerable: true, get: function () { return symmetry_js_1.CUBE3_ORIENTATIONS_24; } });
+Object.defineProperty(exports, "CUBE3_ROTATION_INVERSE", { enumerable: true, get: function () { return symmetry_js_1.CUBE3_ROTATION_INVERSE; } });
+Object.defineProperty(exports, "invertCube3RotationSequence", { enumerable: true, get: function () { return symmetry_js_1.invertCube3RotationSequence; } });
+Object.defineProperty(exports, "rotateCube3Algorithm", { enumerable: true, get: function () { return symmetry_js_1.rotateCube3Algorithm; } });
+Object.defineProperty(exports, "rotateCube3AlgorithmBySequence", { enumerable: true, get: function () { return symmetry_js_1.rotateCube3AlgorithmBySequence; } });
 var coordinates_js_1 = require("./coordinates.js");
 Object.defineProperty(exports, "CUBE3_COORDINATE_RANGES", { enumerable: true, get: function () { return coordinates_js_1.CUBE3_COORDINATE_RANGES; } });
 Object.defineProperty(exports, "createRepresentativeStateForCoordinate", { enumerable: true, get: function () { return coordinates_js_1.createRepresentativeStateForCoordinate; } });

package/dist-cjs/puzzles/cube3/solver/node-loader.js

@@ -71,9 +71,16 @@ function readMoveTable(assetDirectory, entry) {
     if (buffer.length !== expectedBytes) {
         throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
     }
-    const values = new Int32Array(entry.range * entry.moves.length);
+    // Every coordinate fits in 16 bits (max range 40320): store half the
+    // bytes the int32 wire format uses. Checksums are order-sensitive FNV
+    // over the same numeric sequence, so they still match the manifest.
+    const values = new Uint16Array(entry.range * entry.moves.length);
     for (let index = 0; index < values.length; index += 1) {
-        values[index] = buffer.readInt32LE(index * 4);
+        const value = buffer.readInt32LE(index * 4);
+        if (value < 0 || value > 0xffff) {
+            throw new Error(`Move table value out of range for ${entry.coordinate}: ${value}.`);
+        }
+        values[index] = value;
     }
     const table = {
         coordinate: entry.coordinate,

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

@@ -5,6 +5,7 @@ exports.solveCube3Phase1 = solveCube3Phase1;
 exports.encodeCube3Phase1Coordinates = encodeCube3Phase1Coordinates;
 exports.isCube3Phase1Solved = isCube3Phase1Solved;
 exports.applyCube3Phase1Moves = applyCube3Phase1Moves;
+exports.collectCube3Phase1Solutions = collectCube3Phase1Solutions;
 const moves_js_1 = require("../moves.js");
 const coordinates_js_1 = require("./coordinates.js");
 const tables_js_1 = require("./tables.js");
@@ -36,14 +37,7 @@ async function solveCube3Phase1(state, options = {}) {
     const maxDepth = options.maxDepth ?? 12;
     const start = encodeCube3Phase1Coordinates(state);
     const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
-    const context = {
-        tables,
-        jointTables,
-        maxDepth,
-        deadline,
-        visitedNodes: 0,
-        timedOut: false
-    };
+    const context = createPhase1SearchContext(tables, jointTables, maxDepth, deadline);
     if (await isCube3Phase1Solved(start, tables)) {
         return {
             moves: [],
@@ -124,6 +118,66 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
             edgeOrientation === 0 &&
             udSlice === context.tables.moveTables.udSlice.solvedCoordinate;
     }
+    const moveCount = context.tables.phase1Moves.length;
+    const childCount = collectPhase1Children(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, context);
+    const slot = remainingDepth * moveCount;
+    const scratchMove = context.scratchMove;
+    const scratchCo = context.scratchCo;
+    const scratchEo = context.scratchEo;
+    const scratchUd = context.scratchUd;
+    for (let i = 0; i < childCount; i += 1) {
+        const moveIndex = scratchMove[slot + i];
+        const face = PHASE1_MOVE_FACES[moveIndex];
+        path.push(context.tables.phase1Moves[moveIndex]);
+        if (searchPhase1(scratchCo[slot + i], scratchEo[slot + i], scratchUd[slot + i], face, previousFace, remainingDepth - 1, path, context)) {
+            return true;
+        }
+        path.pop();
+        if (context.timedOut) {
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Enumerates up to `limit` phase-1 solutions of exactly `depth` moves for
+ * the given state, most promising first (same ordered DFS as the search).
+ * Used to try several G1 landing states and keep the best phase-1+phase-2
+ * total — a slightly longer phase 1 often collapses phase 2.
+ */
+async function collectCube3Phase1Solutions(state, depth, options = {}) {
+    const tables = options.tables ?? await (0, tables_js_1.loadCube3Phase1Tables)();
+    const jointTables = options.jointTables ?? tables.jointTables;
+    const limit = options.limit ?? 32;
+    const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
+    const context = createPhase1SearchContext(tables, jointTables, depth, deadline);
+    const start = encodeCube3Phase1Coordinates(state);
+    const solutions = [];
+    searchPhase1Collect(start.cornerOrientation, start.edgeOrientation, start.udSlice, -1, -1, depth, [], solutions, limit, context);
+    return { solutions, visitedNodes: context.visitedNodes };
+}
+function createPhase1SearchContext(tables, jointTables, maxDepth, deadline) {
+    const scratchLevels = maxDepth + 1;
+    const scratchSize = scratchLevels * tables_js_1.CUBE3_PHASE1_MOVES.length;
+    return {
+        tables,
+        jointTables,
+        maxDepth,
+        deadline,
+        visitedNodes: 0,
+        timedOut: false,
+        scratchMove: new Int32Array(scratchSize),
+        scratchBound: new Int32Array(scratchSize),
+        scratchCo: new Int32Array(scratchSize),
+        scratchEo: new Int32Array(scratchSize),
+        scratchUd: new Int32Array(scratchSize)
+    };
+}
+/**
+ * Fills the scratch slot for `remainingDepth` with the surviving children
+ * in ascending lower-bound order (stable). Returns the child count.
+ */
+function collectPhase1Children(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, context) {
     const moveCount = context.tables.phase1Moves.length;
     const validMoves = PHASE1_VALID_MOVES[previousFace + 1][previousPreviousFace + 1];
     const coTable = context.tables.moveTables.cornerOrientation.values;
@@ -131,9 +185,17 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
     const udTable = context.tables.moveTables.udSlice.values;
     const coeoTable = context.tables.pruningTables.cornerOrientationEdgeOrientation.values;
     const udPruningTable = context.tables.pruningTables.udSlice.values;
+    const jointTables = context.jointTables;
     const coOffset = cornerOrientation * moveCount;
     const eoOffset = edgeOrientation * moveCount;
     const udOffset = udSlice * moveCount;
+    const slot = remainingDepth * moveCount;
+    const scratchMove = context.scratchMove;
+    const scratchBound = context.scratchBound;
+    const scratchCo = context.scratchCo;
+    const scratchEo = context.scratchEo;
+    const scratchUd = context.scratchUd;
+    let childCount = 0;
     for (let i = 0; i < validMoves.length; i += 1) {
         const moveIndex = validMoves[i];
         const nextCornerOrientation = coTable[coOffset + moveIndex];
@@ -146,7 +208,6 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
         if (nextLowerBound > remainingDepth - 1) {
             continue;
         }
-        const jointTables = context.jointTables;
         if (jointTables) {
             const udCoIndex = nextUdSlice * 2187 + nextCornerOrientation;
             const jc = (jointTables.jointUdCo[udCoIndex >> 1] >> ((udCoIndex & 1) << 2)) & 0x0f;
@@ -162,14 +223,72 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
                 continue;
             }
         }
+        scratchMove[slot + childCount] = moveIndex;
+        scratchBound[slot + childCount] = nextLowerBound;
+        scratchCo[slot + childCount] = nextCornerOrientation;
+        scratchEo[slot + childCount] = nextEdgeOrientation;
+        scratchUd[slot + childCount] = nextUdSlice;
+        childCount += 1;
+    }
+    // Stable insertion sort by bound (n <= 18; ties keep reference order).
+    for (let i = 1; i < childCount; i += 1) {
+        const move = scratchMove[slot + i];
+        const bound = scratchBound[slot + i];
+        const co = scratchCo[slot + i];
+        const eo = scratchEo[slot + i];
+        const ud = scratchUd[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];
+            scratchCo[slot + j + 1] = scratchCo[slot + j];
+            scratchEo[slot + j + 1] = scratchEo[slot + j];
+            scratchUd[slot + j + 1] = scratchUd[slot + j];
+            j -= 1;
+        }
+        scratchMove[slot + j + 1] = move;
+        scratchBound[slot + j + 1] = bound;
+        scratchCo[slot + j + 1] = co;
+        scratchEo[slot + j + 1] = eo;
+        scratchUd[slot + j + 1] = ud;
+    }
+    return childCount;
+}
+/**
+ * Ordered exact-depth DFS that collects solutions instead of stopping at
+ * the first one. Returns true when collection should stop (limit reached
+ * or timed out).
+ */
+function searchPhase1Collect(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, path, solutions, limit, context) {
+    context.visitedNodes += 1;
+    if (context.deadline !== undefined && (context.visitedNodes & 1023) === 0 && performance.now() > context.deadline) {
+        context.timedOut = true;
+        return true;
+    }
+    if (remainingDepth === 0) {
+        if (cornerOrientation === 0 &&
+            edgeOrientation === 0 &&
+            udSlice === context.tables.moveTables.udSlice.solvedCoordinate) {
+            solutions.push([...path]);
+            return solutions.length >= limit;
+        }
+        return false;
+    }
+    const moveCount = context.tables.phase1Moves.length;
+    const childCount = collectPhase1Children(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, context);
+    const slot = remainingDepth * moveCount;
+    const scratchMove = context.scratchMove;
+    const scratchCo = context.scratchCo;
+    const scratchEo = context.scratchEo;
+    const scratchUd = context.scratchUd;
+    for (let i = 0; i < childCount; i += 1) {
+        const moveIndex = scratchMove[slot + i];
         const face = PHASE1_MOVE_FACES[moveIndex];
         path.push(context.tables.phase1Moves[moveIndex]);
-        if (searchPhase1(nextCornerOrientation, nextEdgeOrientation, nextUdSlice, face, previousFace, remainingDepth - 1, path, context)) {
-            return true;
-        }
+        const stop = searchPhase1Collect(scratchCo[slot + i], scratchEo[slot + i], scratchUd[slot + i], face, previousFace, remainingDepth - 1, path, solutions, limit, context);
         path.pop();
-        if (context.timedOut) {
-            return false;
+        if (stop) {
+            return true;
         }
     }
     return false;