@cubingcenter/scrambler 0.4.1 → 0.5.0

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

@@ -0,0 +1,539 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLVED_RANK = exports.CENTER_UNRANK = exports.PERM7_UNRANK = exports.R7_SETS = exports.ORIENT_CLASS = exports.EVEN_CENTER_FULL = exports.EVEN_CENTER_RANK = exports.POLICY_TABLE = exports.CENTERS_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.SKEWB_MOVES = exports.POLICY_PACKED_ENTRIES = exports.STATE_COUNT = exports.MOVE_COUNT = exports.PER_SET_SIZE = exports.ORIENT_CLASS_COUNT = exports.EVEN_CENTER_COUNT = exports.CENTER_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
+exports.getPermutationIndex = getPermutationIndex;
+exports.getPermutationFromIndex = getPermutationFromIndex;
+exports.getOrientationIndex = getOrientationIndex;
+exports.getOrientationFromIndex = getOrientationFromIndex;
+exports.getCenterIndex = getCenterIndex;
+exports.getCenterFromIndex = getCenterFromIndex;
+exports.getStateIndex = getStateIndex;
+exports.getStateFromIndex = getStateFromIndex;
+exports.getPerm7Index = getPerm7Index;
+exports.getPerm7FromIndex = getPerm7FromIndex;
+exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.assignTables = assignTables;
+exports.resetTablesForTests = resetTablesForTests;
+exports.rankFromComponents = rankFromComponents;
+exports.getStateRank = getStateRank;
+exports.getStateFromRank = getStateFromRank;
+exports.getPolicyMoveFromPacked = getPolicyMoveFromPacked;
+exports.getPolicyMove = getPolicyMove;
+exports.getPermutationTransition = getPermutationTransition;
+exports.getOrientationTransition = getOrientationTransition;
+exports.getCentersTransition = getCentersTransition;
+exports.generatePermutationTable = generatePermutationTable;
+exports.generateOrientationTable = generateOrientationTable;
+exports.generateCentersTable = generateCentersTable;
+exports.permutationParity = permutationParity;
+exports.generateHelperTables = generateHelperTables;
+exports.generatePolicyTable = generatePolicyTable;
+exports.checksum = checksum;
+const moves_js_1 = require("../moves.js");
+const generated_assets_js_1 = require("./generated-assets.js");
+// ---------------------------------------------------------------------------
+// Coordinate encoding / decoding (kept from the original solver.ts)
+// ---------------------------------------------------------------------------
+const FACT = [1, 1, 2, 6, 24, 120, 720, 5040, 40320];
+// Popcount lookup (0..255) for the allocation-free Lehmer encoders below.
+const POPCOUNT = new Uint8Array(256);
+for (let i = 1; i < 256; i++)
+    POPCOUNT[i] = POPCOUNT[i >> 1] + (i & 1);
+function getPermutationIndex(perm) {
+    // perm length 8, but pos0 is always 0 for WCA reachable states.
+    // We encode full 8-perm via Lehmer code (0..40319), but for fixed corner it will be in subset.
+    let index = 0;
+    let used = 0;
+    const n = perm.length;
+    for (let i = 0; i < n; i++) {
+        const v = perm[i];
+        const digit = v - POPCOUNT[used & ((1 << v) - 1)];
+        used |= 1 << v;
+        index += digit * FACT[n - 1 - i];
+    }
+    return index;
+}
+function getPermutationFromIndex(index, n) {
+    const perm = Array(n).fill(0);
+    const temp = Array.from({ length: n }, (_, i) => i);
+    let val = index;
+    for (let i = 0; i < n; i++) {
+        const f = FACT[n - 1 - i];
+        const choice = Math.floor(val / f);
+        val %= f;
+        perm[i] = temp[choice];
+        temp.splice(choice, 1);
+    }
+    return perm;
+}
+function getOrientationIndex(orient) {
+    // orient length 8, index 0 is fixed 0, encode remaining 7 base3
+    let index = 0;
+    for (let i = 7; i >= 1; i--) {
+        index = index * 3 + orient[i];
+    }
+    return index;
+}
+function getOrientationFromIndex(index) {
+    const orient = Array(8).fill(0);
+    orient[0] = 0;
+    let val = index;
+    for (let i = 1; i < 8; i++) {
+        orient[i] = val % 3;
+        val = Math.floor(val / 3);
+    }
+    return orient;
+}
+function getCenterIndex(centers) {
+    let index = 0;
+    let used = 0;
+    const n = centers.length;
+    for (let i = 0; i < n; i++) {
+        const v = centers[i];
+        const digit = v - POPCOUNT[used & ((1 << v) - 1)];
+        used |= 1 << v;
+        index += digit * FACT[n - 1 - i];
+    }
+    return index;
+}
+function getCenterFromIndex(index) {
+    return getPermutationFromIndex(index, 6);
+}
+function getStateIndex(state) {
+    const p = getPermutationIndex(state.corners.permutation);
+    const c = getCenterIndex(state.centers);
+    const o = getOrientationIndex(state.corners.orientation);
+    // p in 0..40319, c in 0..719, o in 0..2186
+    // Combine: ((p * 720 + c) * 2187 + o) -> up to 63B fits in JS number (53-bit)
+    return ((p * 720 + c) * 2187 + o);
+}
+function getStateFromIndex(index) {
+    const o = index % 2187;
+    let val = Math.floor(index / 2187);
+    const c = val % 720;
+    const p = Math.floor(val / 720);
+    return {
+        corners: {
+            permutation: getPermutationFromIndex(p, 8),
+            orientation: getOrientationFromIndex(o),
+        },
+        centers: getCenterFromIndex(c),
+    };
+}
+// ---------------------------------------------------------------------------
+// Compact encoding over the WCA-reachable group (3,149,280 states)
+// ---------------------------------------------------------------------------
+// With the UFR corner fixed (position 0, orientation 0), the reachable group
+// factors as:
+//   rC: even center permutations only  -> 360
+//   rO: orientations of corners 1..7   -> 2187, partitioned into 9 classes
+//   r7: corner permutations of 1..7    -> exactly 4 values per (rC, rO-class)
+// so rank = (rC_even * 2187 + rO) * 4 + k is a bijection over the reachable set.
+exports.PERMUTATION_COUNT = 5040; // r7: corners 1..7 Lehmer
+exports.ORIENTATION_COUNT = 2187; // rO: corners 1..7 base-3
+exports.CENTER_COUNT = 720; // rC: centers Lehmer
+exports.EVEN_CENTER_COUNT = 360; // reachable center arrangements
+exports.ORIENT_CLASS_COUNT = 9; // orientation classes
+exports.PER_SET_SIZE = 4; // corner permutations per (rC, rO-class)
+exports.MOVE_COUNT = 8;
+exports.STATE_COUNT = exports.EVEN_CENTER_COUNT * exports.ORIENTATION_COUNT * exports.PER_SET_SIZE; // 3_149_280
+exports.POLICY_PACKED_ENTRIES = Math.ceil((exports.STATE_COUNT * 3) / 8);
+exports.SKEWB_MOVES = ["R", "R'", "U", "U'", "L", "L'", "B", "B'"];
+function getPerm7Index(perm) {
+    // Lehmer rank of the positions 1..7 (values 1..7, offset by -1).
+    // Allocation-free: digit = count of unused values below the current one,
+    // computed with a used-bitmask and a popcount lookup.
+    let index = 0;
+    let used = 0;
+    for (let i = 1; i < 8; i++) {
+        const v = perm[i] - 1;
+        const digit = v - POPCOUNT[used & ((1 << v) - 1)];
+        used |= 1 << v;
+        index += digit * FACT[7 - i];
+    }
+    return index;
+}
+function getPerm7FromIndex(index) {
+    const perm = Array(8).fill(0);
+    const available = [1, 2, 3, 4, 5, 6, 7];
+    let val = index;
+    for (let i = 1; i < 8; i++) {
+        const f = FACT[7 - i];
+        const choice = Math.floor(val / f);
+        val %= f;
+        perm[i] = available[choice];
+        available.splice(choice, 1);
+    }
+    return perm;
+}
+// ---------------------------------------------------------------------------
+// Table loading / runtime state
+// ---------------------------------------------------------------------------
+let tablesLoaded = false;
+exports.PERMUTATION_TABLE = null; // r7 * MOVE_COUNT + m
+exports.ORIENTATION_TABLE = null; // rO * MOVE_COUNT + m
+exports.CENTERS_TABLE = null; // rC * MOVE_COUNT + m
+exports.POLICY_TABLE = null; // optimal move per rank, 3-bit packed
+exports.EVEN_CENTER_RANK = null; // rC -> compact 0..359 (65535 = odd)
+exports.EVEN_CENTER_FULL = null; // compact 0..359 -> rC (derived at load)
+exports.ORIENT_CLASS = null; // rO -> class 0..8
+exports.R7_SETS = null; // (rC_even * 9 + class) * 4 + i
+exports.PERM7_UNRANK = null; // r7 * 7 + i -> piece at corner i+1 (derived at load)
+exports.CENTER_UNRANK = null; // rC * 6 + i -> center piece (derived at load)
+exports.SOLVED_RANK = 0;
+async function ensureTablesLoaded() {
+    if (tablesLoaded)
+        return;
+    const tables = await (0, generated_assets_js_1.loadGeneratedSkewbSolverTables)();
+    assignTables(tables);
+}
+function assignTables(tables) {
+    exports.PERMUTATION_TABLE = tables.permutationTable;
+    exports.ORIENTATION_TABLE = tables.orientationTable;
+    exports.CENTERS_TABLE = tables.centersTable;
+    exports.POLICY_TABLE = tables.policyTable;
+    exports.EVEN_CENTER_RANK = tables.evenCenterRank;
+    exports.ORIENT_CLASS = tables.orientClass;
+    exports.R7_SETS = tables.r7Sets;
+    exports.EVEN_CENTER_FULL = new Uint16Array(exports.EVEN_CENTER_COUNT);
+    for (let rC = 0; rC < exports.CENTER_COUNT; rC++) {
+        const compactIdx = tables.evenCenterRank[rC];
+        if (compactIdx !== 65535)
+            exports.EVEN_CENTER_FULL[compactIdx] = rC;
+    }
+    exports.PERM7_UNRANK = new Uint8Array(exports.PERMUTATION_COUNT * 7);
+    for (let r7 = 0; r7 < exports.PERMUTATION_COUNT; r7++) {
+        const perm = getPerm7FromIndex(r7);
+        for (let i = 0; i < 7; i++)
+            exports.PERM7_UNRANK[r7 * 7 + i] = perm[i + 1];
+    }
+    exports.CENTER_UNRANK = new Uint8Array(exports.CENTER_COUNT * 6);
+    for (let rC = 0; rC < exports.CENTER_COUNT; rC++) {
+        const centers = getCenterFromIndex(rC);
+        for (let i = 0; i < 6; i++)
+            exports.CENTER_UNRANK[rC * 6 + i] = centers[i];
+    }
+    exports.SOLVED_RANK = rankFromComponents(0, 0, 0);
+    tablesLoaded = true;
+}
+function resetTablesForTests() {
+    tablesLoaded = false;
+    exports.PERMUTATION_TABLE = null;
+    exports.ORIENTATION_TABLE = null;
+    exports.CENTERS_TABLE = null;
+    exports.POLICY_TABLE = null;
+    exports.EVEN_CENTER_RANK = null;
+    exports.EVEN_CENTER_FULL = null;
+    exports.ORIENT_CLASS = null;
+    exports.R7_SETS = null;
+    exports.PERM7_UNRANK = null;
+    exports.CENTER_UNRANK = null;
+}
+// ---------------------------------------------------------------------------
+// Compact rank helpers
+// ---------------------------------------------------------------------------
+function rankFromComponents(r7, rO, rC) {
+    const evenRank = exports.EVEN_CENTER_RANK[rC];
+    if (evenRank === 65535) {
+        throw new Error("Unreachable Skewb state: odd center permutation parity.");
+    }
+    const cls = exports.ORIENT_CLASS[rO];
+    const set = exports.R7_SETS;
+    const base = (evenRank * exports.ORIENT_CLASS_COUNT + cls) * exports.PER_SET_SIZE;
+    for (let i = 0; i < exports.PER_SET_SIZE; i++) {
+        if (set[base + i] === r7) {
+            return (evenRank * exports.ORIENTATION_COUNT + rO) * exports.PER_SET_SIZE + i;
+        }
+    }
+    throw new Error("Unreachable Skewb state: corner permutation not in reachable set.");
+}
+function getStateRank(state) {
+    if (state.corners.permutation[0] !== 0) {
+        throw new Error("The Skewb solver requires the UFR corner (index 0) to be fixed " +
+            "as the frame of reference. Please normalize the state before solving.");
+    }
+    const r7 = getPerm7Index(state.corners.permutation);
+    const rO = getOrientationIndex(state.corners.orientation);
+    const rC = getCenterIndex(state.centers);
+    return rankFromComponents(r7, rO, rC);
+}
+// Inverse of getStateRank: decodes a reachable rank (0..3_149_279) back into
+// a full state. Used for exact uniform random-state sampling.
+function getStateFromRank(rank) {
+    const even = Math.floor(rank / (exports.ORIENTATION_COUNT * exports.PER_SET_SIZE));
+    const rest = rank % (exports.ORIENTATION_COUNT * exports.PER_SET_SIZE);
+    const rO = Math.floor(rest / exports.PER_SET_SIZE);
+    const k = rest % exports.PER_SET_SIZE;
+    const cls = exports.ORIENT_CLASS[rO];
+    const r7 = exports.R7_SETS[(even * exports.ORIENT_CLASS_COUNT + cls) * exports.PER_SET_SIZE + k];
+    const perm = new Array(8);
+    perm[0] = 0;
+    const permBase = r7 * 7;
+    for (let i = 0; i < 7; i++)
+        perm[i + 1] = exports.PERM7_UNRANK[permBase + i];
+    const orient = new Array(8);
+    orient[0] = 0;
+    let val = rO;
+    for (let i = 1; i < 8; i++) {
+        orient[i] = val % 3;
+        val = Math.floor(val / 3);
+    }
+    const centers = new Array(6);
+    const centerBase = exports.EVEN_CENTER_FULL[even] * 6;
+    for (let i = 0; i < 6; i++)
+        centers[i] = exports.CENTER_UNRANK[centerBase + i];
+    return { corners: { permutation: perm, orientation: orient }, centers };
+}
+// 3-bit little-endian unpacking of the packed policy table.
+function getPolicyMoveFromPacked(packed, stateRank) {
+    const bits = stateRank * 3;
+    const byteIndex = bits >> 3;
+    const offset = bits & 7;
+    const word = (packed[byteIndex] | ((packed[byteIndex + 1] ?? 0) << 8)) >> offset;
+    return word & 0x07;
+}
+function getPolicyMove(stateRank) {
+    if (!exports.POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return getPolicyMoveFromPacked(exports.POLICY_TABLE, stateRank);
+}
+function getPermutationTransition(permIdx, move) {
+    if (!exports.PERMUTATION_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return exports.PERMUTATION_TABLE[permIdx * exports.MOVE_COUNT + move];
+}
+function getOrientationTransition(orientIdx, move) {
+    if (!exports.ORIENTATION_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return exports.ORIENTATION_TABLE[orientIdx * exports.MOVE_COUNT + move];
+}
+function getCentersTransition(centerIdx, move) {
+    if (!exports.CENTERS_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return exports.CENTERS_TABLE[centerIdx * exports.MOVE_COUNT + move];
+}
+// ---------------------------------------------------------------------------
+// Table generation (used by the generate script)
+// ---------------------------------------------------------------------------
+function generatePermutationTable() {
+    const table = new Uint16Array(exports.PERMUTATION_COUNT * exports.MOVE_COUNT);
+    for (let r7 = 0; r7 < exports.PERMUTATION_COUNT; r7++) {
+        const perm = getPerm7FromIndex(r7);
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const state = {
+                corners: { permutation: [...perm], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+                centers: [0, 1, 2, 3, 4, 5],
+            };
+            const next = (0, moves_js_1.applySkewbMove)(state, exports.SKEWB_MOVES[m]);
+            table[r7 * exports.MOVE_COUNT + m] = getPerm7Index(next.corners.permutation);
+        }
+    }
+    return table;
+}
+function generateOrientationTable() {
+    const table = new Uint16Array(exports.ORIENTATION_COUNT * exports.MOVE_COUNT);
+    for (let rO = 0; rO < exports.ORIENTATION_COUNT; rO++) {
+        const orient = getOrientationFromIndex(rO);
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const state = {
+                corners: { permutation: [0, 1, 2, 3, 4, 5, 6, 7], orientation: [...orient] },
+                centers: [0, 1, 2, 3, 4, 5],
+            };
+            const next = (0, moves_js_1.applySkewbMove)(state, exports.SKEWB_MOVES[m]);
+            table[rO * exports.MOVE_COUNT + m] = getOrientationIndex(next.corners.orientation);
+        }
+    }
+    return table;
+}
+function generateCentersTable() {
+    const table = new Uint16Array(exports.CENTER_COUNT * exports.MOVE_COUNT);
+    for (let rC = 0; rC < exports.CENTER_COUNT; rC++) {
+        const centers = getCenterFromIndex(rC);
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const state = {
+                corners: { permutation: [0, 1, 2, 3, 4, 5, 6, 7], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+                centers: [...centers],
+            };
+            const next = (0, moves_js_1.applySkewbMove)(state, exports.SKEWB_MOVES[m]);
+            table[rC * exports.MOVE_COUNT + m] = getCenterIndex(next.centers);
+        }
+    }
+    return table;
+}
+function permutationParity(perm) {
+    let inversions = 0;
+    for (let i = 0; i < perm.length; i++) {
+        for (let j = i + 1; j < perm.length; j++) {
+            if (perm[i] > perm[j])
+                inversions++;
+        }
+    }
+    return inversions % 2;
+}
+// Discovers the reachable-state structure with a BFS over the full product
+// coordinate (r7, rO, rC) and derives the compact-rank helper tables:
+//   - even center permutations only (360 of 720)
+//   - rO partitioned into 9 classes by the 4-corner-permutation sets
+function generateHelperTables(permTable, orientTable, centersTable) {
+    const evenCenterRank = new Uint16Array(exports.CENTER_COUNT).fill(65535);
+    const evenCenterFull = new Uint16Array(exports.EVEN_CENTER_COUNT);
+    let compact = 0;
+    for (let rC = 0; rC < exports.CENTER_COUNT; rC++) {
+        if (permutationParity(getCenterFromIndex(rC)) === 0) {
+            evenCenterRank[rC] = compact;
+            evenCenterFull[compact] = rC;
+            compact++;
+        }
+    }
+    if (compact !== exports.EVEN_CENTER_COUNT) {
+        throw new Error(`Expected ${exports.EVEN_CENTER_COUNT} even center permutations, found ${compact}.`);
+    }
+    const pack = (r7, rO, rC) => (r7 * exports.ORIENTATION_COUNT + rO) * exports.CENTER_COUNT + rC;
+    const pairSets = new Map();
+    const seen = new Set([0]);
+    const queue = [0];
+    let head = 0;
+    while (head < queue.length) {
+        const cur = queue[head++];
+        const rC = cur % exports.CENTER_COUNT;
+        const rest = Math.floor(cur / exports.CENTER_COUNT);
+        const rO = rest % exports.ORIENTATION_COUNT;
+        const r7 = Math.floor(rest / exports.ORIENTATION_COUNT);
+        const pairKey = rC * exports.ORIENTATION_COUNT + rO;
+        let set = pairSets.get(pairKey);
+        if (!set) {
+            set = new Set();
+            pairSets.set(pairKey, set);
+        }
+        set.add(r7);
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const n7 = permTable[r7 * exports.MOVE_COUNT + m];
+            const nO = orientTable[rO * exports.MOVE_COUNT + m];
+            const nC = centersTable[rC * exports.MOVE_COUNT + m];
+            const next = pack(n7, nO, nC);
+            if (!seen.has(next)) {
+                seen.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    if (seen.size !== exports.STATE_COUNT) {
+        throw new Error(`Reachability BFS covered ${seen.size} states, expected ${exports.STATE_COUNT}.`);
+    }
+    const setKey = (values) => [...values].sort((a, b) => a - b).join(",");
+    // Reference partition from rC = 0 (verified identical for all even rC).
+    const orientClass = new Uint8Array(exports.ORIENTATION_COUNT);
+    const classOfSet = new Map();
+    for (let rO = 0; rO < exports.ORIENTATION_COUNT; rO++) {
+        const set = pairSets.get(rO);
+        const key = setKey(set);
+        if (!classOfSet.has(key)) {
+            classOfSet.set(key, classOfSet.size);
+        }
+        orientClass[rO] = classOfSet.get(key);
+    }
+    if (classOfSet.size !== exports.ORIENT_CLASS_COUNT) {
+        throw new Error(`Expected ${exports.ORIENT_CLASS_COUNT} orientation classes, found ${classOfSet.size}.`);
+    }
+    // Verify the partition is identical for every even rC and that each
+    // (rC, class) has exactly PER_SET_SIZE corner permutations.
+    const r7Sets = new Uint16Array(exports.EVEN_CENTER_COUNT * exports.ORIENT_CLASS_COUNT * exports.PER_SET_SIZE);
+    for (let rC = 0; rC < exports.CENTER_COUNT; rC++) {
+        const rCCompact = evenCenterRank[rC];
+        if (rCCompact === 65535)
+            continue;
+        for (let rO = 0; rO < exports.ORIENTATION_COUNT; rO++) {
+            const set = pairSets.get(rC * exports.ORIENTATION_COUNT + rO);
+            if (set.size !== exports.PER_SET_SIZE) {
+                throw new Error(`Expected ${exports.PER_SET_SIZE} permutations for (rC=${rC}, rO=${rO}), found ${set.size}.`);
+            }
+            const cls = orientClass[rO];
+            if (classOfSet.get(setKey(set)) !== cls) {
+                throw new Error(`Orientation class partition differs at rC=${rC}, rO=${rO}.`);
+            }
+            const stored = [...set].sort((a, b) => a - b);
+            const base = (rCCompact * exports.ORIENT_CLASS_COUNT + cls) * exports.PER_SET_SIZE;
+            for (let i = 0; i < exports.PER_SET_SIZE; i++)
+                r7Sets[base + i] = stored[i];
+        }
+    }
+    return { evenCenterRank, orientClass, r7Sets, evenCenterFull };
+}
+// BFS from solved stores, for each state, the inverse of the move that first
+// discovered it: an optimal move toward solved. Packed 3 bits per state
+// (8 moves; the solved entry is never read, the solve loop exits first).
+function generatePolicyTable(permTable, orientTable, centersTable, helpers) {
+    // Install the compact-rank tables for the duration of the build.
+    const saved = { evenCenterRank: exports.EVEN_CENTER_RANK, orientClass: exports.ORIENT_CLASS, r7Sets: exports.R7_SETS };
+    exports.EVEN_CENTER_RANK = helpers.evenCenterRank;
+    exports.ORIENT_CLASS = helpers.orientClass;
+    exports.R7_SETS = helpers.r7Sets;
+    try {
+        const solvedRank = rankFromComponents(0, 0, 0);
+        const distances = new Uint8Array(exports.STATE_COUNT).fill(255);
+        const policy = new Uint8Array(exports.STATE_COUNT);
+        distances[solvedRank] = 0;
+        const queue = new Uint32Array(exports.STATE_COUNT);
+        let read = 0;
+        let write = 1;
+        queue[0] = solvedRank;
+        let maxDepth = 0;
+        while (read < write) {
+            const curr = queue[read++];
+            const dist = distances[curr];
+            const even = Math.floor(curr / (exports.ORIENTATION_COUNT * exports.PER_SET_SIZE));
+            const rest = curr % (exports.ORIENTATION_COUNT * exports.PER_SET_SIZE);
+            const rO = Math.floor(rest / exports.PER_SET_SIZE);
+            const k = rest % exports.PER_SET_SIZE;
+            const cls = exports.ORIENT_CLASS[rO];
+            const r7 = exports.R7_SETS[(even * exports.ORIENT_CLASS_COUNT + cls) * exports.PER_SET_SIZE + k];
+            const rC = helpers.evenCenterFull[even];
+            const nextDist = dist + 1;
+            for (let m = 0; m < exports.MOVE_COUNT; m++) {
+                const n7 = permTable[r7 * exports.MOVE_COUNT + m];
+                const nO = orientTable[rO * exports.MOVE_COUNT + m];
+                const nC = centersTable[rC * exports.MOVE_COUNT + m];
+                const next = rankFromComponents(n7, nO, nC);
+                if (distances[next] === 255) {
+                    distances[next] = nextDist;
+                    policy[next] = m ^ 1; // inverse move of the discovery edge
+                    if (nextDist > maxDepth)
+                        maxDepth = nextDist;
+                    queue[write++] = next;
+                }
+            }
+        }
+        if (write !== exports.STATE_COUNT) {
+            throw new Error(`Policy BFS covered ${write} states, expected ${exports.STATE_COUNT}.`);
+        }
+        const packed = new Uint8Array(exports.POLICY_PACKED_ENTRIES);
+        for (let i = 0; i < exports.STATE_COUNT; i++) {
+            const bits = i * 3;
+            const byteIndex = bits >> 3;
+            const offset = bits & 7;
+            const value = policy[i] & 0x07;
+            packed[byteIndex] |= (value << offset) & 0xff;
+            if (offset > 5) {
+                packed[byteIndex + 1] |= value >> (8 - offset);
+            }
+        }
+        return { packed, maxDepth };
+    }
+    finally {
+        exports.EVEN_CENTER_RANK = saved.evenCenterRank;
+        exports.ORIENT_CLASS = saved.orientClass;
+        exports.R7_SETS = saved.r7Sets;
+    }
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < values.length; i++) {
+        hash ^= values[i];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

package/dist-cjs/random/prng.js

@@ -9,8 +9,17 @@ function createRandomSource(seed) {
     return new SeededRandomSource(hashSeed(seed));
 }
 class CryptoRandomSource {
+    buffer = null;
+    offset = 0;
     next() {
-        const value = (0, node_crypto_1.randomBytes)(6).readUIntBE(0, 6);
+        // Batch the crypto calls: one randomBytes per move is ~2 orders of
+        // magnitude slower in Node (syscall per call). Refill lazily.
+        if (this.buffer === null || this.offset + 6 > 256) {
+            this.buffer = (0, node_crypto_1.randomBytes)(256);
+            this.offset = 0;
+        }
+        const value = this.buffer.readUIntBE(this.offset, 6);
+        this.offset += 6;
         return value / 0x1000000000000;
     }
     nextInt(maxExclusive) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubingcenter/scrambler",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Extensible scramble generation toolkit for CubingCenter projects.",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "test": "node --test --import tsx test/*.test.ts",
     "lint": "tsc -p tsconfig.json --noEmit",
     "package:check": "pnpm build && node scripts/check-package.cjs",
-    "verify": "pnpm lint && pnpm test && pnpm build && pnpm cube3:tables:check && pnpm cube2:tables:check && pnpm pyraminx:tables:check && pnpm package:check",
+    "verify": "pnpm lint && pnpm test && pnpm build && pnpm cube3:tables:check && pnpm cube2:tables:check && pnpm pyraminx:tables:check && pnpm skewb:tables:check && pnpm package:check",
     "dev": "tsx src/cli/index.ts",
     "cube3:tables": "node --import tsx scripts/generate-cube3-solver-tables.ts",
     "cube3:tables:check": "node --import tsx scripts/check-cube3-solver-tables.ts",
@@ -42,6 +42,8 @@
     "cube2:tables:check": "node --import tsx scripts/check-cube2-solver-tables.ts",
     "pyraminx:tables": "node --import tsx scripts/generate-pyraminx-solver-tables.ts",
     "pyraminx:tables:check": "node --import tsx scripts/check-pyraminx-solver-tables.ts",
+    "skewb:tables": "node --import tsx scripts/generate-skewb-solver-tables.ts",
+    "skewb:tables:check": "node --import tsx scripts/check-skewb-solver-tables.ts",
     "tables:web:sync": "node --import tsx scripts/sync-web-tables.ts",
     "verify:scrambles": "node --import tsx scripts/verify-scrambles.ts",
     "verify:pyraminx:exhaustive": "node --import tsx scripts/verify-pyraminx-exhaustive.ts",
@@ -49,7 +51,8 @@
     "bench:cube2": "node --import tsx bench-cube2.ts",
     "bench:cube3": "node --import tsx bench-cube3.ts",
     "bench:skewb": "node --import tsx bench-skewb.ts",
-    "bench:pyraminx": "node --import tsx bench-pyraminx.ts"
+    "bench:pyraminx": "node --import tsx bench-pyraminx.ts",
+    "bench:phases": "node --import tsx bench-phases.ts"
   },
   "devDependencies": {
     "@cubingcenter/viz": "link:../cubingcenter-viz",

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

@@ -1,11 +0,0 @@
-import type { SkewbMove, SkewbState } from "./types.js";
-export declare function getPermutationIndex(perm: readonly number[]): number;
-export declare function getPermutationFromIndex(index: number, n: number): number[];
-export declare function getOrientationIndex(orient: readonly number[]): number;
-export declare function getOrientationFromIndex(index: number): number[];
-export declare function getCenterIndex(centers: readonly number[]): number;
-export declare function getCenterFromIndex(index: number): number[];
-export declare function getStateIndex(state: SkewbState): number;
-export declare function getStateFromIndex(index: number): SkewbState;
-export declare function solveSkewb(state: SkewbState): SkewbMove[];
-//# sourceMappingURL=solver.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/solver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMxD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWnE;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,CASjE;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;AAID,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,CA+CzD"}