@cubingcenter/scrambler 0.4.0 → 0.5.0

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

@@ -0,0 +1,508 @@
+import { applySkewbMove } from "../moves.js";
+import { loadGeneratedSkewbSolverTables } from "./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);
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export function getCenterFromIndex(index) {
+    return getPermutationFromIndex(index, 6);
+}
+export 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);
+}
+export 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.
+export const PERMUTATION_COUNT = 5040; // r7: corners 1..7 Lehmer
+export const ORIENTATION_COUNT = 2187; // rO: corners 1..7 base-3
+export const CENTER_COUNT = 720; // rC: centers Lehmer
+export const EVEN_CENTER_COUNT = 360; // reachable center arrangements
+export const ORIENT_CLASS_COUNT = 9; // orientation classes
+export const PER_SET_SIZE = 4; // corner permutations per (rC, rO-class)
+export const MOVE_COUNT = 8;
+export const STATE_COUNT = EVEN_CENTER_COUNT * ORIENTATION_COUNT * PER_SET_SIZE; // 3_149_280
+export const POLICY_PACKED_ENTRIES = Math.ceil((STATE_COUNT * 3) / 8);
+export const SKEWB_MOVES = ["R", "R'", "U", "U'", "L", "L'", "B", "B'"];
+export 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;
+}
+export 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;
+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
+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
+export let R7_SETS = null; // (rC_even * 9 + class) * 4 + i
+export let PERM7_UNRANK = null; // r7 * 7 + i -> piece at corner i+1 (derived at load)
+export let CENTER_UNRANK = null; // rC * 6 + i -> center piece (derived at load)
+export let SOLVED_RANK = 0;
+export async function ensureTablesLoaded() {
+    if (tablesLoaded)
+        return;
+    const tables = await loadGeneratedSkewbSolverTables();
+    assignTables(tables);
+}
+export function assignTables(tables) {
+    PERMUTATION_TABLE = tables.permutationTable;
+    ORIENTATION_TABLE = tables.orientationTable;
+    CENTERS_TABLE = tables.centersTable;
+    POLICY_TABLE = tables.policyTable;
+    EVEN_CENTER_RANK = tables.evenCenterRank;
+    ORIENT_CLASS = tables.orientClass;
+    R7_SETS = tables.r7Sets;
+    EVEN_CENTER_FULL = new Uint16Array(EVEN_CENTER_COUNT);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const compactIdx = tables.evenCenterRank[rC];
+        if (compactIdx !== 65535)
+            EVEN_CENTER_FULL[compactIdx] = rC;
+    }
+    PERM7_UNRANK = new Uint8Array(PERMUTATION_COUNT * 7);
+    for (let r7 = 0; r7 < PERMUTATION_COUNT; r7++) {
+        const perm = getPerm7FromIndex(r7);
+        for (let i = 0; i < 7; i++)
+            PERM7_UNRANK[r7 * 7 + i] = perm[i + 1];
+    }
+    CENTER_UNRANK = new Uint8Array(CENTER_COUNT * 6);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const centers = getCenterFromIndex(rC);
+        for (let i = 0; i < 6; i++)
+            CENTER_UNRANK[rC * 6 + i] = centers[i];
+    }
+    SOLVED_RANK = rankFromComponents(0, 0, 0);
+    tablesLoaded = true;
+}
+export function resetTablesForTests() {
+    tablesLoaded = false;
+    PERMUTATION_TABLE = null;
+    ORIENTATION_TABLE = null;
+    CENTERS_TABLE = null;
+    POLICY_TABLE = null;
+    EVEN_CENTER_RANK = null;
+    EVEN_CENTER_FULL = null;
+    ORIENT_CLASS = null;
+    R7_SETS = null;
+    PERM7_UNRANK = null;
+    CENTER_UNRANK = null;
+}
+// ---------------------------------------------------------------------------
+// Compact rank helpers
+// ---------------------------------------------------------------------------
+export function rankFromComponents(r7, rO, rC) {
+    const evenRank = EVEN_CENTER_RANK[rC];
+    if (evenRank === 65535) {
+        throw new Error("Unreachable Skewb state: odd center permutation parity.");
+    }
+    const cls = ORIENT_CLASS[rO];
+    const set = R7_SETS;
+    const base = (evenRank * ORIENT_CLASS_COUNT + cls) * PER_SET_SIZE;
+    for (let i = 0; i < PER_SET_SIZE; i++) {
+        if (set[base + i] === r7) {
+            return (evenRank * ORIENTATION_COUNT + rO) * PER_SET_SIZE + i;
+        }
+    }
+    throw new Error("Unreachable Skewb state: corner permutation not in reachable set.");
+}
+export 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.
+export function getStateFromRank(rank) {
+    const even = Math.floor(rank / (ORIENTATION_COUNT * PER_SET_SIZE));
+    const rest = rank % (ORIENTATION_COUNT * PER_SET_SIZE);
+    const rO = Math.floor(rest / PER_SET_SIZE);
+    const k = rest % PER_SET_SIZE;
+    const cls = ORIENT_CLASS[rO];
+    const r7 = R7_SETS[(even * ORIENT_CLASS_COUNT + cls) * 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] = 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 = EVEN_CENTER_FULL[even] * 6;
+    for (let i = 0; i < 6; i++)
+        centers[i] = CENTER_UNRANK[centerBase + i];
+    return { corners: { permutation: perm, orientation: orient }, centers };
+}
+// 3-bit little-endian unpacking of the packed policy table.
+export 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;
+}
+export function getPolicyMove(stateRank) {
+    if (!POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return getPolicyMoveFromPacked(POLICY_TABLE, stateRank);
+}
+export function getPermutationTransition(permIdx, move) {
+    if (!PERMUTATION_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return PERMUTATION_TABLE[permIdx * MOVE_COUNT + move];
+}
+export function getOrientationTransition(orientIdx, move) {
+    if (!ORIENTATION_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return ORIENTATION_TABLE[orientIdx * MOVE_COUNT + move];
+}
+export function getCentersTransition(centerIdx, move) {
+    if (!CENTERS_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return CENTERS_TABLE[centerIdx * MOVE_COUNT + move];
+}
+// ---------------------------------------------------------------------------
+// Table generation (used by the generate script)
+// ---------------------------------------------------------------------------
+export function generatePermutationTable() {
+    const table = new Uint16Array(PERMUTATION_COUNT * MOVE_COUNT);
+    for (let r7 = 0; r7 < PERMUTATION_COUNT; r7++) {
+        const perm = getPerm7FromIndex(r7);
+        for (let m = 0; m < 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 = applySkewbMove(state, SKEWB_MOVES[m]);
+            table[r7 * MOVE_COUNT + m] = getPerm7Index(next.corners.permutation);
+        }
+    }
+    return table;
+}
+export function generateOrientationTable() {
+    const table = new Uint16Array(ORIENTATION_COUNT * MOVE_COUNT);
+    for (let rO = 0; rO < ORIENTATION_COUNT; rO++) {
+        const orient = getOrientationFromIndex(rO);
+        for (let m = 0; m < 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 = applySkewbMove(state, SKEWB_MOVES[m]);
+            table[rO * MOVE_COUNT + m] = getOrientationIndex(next.corners.orientation);
+        }
+    }
+    return table;
+}
+export function generateCentersTable() {
+    const table = new Uint16Array(CENTER_COUNT * MOVE_COUNT);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const centers = getCenterFromIndex(rC);
+        for (let m = 0; m < 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 = applySkewbMove(state, SKEWB_MOVES[m]);
+            table[rC * MOVE_COUNT + m] = getCenterIndex(next.centers);
+        }
+    }
+    return table;
+}
+export 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
+export function generateHelperTables(permTable, orientTable, centersTable) {
+    const evenCenterRank = new Uint16Array(CENTER_COUNT).fill(65535);
+    const evenCenterFull = new Uint16Array(EVEN_CENTER_COUNT);
+    let compact = 0;
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        if (permutationParity(getCenterFromIndex(rC)) === 0) {
+            evenCenterRank[rC] = compact;
+            evenCenterFull[compact] = rC;
+            compact++;
+        }
+    }
+    if (compact !== EVEN_CENTER_COUNT) {
+        throw new Error(`Expected ${EVEN_CENTER_COUNT} even center permutations, found ${compact}.`);
+    }
+    const pack = (r7, rO, rC) => (r7 * ORIENTATION_COUNT + rO) * 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 % CENTER_COUNT;
+        const rest = Math.floor(cur / CENTER_COUNT);
+        const rO = rest % ORIENTATION_COUNT;
+        const r7 = Math.floor(rest / ORIENTATION_COUNT);
+        const pairKey = rC * 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 < MOVE_COUNT; m++) {
+            const n7 = permTable[r7 * MOVE_COUNT + m];
+            const nO = orientTable[rO * MOVE_COUNT + m];
+            const nC = centersTable[rC * MOVE_COUNT + m];
+            const next = pack(n7, nO, nC);
+            if (!seen.has(next)) {
+                seen.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    if (seen.size !== STATE_COUNT) {
+        throw new Error(`Reachability BFS covered ${seen.size} states, expected ${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(ORIENTATION_COUNT);
+    const classOfSet = new Map();
+    for (let rO = 0; rO < 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 !== ORIENT_CLASS_COUNT) {
+        throw new Error(`Expected ${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(EVEN_CENTER_COUNT * ORIENT_CLASS_COUNT * PER_SET_SIZE);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const rCCompact = evenCenterRank[rC];
+        if (rCCompact === 65535)
+            continue;
+        for (let rO = 0; rO < ORIENTATION_COUNT; rO++) {
+            const set = pairSets.get(rC * ORIENTATION_COUNT + rO);
+            if (set.size !== PER_SET_SIZE) {
+                throw new Error(`Expected ${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 * ORIENT_CLASS_COUNT + cls) * PER_SET_SIZE;
+            for (let i = 0; i < 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).
+export function generatePolicyTable(permTable, orientTable, centersTable, helpers) {
+    // Install the compact-rank tables for the duration of the build.
+    const saved = { evenCenterRank: EVEN_CENTER_RANK, orientClass: ORIENT_CLASS, r7Sets: R7_SETS };
+    EVEN_CENTER_RANK = helpers.evenCenterRank;
+    ORIENT_CLASS = helpers.orientClass;
+    R7_SETS = helpers.r7Sets;
+    try {
+        const solvedRank = rankFromComponents(0, 0, 0);
+        const distances = new Uint8Array(STATE_COUNT).fill(255);
+        const policy = new Uint8Array(STATE_COUNT);
+        distances[solvedRank] = 0;
+        const queue = new Uint32Array(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 / (ORIENTATION_COUNT * PER_SET_SIZE));
+            const rest = curr % (ORIENTATION_COUNT * PER_SET_SIZE);
+            const rO = Math.floor(rest / PER_SET_SIZE);
+            const k = rest % PER_SET_SIZE;
+            const cls = ORIENT_CLASS[rO];
+            const r7 = R7_SETS[(even * ORIENT_CLASS_COUNT + cls) * PER_SET_SIZE + k];
+            const rC = helpers.evenCenterFull[even];
+            const nextDist = dist + 1;
+            for (let m = 0; m < MOVE_COUNT; m++) {
+                const n7 = permTable[r7 * MOVE_COUNT + m];
+                const nO = orientTable[rO * MOVE_COUNT + m];
+                const nC = centersTable[rC * 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 !== STATE_COUNT) {
+            throw new Error(`Policy BFS covered ${write} states, expected ${STATE_COUNT}.`);
+        }
+        const packed = new Uint8Array(POLICY_PACKED_ENTRIES);
+        for (let i = 0; i < 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 {
+        EVEN_CENTER_RANK = saved.evenCenterRank;
+        ORIENT_CLASS = saved.orientClass;
+        R7_SETS = saved.r7Sets;
+    }
+}
+export 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/random/prng.js

@@ -6,8 +6,17 @@ export function createRandomSource(seed) {
     return new SeededRandomSource(hashSeed(seed));
 }
 class CryptoRandomSource {
+    buffer = null;
+    offset = 0;
     next() {
-        const value = 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 = randomBytes(256);
+            this.offset = 0;
+        }
+        const value = this.buffer.readUIntBE(this.offset, 6);
+        this.offset += 6;
         return value / 0x1000000000000;
     }
     nextInt(maxExclusive) {

package/dist-cjs/core/api.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeScrambler = initializeScrambler;
 exports.registerScrambleGenerator = registerScrambleGenerator;
@@ -8,8 +41,6 @@ exports.generateScramble = generateScramble;
 exports.generateScrambles = generateScrambles;
 const errors_js_1 = require("./errors.js");
 const registry_js_1 = require("./registry.js");
-const browser_loader_js_1 = require("../puzzles/cube2/solver/browser-loader.js");
-const browser_loader_js_2 = require("../puzzles/cube3/solver/browser-loader.js");
 /**
  * Pre-load solver tables in browser environments.
  * In Node.js this is a no-op (tables are read lazily from the filesystem).
@@ -26,16 +57,30 @@ async function initializeScrambler(baseUrl, eventId) {
         // Node.js — tables are loaded on-demand from the filesystem
         return;
     }
+    // Lazy imports keep per-puzzle subpath bundles from pulling in the
+    // loaders of every other puzzle.
     if (eventId === "222" || eventId === "222so") {
-        await (0, browser_loader_js_1.loadBrowserTables)(baseUrl);
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/cube2/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
     }
     else if (eventId === "333") {
-        await (0, browser_loader_js_2.loadBrowserTables)(baseUrl);
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/cube3/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
+    }
+    else if (eventId === "pymx") {
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/pyraminx/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
+    }
+    else if (eventId === "skwb") {
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/skewb/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
     }
     else if (!eventId) {
         await Promise.all([
-            (0, browser_loader_js_1.loadBrowserTables)(baseUrl),
-            (0, browser_loader_js_2.loadBrowserTables)(baseUrl)
+            Promise.resolve().then(() => __importStar(require("../puzzles/cube2/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
+            Promise.resolve().then(() => __importStar(require("../puzzles/cube3/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
+            Promise.resolve().then(() => __importStar(require("../puzzles/pyraminx/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
+            Promise.resolve().then(() => __importStar(require("../puzzles/skewb/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl))
         ]);
     }
 }

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

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateClockScramble = exports.clockScrambleGenerator = void 0;
-var scrambler_js_1 = require("./scrambler.js");
-Object.defineProperty(exports, "clockScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.clockScrambleGenerator; } });
-Object.defineProperty(exports, "generateClockScramble", { enumerable: true, get: function () { return scrambler_js_1.generateClockScramble; } });
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.generateClockScramble = exports.clockScrambleGenerator = void 0;
+const index_js_1 = require("../../core/index.js");
+const scrambler_js_1 = require("./scrambler.js");
+(0, index_js_1.registerScrambleGenerator)(scrambler_js_1.clockScrambleGenerator);
+var scrambler_js_2 = require("./scrambler.js");
+Object.defineProperty(exports, "clockScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.clockScrambleGenerator; } });
+Object.defineProperty(exports, "generateClockScramble", { enumerable: true, get: function () { return scrambler_js_2.generateClockScramble; } });
+var index_js_2 = require("../../core/index.js");
+Object.defineProperty(exports, "generateScramble", { enumerable: true, get: function () { return index_js_2.generateScramble; } });
+Object.defineProperty(exports, "generateScrambles", { enumerable: true, get: function () { return index_js_2.generateScrambles; } });
+Object.defineProperty(exports, "getEventInfo", { enumerable: true, get: function () { return index_js_2.getEventInfo; } });
+Object.defineProperty(exports, "getSupportedEvents", { enumerable: true, get: function () { return index_js_2.getSupportedEvents; } });
+Object.defineProperty(exports, "initializeScrambler", { enumerable: true, get: function () { return index_js_2.initializeScrambler; } });

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

@@ -33,7 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solver = exports.toCube2Facelets = exports.getCube2FaceOrder = exports.formatCube2Facelets = exports.generateCube2Scramble = exports.cube2ScrambleGenerator = exports.generateRandomCube2State = exports.validateCube2State = exports.permutationParity = exports.isOneMoveFromSolvedCube2State = exports.isAllowedRandomCube2State = exports.isSolvedCube2State = exports.cube2StatesEqual = exports.createSolvedCube2State = exports.cloneCube2State = exports.parseCube2Move = exports.parseCube2Algorithm = exports.invertCube2Move = exports.invertCube2Algorithm = exports.formatCube2Algorithm = exports.applyCube2Move = exports.applyCube2Algorithm = exports.CORNER_COUNT = exports.CUBE2_MOVES = void 0;
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.solver = exports.toCube2Facelets = exports.getCube2FaceOrder = exports.formatCube2Facelets = exports.generateCube2Scramble = exports.cube2ScrambleGenerator = exports.generateRandomCube2State = exports.validateCube2State = exports.permutationParity = exports.isOneMoveFromSolvedCube2State = exports.isAllowedRandomCube2State = exports.isSolvedCube2State = exports.cube2StatesEqual = exports.createSolvedCube2State = exports.cloneCube2State = exports.parseCube2Move = exports.parseCube2Algorithm = exports.invertCube2Move = exports.invertCube2Algorithm = exports.formatCube2Algorithm = exports.applyCube2Move = exports.applyCube2Algorithm = exports.CORNER_COUNT = exports.CUBE2_MOVES = void 0;
+const index_js_1 = require("../../core/index.js");
+const scrambler_js_1 = require("./scrambler.js");
+(0, index_js_1.registerScrambleGenerator)(scrambler_js_1.cube2ScrambleGenerator);
 var types_js_1 = require("./types.js");
 Object.defineProperty(exports, "CUBE2_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE2_MOVES; } });
 Object.defineProperty(exports, "CORNER_COUNT", { enumerable: true, get: function () { return types_js_1.CORNER_COUNT; } });
@@ -57,11 +60,17 @@ Object.defineProperty(exports, "permutationParity", { enumerable: true, get: fun
 Object.defineProperty(exports, "validateCube2State", { enumerable: true, get: function () { return validation_js_1.validateCube2State; } });
 var random_state_js_1 = require("./random-state.js");
 Object.defineProperty(exports, "generateRandomCube2State", { enumerable: true, get: function () { return random_state_js_1.generateRandomCube2State; } });
-var scrambler_js_1 = require("./scrambler.js");
-Object.defineProperty(exports, "cube2ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube2ScrambleGenerator; } });
-Object.defineProperty(exports, "generateCube2Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube2Scramble; } });
+var scrambler_js_2 = require("./scrambler.js");
+Object.defineProperty(exports, "cube2ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.cube2ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube2Scramble", { enumerable: true, get: function () { return scrambler_js_2.generateCube2Scramble; } });
 var facelets_js_1 = require("./facelets.js");
 Object.defineProperty(exports, "formatCube2Facelets", { enumerable: true, get: function () { return facelets_js_1.formatCube2Facelets; } });
 Object.defineProperty(exports, "getCube2FaceOrder", { enumerable: true, get: function () { return facelets_js_1.getCube2FaceOrder; } });
 Object.defineProperty(exports, "toCube2Facelets", { enumerable: true, get: function () { return facelets_js_1.toCube2Facelets; } });
 exports.solver = __importStar(require("./solver/index.js"));
+var index_js_2 = require("../../core/index.js");
+Object.defineProperty(exports, "generateScramble", { enumerable: true, get: function () { return index_js_2.generateScramble; } });
+Object.defineProperty(exports, "generateScrambles", { enumerable: true, get: function () { return index_js_2.generateScrambles; } });
+Object.defineProperty(exports, "getEventInfo", { enumerable: true, get: function () { return index_js_2.getEventInfo; } });
+Object.defineProperty(exports, "getSupportedEvents", { enumerable: true, get: function () { return index_js_2.getSupportedEvents; } });
+Object.defineProperty(exports, "initializeScrambler", { enumerable: true, get: function () { return index_js_2.initializeScrambler; } });