@cubingcenter/scrambler 0.4.1 → 0.5.1

package/dist/random/prng.js

@@ -1,13 +1,36 @@
 import { randomBytes } from "node:crypto";
+// 4096 bytes per refill (~682 values per syscall).
+const CRYPTO_BUFFER_BYTES = 4096;
+// Shared unseeded source: the crypto refill costs a syscall per buffer, so a
+// per-call source would pay ~one syscall per scramble. Seeded calls stay
+// isolated (deterministic streams must never be shared).
+let sharedCryptoSource = null;
 export function createRandomSource(seed) {
     if (seed === undefined) {
-        return new CryptoRandomSource();
+        sharedCryptoSource ??= new CryptoRandomSource();
+        return sharedCryptoSource;
     }
     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 > CRYPTO_BUFFER_BYTES) {
+            this.buffer = randomBytes(CRYPTO_BUFFER_BYTES);
+            this.offset = 0;
+        }
+        const bytes = this.buffer;
+        const offset = this.offset;
+        this.offset += 6;
+        const value = bytes[offset] * 0x10000000000 +
+            bytes[offset + 1] * 0x100000000 +
+            bytes[offset + 2] * 0x1000000 +
+            bytes[offset + 3] * 0x10000 +
+            bytes[offset + 4] * 0x100 +
+            bytes[offset + 5];
         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/pyraminx/facelets.js

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

package/dist-cjs/puzzles/pyraminx/random-state.js

@@ -2,41 +2,71 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRandomPyraminxState = generateRandomPyraminxState;
 const index_js_1 = require("../../random/index.js");
