@cubingcenter/scrambler 0.4.1 → 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

@@ -71,11 +71,16 @@ async function initializeScrambler(baseUrl, eventId) {
         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([
             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/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/skewb/facelets.js

@@ -7,6 +7,7 @@ exports.getSkewbFaceOrder = getSkewbFaceOrder;
 // Facelets model matching cubingcenter-viz/src/puzzles/skewb.ts
 // Each face has 5 stickers: 0=center, 1=TL,2=TR,3=BL,4=BR (net layout)
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const FACE_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 // Canonical sticker faces per corner position: [UD sticker, RL sticker, FB sticker]
 const CORNER_STICKERS = [
     ["U", "R", "F"],
@@ -29,43 +30,65 @@ const CORNER_SLOTS = [
     [["D", 4], ["R", 4], ["B", 3]],
     [["D", 3], ["L", 3], ["B", 4]],
 ];
+// For each (position, piece, orientation) the three facelet writes, flattened:
+// face index, sticker slot index and sticker color index, so the hot loop is
+// pure table lookups (no tuple destructuring, no modulo).
+const CORNER_WRITE_COUNT = 8 * 8 * 3 * 3;
+const WRITE_FACE = new Int8Array(CORNER_WRITE_COUNT);
+const WRITE_SLOT = new Int8Array(CORNER_WRITE_COUNT);
+const WRITE_COLOR = new Int8Array(CORNER_WRITE_COUNT);
+for (let pos = 0; pos < 8; pos++) {
+    const slots = CORNER_SLOTS[pos];
+    for (let piece = 0; piece < 8; piece++) {
+        const stickers = CORNER_STICKERS[piece];
+        for (let ori = 0; ori < 3; ori++) {
+            const base = ((pos * 8 + piece) * 3 + ori) * 3;
+            for (let i = 0; i < 3; i++) {
+                const [face, idx] = slots[i];
+                const color = stickers[(i + 3 - ori) % 3];
+                WRITE_FACE[base + i] = FACE_INDEX[face];
+                WRITE_SLOT[base + i] = idx;
+                WRITE_COLOR[base + i] = FACE_INDEX[color];
+            }
+        }
+    }
+}
 function createSolvedSkewbFacelets() {
     return {
-        U: Array.from({ length: 5 }, () => "U"),
-        R: Array.from({ length: 5 }, () => "R"),
-        F: Array.from({ length: 5 }, () => "F"),
-        D: Array.from({ length: 5 }, () => "D"),
-        L: Array.from({ length: 5 }, () => "L"),
-        B: Array.from({ length: 5 }, () => "B"),
+        U: ["U", "U", "U", "U", "U"],
+        R: ["R", "R", "R", "R", "R"],
+        F: ["F", "F", "F", "F", "F"],
+        D: ["D", "D", "D", "D", "D"],
+        L: ["L", "L", "L", "L", "L"],
+        B: ["B", "B", "B", "B", "B"],
     };
 }
 function createEmptySkewbFacelets() {
     return {
-        U: Array(5).fill("?"),
-        R: Array(5).fill("?"),
-        F: Array(5).fill("?"),
-        D: Array(5).fill("?"),
-        L: Array(5).fill("?"),
-        B: Array(5).fill("?"),
+        U: ["?", "?", "?", "?", "?"],
+        R: ["?", "?", "?", "?", "?"],
+        F: ["?", "?", "?", "?", "?"],
+        D: ["?", "?", "?", "?", "?"],
+        L: ["?", "?", "?", "?", "?"],
+        B: ["?", "?", "?", "?", "?"],
     };
 }
 function toSkewbFacelets(state) {
     const facelets = createEmptySkewbFacelets();
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    const perm = state.corners.permutation;
+    const orient = state.corners.orientation;
+    const centers = state.centers;
     // centers
     for (let face = 0; face < 6; face++) {
-        const targetFace = FACE_ORDER[face];
-        facelets[targetFace][0] = FACE_ORDER[state.centers[face]];
+        faces[face][0] = FACE_ORDER[centers[face]];
     }
-    // corners
+    // corners (unrolled 3 writes per position)
     for (let pos = 0; pos < 8; pos++) {
-        const piece = state.corners.permutation[pos];
-        const ori = state.corners.orientation[pos];
-        const slots = CORNER_SLOTS[pos];
-        const stickers = CORNER_STICKERS[piece];
-        for (let i = 0; i < 3; i++) {
-            const [face, idx] = slots[i];
-            facelets[face][idx] = stickers[(i + 3 - ori) % 3];
-        }
+        const base = ((pos * 8 + perm[pos]) * 3 + orient[pos]) * 3;
+        faces[WRITE_FACE[base]][WRITE_SLOT[base]] = FACE_ORDER[WRITE_COLOR[base]];
+        faces[WRITE_FACE[base + 1]][WRITE_SLOT[base + 1]] = FACE_ORDER[WRITE_COLOR[base + 1]];
+        faces[WRITE_FACE[base + 2]][WRITE_SLOT[base + 2]] = FACE_ORDER[WRITE_COLOR[base + 2]];
     }
     return facelets;
 }