-const validation_js_1 = require("./validation.js");
+const state_js_1 = require("./state.js");
+// Compact -> full Lehmer index for the 360 even permutations of 6 edges.
+// Generated once: a permutation's parity is the parity of the digit sum of
+// its Lehmer code (each digit counts smaller elements to its right).
+const COMPACT_TO_FULL = new Uint16Array(360);
+(function buildCompactMapping() {
+    let compact = 0;
+    for (let full = 0; full < 720 && compact < 360; full += 1) {
+        let value = full;
+        const c5 = (value / 120) | 0;
+        value -= c5 * 120;
+        const c4 = (value / 24) | 0;
+        value -= c4 * 24;
+        const c3 = (value / 6) | 0;
+        value -= c3 * 6;
+        const c2 = (value / 2) | 0;
+        value -= c2 * 2;
+        const c1 = value;
+        if ((c5 + c4 + c3 + c2 + c1) % 2 === 0) {
+            COMPACT_TO_FULL[compact] = full;
+            compact += 1;
+        }
+    }
+})();
 function generateRandomPyraminxState(options = {}) {
     const random = (0, index_js_1.createRandomSource)(options.seed);
     const rejectTrivial = options.rejectTrivial ?? true;
     for (let attempt = 0; attempt < 100; attempt += 1) {
+        // The state is legal by construction (even permutation parity, even
+        // orientation sum, values in range), so only the trivial core check is
+        // needed here — no full re-validation.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomPyraminxState)(state)) {
+        if (!rejectTrivial || !(0, state_js_1.isSolvedPyraminxState)(state)) {
             return state;
         }
     }
     throw new Error("Unable to generate a non-trivial random Pyraminx state.");
 }
 function createLegalRandomState(random) {
-    // 4 random centers
-    const centers = Array.from({ length: 4 }, () => random.nextInt(3));
-    // 4 random tips
-    const tips = Array.from({ length: 4 }, () => random.nextInt(3));
-    // 6 edges permutation
-    const edgesPerm = shuffledRange(6, random);
-    // Ensure even parity
-    if ((0, validation_js_1.permutationParity)(edgesPerm) !== 0) {
-        // Swap the first two elements to flip parity
-        const temp = edgesPerm[0];
-        edgesPerm[0] = edgesPerm[1];
-        edgesPerm[1] = temp;
+    // 4 random centers from one uniform value in [0, 81) (4 base-3 digits)
+    let centerValue = random.nextInt(81);
+    const centers = [0, 0, 0, 0];
+    for (let index = 0; index < 4; index += 1) {
+        centers[index] = centerValue % 3;
+        centerValue = (centerValue / 3) | 0;
+    }
+    // 4 random tips from one uniform value in [0, 81)
+    let tipValue = random.nextInt(81);
+    const tips = [0, 0, 0, 0];
+    for (let index = 0; index < 4; index += 1) {
+        tips[index] = tipValue % 3;
+        tipValue = (tipValue / 3) | 0;
     }
-    // 6 edges orientation (sum must be even)
-    const edgesOrient = Array(6).fill(0);
+    // 6 edges permutation, even parity, uniform over the 360 even permutations
+    const edgesPerm = permutationFromCompact(random.nextInt(360));
+    // 6 edges orientation (sum must be even): 5 free bits + parity digit
+    let orientationValue = random.nextInt(32);
+    const edgesOrient = [0, 0, 0, 0, 0, 0];
     let sumOrient = 0;
-    for (let i = 0; i < 5; i++) {
-        const val = random.nextInt(2);
-        edgesOrient[i] = val;
-        sumOrient += val;
+    for (let index = 0; index < 5; index += 1) {
+        edgesOrient[index] = orientationValue & 1;
+        sumOrient += orientationValue & 1;
+        orientationValue >>= 1;
     }
-    edgesOrient[5] = sumOrient % 2 === 0 ? 0 : 1;
+    edgesOrient[5] = sumOrient & 1;
     return {
         centers,
         edgesPerm,
@@ -44,13 +74,17 @@ function createLegalRandomState(random) {
         tips
     };
 }
-function shuffledRange(length, random) {
-    const values = Array.from({ length }, (_, index) => index);
-    for (let index = values.length - 1; index > 0; index -= 1) {
-        const swapIndex = random.nextInt(index + 1);
-        const temporary = values[index];
-        values[index] = values[swapIndex];
-        values[swapIndex] = temporary;
+const FACTORIALS = [1, 1, 2, 6, 24, 120, 720];
+function permutationFromCompact(compact) {
+    let full = COMPACT_TO_FULL[compact];
+    const permutation = [0, 0, 0, 0, 0, 0];
+    const remaining = [0, 1, 2, 3, 4, 5];
+    for (let position = 0; position < 6; position += 1) {
+        const divisor = FACTORIALS[5 - position];
+        const choice = (full / divisor) | 0;
+        full -= choice * divisor;
+        permutation[position] = remaining[choice];
+        remaining.splice(choice, 1);
     }
-    return values;
+    return permutation;
 }

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

@@ -3,12 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pyraminxScrambleGenerator = void 0;
 exports.generatePyraminxScramble = generatePyraminxScramble;
 const random_state_js_1 = require("./random-state.js");
-const moves_js_1 = require("./moves.js");
 const index_js_1 = require("./solver/index.js");
 const facelets_js_1 = require("./facelets.js");
 const types_js_1 = require("./types.js");
-// Face -> tip index (U,L,R,B order, same as PYRAMINX_TIPS).
-const FACE_TIP_INDEX = { U: 0, L: 1, R: 2, B: 3 };
+const TIP_INVERSE = ["u'", "l'", "r'", "b'"];
 exports.pyraminxScrambleGenerator = {
     info: {
         eventId: "pymx",
@@ -24,47 +22,58 @@ exports.pyraminxScrambleGenerator = {
 };
 async function generatePyraminxScramble(options = {}) {
     const state = (0, random_state_js_1.generateRandomPyraminxState)(options);
-    // Solve the core edges and centers
-    const solution = await (0, index_js_1.solvePyraminx)(state);
-    const scrambleMoves = (0, moves_js_1.invertPyraminxAlgorithm)(solution);
-    // Append tips: layer moves already rotate tips, so we need the delta
-    // between the target tips and the tips produced by the core scramble.
-    // Computed arithmetically from the move sequence (no state replay).
+    // Solve the core edges and centers as move indices (0..7). For index m the
+    // inverse is m ^ 1, the face is m >> 1 (0=U, 1=L, 2=R, 3=B) and the
+    // direction is m & 1 (1 = clockwise, 0 = counter-clockwise).
+    const solution = (0, index_js_1.arePyraminxTablesLoaded)()
+        ? (0, index_js_1.solvePyraminxIndicesSync)(state)
+        : await (0, index_js_1.solvePyraminxIndices)(state);
+    const depth = solution.length;
+    // Single pass over the solution (reversed): build the scramble move strings
+    // while accumulating the tips rotated by the layer moves arithmetically
+    // (no state replay, no string parsing).
+    const moves = new Array(depth + 4);
     const coreTips = [0, 0, 0, 0];
-    for (const move of scrambleMoves) {
-        const isInverse = move.endsWith("'");
-        const face = isInverse ? move.slice(0, -1) : move;
-        const tipIndex = FACE_TIP_INDEX[face];
-        if (tipIndex !== undefined) {
-            coreTips[tipIndex] = (coreTips[tipIndex] + (isInverse ? 2 : 1)) % 3;
-        }
+    let count = 0;
+    for (let index = depth - 1; index >= 0; index -= 1) {
+        const m = solution[index] ^ 1;
+        moves[count++] = index_js_1.PYRAMINX_MOVES[m];
+        const face = m >> 1;
+        coreTips[face] = (coreTips[face] + (m & 1 ? 2 : 1)) % 3;
     }
-    const finalMoves = [...scrambleMoves];
-    for (let i = 0; i < 4; i++) {
+    const tipMoves = [];
+    for (let i = 0; i < 4; i += 1) {
         const delta = (state.tips[i] - coreTips[i] + 3) % 3;
         if (delta === 1) {
-            finalMoves.push(types_js_1.PYRAMINX_TIPS[i]);
+            moves[count++] = types_js_1.PYRAMINX_TIPS[i];
+            tipMoves.push(i * 2);
         }
         else if (delta === 2) {
-            finalMoves.push(`${types_js_1.PYRAMINX_TIPS[i]}'`);
+            moves[count++] = TIP_INVERSE[i];
+            tipMoves.push(i * 2 + 1);
         }
     }
-    if (!options.skipValidation && !(0, index_js_1.verifyPyraminxScramble)(state, finalMoves)) {
+    moves.length = count;
+    if (!options.skipValidation && !(0, index_js_1.verifyPyraminxScrambleIndices)(state, solution, tipMoves)) {
         throw new Error("Generated Pyraminx scramble does not reproduce the target random state.");
     }
     const facelets = (0, facelets_js_1.toPyraminxFacelets)(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = index_js_1.PYRAMINX_MOVES[solution[index]];
+    }
     return {
         eventId: "pymx",
-        scramble: finalMoves.join(" "),
-        moves: finalMoves,
+        scramble: moves.join(" "),
+        moves,
         quality: "random-state",
         generator: "pyraminx-optimal",
         metadata: {
             state,
             facelets,
             faceletString: (0, facelets_js_1.formatPyraminxFacelets)(facelets),
-            solutionMoves: solution,
-            solutionDepth: solution.length
+            solutionMoves,
+            solutionDepth: depth
         }
     };
 }

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.solvePyraminx = solvePyraminx;
 exports.solvePyraminxWithInfo = solvePyraminxWithInfo;
+exports.solvePyraminxIndices = solvePyraminxIndices;
+exports.solvePyraminxIndicesSync = solvePyraminxIndicesSync;
 exports.solvePyraminxSync = solvePyraminxSync;
 exports.verifyPyraminxScramble = verifyPyraminxScramble;
+exports.verifyPyraminxScrambleIndices = verifyPyraminxScrambleIndices;
 const tables_js_1 = require("./tables.js");
 async function solvePyraminx(state) {
     await (0, tables_js_1.ensureTablesLoaded)();
@@ -13,7 +16,25 @@ async function solvePyraminxWithInfo(state) {
     await (0, tables_js_1.ensureTablesLoaded)();
     return solveWithTables(state);
 }
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..7) in walk order. The inverse of index m is m ^ 1 (moves are
+// paired U/U', L/L', R/R', B/B'), its face is m >> 1 and its direction is
+// m & 1 (1 = clockwise, 0 = counter-clockwise).
+async function solvePyraminxIndices(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTablesIndices(state);
+}
+function solvePyraminxIndicesSync(state) {
+    if (!tables_js_1.POLICY_TABLE)
+        throw new Error("Pyraminx tables not loaded");
+    return solveWithTablesIndices(state);
+}
 function solveWithTables(state) {
+    const indices = solveWithTablesIndices(state);
+    const moves = indices.map((index) => tables_js_1.PYRAMINX_MOVES[index]);
+    return { moves, depth: moves.length };
+}
+function solveWithTablesIndices(state) {
     const centersTable = tables_js_1.CENTERS_TABLE;
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
@@ -23,17 +44,20 @@ function solveWithTables(state) {
     let o = (0, tables_js_1.getOrientationIndex)(state.edgesOrient);
     let stateIndex = c + 81 * (p + tables_js_1.PERMUTATION_COUNT * o);
     if (stateIndex === 0)
-        return { moves: [], depth: 0 };
+        return [];
     const moves = [];
     while (stateIndex !== 0) {
-        const m = (0, tables_js_1.getPolicyMoveFromPacked)(policy, stateIndex);
-        moves.push(tables_js_1.PYRAMINX_MOVES[m]);
+        const bits = stateIndex * 3;
+        const byteIndex = bits >> 3;
+        const offset = bits & 7;
+        const m = ((policy[byteIndex] | ((policy[byteIndex + 1] ?? 0) << 8)) >> offset) & 0x07;
+        moves.push(m);
         c = centersTable[c * tables_js_1.MOVE_COUNT + m];
         p = permTable[p * tables_js_1.MOVE_COUNT + m];
         o = orientTable[o * tables_js_1.MOVE_COUNT + m];
         stateIndex = c + 81 * (p + tables_js_1.PERMUTATION_COUNT * o);
     }
-    return { moves, depth: moves.length };
+    return moves;
 }
 // Synchronous variant for scripts that have already ensured tables are loaded
 function solvePyraminxSync(state) {
@@ -86,3 +110,37 @@ function verifyPyraminxScramble(state, finalMoves) {
         tips[2] === state.tips[2] &&
         tips[3] === state.tips[3]);
 }
+// Numeric verification for the hot scramble path: replays the scramble
+// (solution reversed with m ^ 1 inverses, tip moves as tipIndex * 2 + dir
+// with dir 0 = clockwise, 1 = counter-clockwise) without any string parsing.
+function verifyPyraminxScrambleIndices(state, solution, tipMoves) {
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    if (!centersTable || !permTable || !orientTable) {
+        throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let c = 0;
+    let p = 0;
+    let o = 0;
+    const tips = [0, 0, 0, 0];
+    for (let index = solution.length - 1; index >= 0; index -= 1) {
+        const m = solution[index] ^ 1;
+        c = centersTable[c * tables_js_1.MOVE_COUNT + m];
+        p = permTable[p * tables_js_1.MOVE_COUNT + m];
+        o = orientTable[o * tables_js_1.MOVE_COUNT + m];
+        const face = m >> 1;
+        tips[face] = (tips[face] + (m & 1 ? 2 : 1)) % 3;
+    }
+    for (const tipMove of tipMoves) {
+        const tipIndex = tipMove >> 1;
+        tips[tipIndex] = (tips[tipIndex] + (tipMove & 1 ? 2 : 1)) % 3;
+    }
+    return (c === (0, tables_js_1.getCentersIndex)(state.centers) &&
+        p === (0, tables_js_1.getPermutationCompactIndex)(state.edgesPerm) &&
+        o === (0, tables_js_1.getOrientationIndex)(state.edgesOrient) &&
+        tips[0] === state.tips[0] &&
+        tips[1] === state.tips[1] &&
+        tips[2] === state.tips[2] &&
+        tips[3] === state.tips[3]);
+}

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

@@ -20,6 +20,7 @@ exports.generateOrientationTable = generateOrientationTable;
 exports.generatePolicyTable = generatePolicyTable;
 exports.checksum = checksum;
 exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.arePyraminxTablesLoaded = arePyraminxTablesLoaded;
 exports.getPolicyMove = getPolicyMove;
 exports.getCentersTransition = getCentersTransition;
 exports.getPermutationTransition = getPermutationTransition;
@@ -298,6 +299,9 @@ async function ensureTablesLoaded() {
     exports.POLICY_TABLE = tables.policyTable;
     tablesLoaded = true;
 }
+function arePyraminxTablesLoaded() {
+    return tablesLoaded;
+}
 function getPolicyMove(stateIndex) {
     if (!exports.POLICY_TABLE)
         throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");

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;
 }