@cubingcenter/scrambler 0.1.0

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

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * 4x4 Move Definitions
+ *
+ * Each base move (CW quarter-turn) is defined by its effect on:
+ *  - Corner permutation & orientation (same as 3x3 for outer moves; identity for wide-only slice)
+ *  - Wing permutation (24 wings)
+ *  - Center permutation (24 centers)
+ *
+ * Wide moves (Uw, Rw, etc.) = outer move + inner slice.
+ * We define outer moves and inner slices separately, then compose.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FACE_MOVE_EFFECTS = void 0;
+exports.parseMove = parseMove;
+exports.applyCube4Move = applyCube4Move;
+exports.applyCube4Algorithm = applyCube4Algorithm;
+exports.invertCube4Move = invertCube4Move;
+exports.invertCube4Algorithm = invertCube4Algorithm;
+exports.formatCube4Algorithm = formatCube4Algorithm;
+exports.parseCube4Algorithm = parseCube4Algorithm;
+exports.parseCube4Move = parseCube4Move;
+const types_js_1 = require("./types.js");
+// ---------------------------------------------------------------------------
+// Identity arrays
+// ---------------------------------------------------------------------------
+const ID_CP = [0, 1, 2, 3, 4, 5, 6, 7];
+const ID_CO = [0, 0, 0, 0, 0, 0, 0, 0];
+const ID_WP = Array.from({ length: 24 }, (_, i) => i);
+const ID_CT = Array.from({ length: 24 }, (_, i) => i);
+// ---------------------------------------------------------------------------
+// Helper: apply cycles to an identity-initialized permutation array
+// ---------------------------------------------------------------------------
+function withCycles(base, ...cycles) {
+    const result = [...base];
+    for (const cycle of cycles) {
+        const last = result[cycle[cycle.length - 1]];
+        for (let i = cycle.length - 1; i > 0; i--) {
+            result[cycle[i]] = result[cycle[i - 1]];
+        }
+        result[cycle[0]] = last;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Outer face moves (single outer layer)
+// ---------------------------------------------------------------------------
+/*
+ * Corner numbering: 0=URF 1=UFL 2=ULB 3=UBR 4=DFR 5=DLF 6=DBL 7=DRB
+ *
+ * Wing numbering (24 wings):
+ *   Pair  0 (UR): 0=URf, 1=URb     Pair  6 (DL): 12=DLf, 13=DLb
+ *   Pair  1 (UF): 2=UFr, 3=UFl     Pair  7 (DB): 14=DBl, 15=DBr
+ *   Pair  2 (UL): 4=ULf, 5=ULb     Pair  8 (FR): 16=FRu, 17=FRd
+ *   Pair  3 (UB): 6=UBl, 7=UBr     Pair  9 (FL): 18=FLu, 19=FLd
+ *   Pair  4 (DR): 8=DRf, 9=DRb     Pair 10 (BL): 20=BLu, 21=BLd
+ *   Pair  5 (DF): 10=DFr, 11=DFl    Pair 11 (BR): 22=BRu, 23=BRd
+ *
+ * Center numbering (inner 2×2 per face, reading order):
+ *   U: 0,1,2,3   R: 4,5,6,7   F: 8,9,10,11
+ *   D: 12,13,14,15   L: 16,17,18,19   B: 20,21,22,23
+ *
+ *   Within a face, positions are:
+ *     0=top-left  1=top-right
+ *     2=bot-left  3=bot-right
+ *   (as seen looking at the face from the outside)
+ */
+const OUTER_U = {
+    cperm: [3, 0, 1, 2, 4, 5, 6, 7],
+    corient: [0, 0, 0, 0, 0, 0, 0, 0],
+    wperm: [7, 6, 1, 0, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+    ctperm: [2, 0, 3, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+};
+const OUTER_D = {
+    cperm: [0, 1, 2, 3, 5, 6, 7, 4],
+    corient: [0, 0, 0, 0, 0, 0, 0, 0],
+    wperm: [0, 1, 2, 3, 4, 5, 6, 7, 11, 10, 12, 13, 14, 15, 9, 8, 16, 17, 18, 19, 20, 21, 22, 23],
+    ctperm: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 12, 15, 13, 16, 17, 18, 19, 20, 21, 22, 23],
+};
+const OUTER_R = {
+    cperm: [4, 1, 2, 0, 7, 5, 6, 3],
+    corient: [2, 0, 0, 1, 1, 0, 0, 2],
+    wperm: [17, 16, 2, 3, 4, 5, 6, 7, 23, 22, 10, 11, 12, 13, 14, 15, 8, 9, 18, 19, 20, 21, 0, 1],
+    ctperm: [0, 1, 2, 3, 6, 4, 7, 5, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+};
+const OUTER_L = {
+    cperm: [0, 2, 6, 3, 4, 1, 5, 7],
+    corient: [0, 1, 2, 0, 0, 2, 1, 0],
+    wperm: [0, 1, 2, 3, 20, 21, 6, 7, 8, 9, 10, 11, 18, 19, 14, 15, 16, 17, 5, 4, 13, 12, 22, 23],
+    ctperm: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 18, 16, 19, 17, 20, 21, 22, 23],
+};
+const OUTER_F = {
+    cperm: [1, 5, 2, 3, 0, 4, 6, 7],
+    corient: [1, 2, 0, 0, 2, 1, 0, 0],
+    wperm: [0, 1, 18, 19, 4, 5, 6, 7, 8, 9, 16, 17, 12, 13, 14, 15, 3, 2, 11, 10, 20, 21, 22, 23],
+    ctperm: [0, 1, 2, 3, 4, 5, 6, 7, 10, 8, 11, 9, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+};
+const OUTER_B = {
+    cperm: [0, 1, 3, 7, 4, 5, 2, 6],
+    corient: [0, 0, 1, 2, 0, 0, 2, 1],
+    wperm: [0, 1, 2, 3, 4, 5, 22, 23, 8, 9, 10, 11, 12, 13, 20, 21, 16, 17, 18, 19, 7, 6, 15, 14],
+    ctperm: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 20, 23, 21],
+};
+// ---------------------------------------------------------------------------
+// Inner slices — derived from facelet simulation, verified x4=identity
+// ---------------------------------------------------------------------------
+const INNER_u = {
+    cperm: ID_CP, corient: ID_CO,
+    wperm: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 22, 17, 16, 19, 18, 21, 20, 23],
+    ctperm: [0, 1, 2, 3, 20, 21, 6, 7, 4, 5, 10, 11, 12, 13, 14, 15, 8, 9, 18, 19, 16, 17, 22, 23],
+};
+const INNER_d = {
+    cperm: ID_CP, corient: ID_CO,
+    wperm: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 19, 18, 21, 20, 23, 22, 17],
+    ctperm: [0, 1, 2, 3, 4, 5, 10, 11, 8, 9, 18, 19, 12, 13, 14, 15, 16, 17, 22, 23, 20, 21, 6, 7],
+};
+const INNER_r = {
+    cperm: ID_CP, corient: ID_CO,
+    wperm: [0, 1, 10, 3, 4, 5, 6, 2, 8, 9, 15, 11, 12, 13, 14, 7, 16, 17, 18, 19, 20, 21, 22, 23],
+    ctperm: [0, 9, 2, 11, 4, 5, 6, 7, 8, 13, 10, 15, 12, 22, 14, 20, 16, 17, 18, 19, 3, 21, 1, 23],
+};
+const INNER_l = {
+    cperm: ID_CP, corient: ID_CO,
+    wperm: [0, 1, 2, 6, 4, 5, 14, 7, 8, 9, 10, 3, 12, 13, 11, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+    ctperm: [23, 1, 21, 3, 4, 5, 6, 7, 0, 9, 2, 11, 8, 13, 10, 15, 16, 17, 18, 19, 20, 14, 22, 12],
+};
+const INNER_f = {
+    cperm: ID_CP, corient: ID_CO,
+    wperm: [4, 1, 2, 3, 12, 5, 6, 7, 0, 9, 10, 11, 8, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+    ctperm: [0, 1, 19, 17, 2, 5, 3, 7, 8, 9, 10, 11, 6, 4, 14, 15, 16, 12, 18, 13, 20, 21, 22, 23],
+};
+const INNER_b = {
+    cperm: ID_CP, corient: ID_CO,
+    wperm: [0, 9, 2, 3, 4, 1, 6, 7, 8, 13, 10, 11, 12, 5, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+    ctperm: [5, 7, 2, 3, 4, 15, 6, 14, 8, 9, 10, 11, 12, 13, 16, 18, 1, 17, 0, 19, 20, 21, 22, 23],
+};
+// ---------------------------------------------------------------------------
+// Compose two effects to create wide moves: Xw = outer_X then inner_x
+// ---------------------------------------------------------------------------
+function composeEffects(a, b) {
+    const cp = new Array(types_js_1.CORNER_COUNT);
+    const co = new Array(types_js_1.CORNER_COUNT);
+    const wp = new Array(types_js_1.WING_COUNT);
+    const ct = new Array(types_js_1.CENTER_COUNT);
+    for (let i = 0; i < types_js_1.CORNER_COUNT; i++) {
+        cp[i] = a.cperm[b.cperm[i]];
+        co[i] = (a.corient[b.cperm[i]] + b.corient[i]) % 3;
+    }
+    for (let i = 0; i < types_js_1.WING_COUNT; i++) {
+        wp[i] = a.wperm[b.wperm[i]];
+    }
+    for (let i = 0; i < types_js_1.CENTER_COUNT; i++) {
+        ct[i] = a.ctperm[b.ctperm[i]];
+    }
+    return { cperm: cp, corient: co, wperm: wp, ctperm: ct };
+}
+// Wide moves = outer + inner
+const WIDE_Uw = composeEffects(OUTER_U, INNER_u);
+const WIDE_Dw = composeEffects(OUTER_D, INNER_d);
+const WIDE_Rw = composeEffects(OUTER_R, INNER_r);
+const WIDE_Lw = composeEffects(OUTER_L, INNER_l);
+const WIDE_Fw = composeEffects(OUTER_F, INNER_f);
+const WIDE_Bw = composeEffects(OUTER_B, INNER_b);
+// ---------------------------------------------------------------------------
+// Lookup table: face-move name → MoveEffect (CW quarter turn)
+// ---------------------------------------------------------------------------
+const FACE_MOVE_EFFECTS = {
+    U: OUTER_U, D: OUTER_D, R: OUTER_R, L: OUTER_L, F: OUTER_F, B: OUTER_B,
+    Uw: WIDE_Uw, Dw: WIDE_Dw, Rw: WIDE_Rw, Lw: WIDE_Lw, Fw: WIDE_Fw, Bw: WIDE_Bw
+};
+exports.FACE_MOVE_EFFECTS = FACE_MOVE_EFFECTS;
+// ---------------------------------------------------------------------------
+// Apply a single move to a state
+// ---------------------------------------------------------------------------
+function applyEffect(state, effect) {
+    const cp = new Uint8Array(types_js_1.CORNER_COUNT);
+    const co = new Uint8Array(types_js_1.CORNER_COUNT);
+    const wp = new Uint8Array(types_js_1.WING_COUNT);
+    const centers = new Uint8Array(types_js_1.CENTER_COUNT);
+    for (let i = 0; i < types_js_1.CORNER_COUNT; i++) {
+        cp[i] = state.cp[effect.cperm[i]];
+        co[i] = (state.co[effect.cperm[i]] + effect.corient[i]) % 3;
+    }
+    for (let i = 0; i < types_js_1.WING_COUNT; i++) {
+        wp[i] = state.wp[effect.wperm[i]];
+    }
+    for (let i = 0; i < types_js_1.CENTER_COUNT; i++) {
+        centers[i] = state.centers[effect.ctperm[i]];
+    }
+    return { cp, co, wp, centers };
+}
+function parseMove(move) {
+    let face;
+    let suffix;
+    if (move.length >= 2 && move[1] === "w") {
+        face = move.slice(0, 2);
+        suffix = move.slice(2);
+    }
+    else {
+        face = move[0];
+        suffix = move.slice(1);
+    }
+    const turns = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    return { face: face, suffix, turns };
+}
+function applyCube4Move(state, move) {
+    const { face, turns } = parseMove(move);
+    const effect = FACE_MOVE_EFFECTS[face];
+    let current = state;
+    for (let i = 0; i < turns; i++) {
+        current = applyEffect(current, effect);
+    }
+    return current;
+}
+function applyCube4Algorithm(state, moves) {
+    let current = state;
+    for (const move of moves) {
+        current = applyCube4Move(current, move);
+    }
+    return current;
+}
+// ---------------------------------------------------------------------------
+// Move inversion
+// ---------------------------------------------------------------------------
+function invertCube4Move(move) {
+    const { face, suffix } = parseMove(move);
+    if (suffix === "2")
+        return move;
+    return `${face}${suffix === "'" ? "" : "'"}`;
+}
+function invertCube4Algorithm(moves) {
+    return [...moves].reverse().map(invertCube4Move);
+}
+// ---------------------------------------------------------------------------
+// Format / parse
+// ---------------------------------------------------------------------------
+function formatCube4Algorithm(moves) {
+    return moves.join(" ");
+}
+function parseCube4Algorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0)
+        return [];
+    return trimmed.split(/\s+/).map(parseCube4Move);
+}
+function parseCube4Move(value) {
+    if (types_js_1.CUBE4_ALL_MOVES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid 4x4 move: ${value}`);
+}

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

@@ -0,0 +1,135 @@
+"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.cube4ScrambleGenerator = void 0;
+exports.generateCube4Scramble = generateCube4Scramble;
+const state_js_1 = require("./state.js");
+const moves_js_1 = require("./moves.js");
+const facelets_js_1 = require("./facelets.js");
+const SCRAMBLE_LENGTH = 40;
+exports.cube4ScrambleGenerator = {
+    info: {
+        eventId: "444",
+        name: "4x4x4 Cube",
+        puzzle: "cube-4x4",
+        quality: "random-move",
+        generator: "cube4-random-move",
+        description: "Random-move 4x4 scramble with 40 moves."
+    },
+    generate(options = {}) {
+        return generateCube4Scramble(options);
+    }
+};
+async function generateCube4Scramble(options = {}) {
+    // Use cubing library for high-quality random-state 4x4 scrambles
+    const { randomScrambleForEvent } = await Promise.resolve().then(() => __importStar(require("cubing/scramble")));
+    const alg = await randomScrambleForEvent("444");
+    const scramble = alg.toString();
+    const moves = scramble.split(/\s+/);
+    const targetState = (0, moves_js_1.applyCube4Algorithm)((0, state_js_1.createSolvedCube4State)(), moves);
+    const faceletString = (0, facelets_js_1.formatCube4Facelets)((0, facelets_js_1.toCube4Facelets)(targetState));
+    const result = {
+        eventId: "444",
+        scramble,
+        moves,
+        quality: "random-state",
+        generator: "cubing-scramble",
+        metadata: {
+            totalMoves: moves.length,
+            distribution: "random-state",
+            state: targetState,
+            facelets: (0, facelets_js_1.toCube4Facelets)(targetState),
+            faceletString
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+const MAX_AXIS_BLOCK = 3;
+const ROTATION_PAIRS = {
+    "Uw": "Dw", "Dw": "Uw",
+    "Rw": "Lw", "Lw": "Rw",
+    "Fw": "Bw", "Bw": "Fw",
+};
+function getBaseMove(move) {
+    if (move.endsWith("2") || move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return move;
+}
+function getAxis(base) {
+    if (base.includes("R") || base.includes("L"))
+        return "X";
+    if (base.includes("U") || base.includes("D"))
+        return "Y";
+    if (base.includes("F") || base.includes("B"))
+        return "Z";
+    return "";
+}
+function isRedundant(moves, newMove) {
+    if (moves.length === 0)
+        return false;
+    const newBase = getBaseMove(newMove);
+    const newAxis = getAxis(newBase);
+    const lastBase = getBaseMove(moves[moves.length - 1]);
+    if (lastBase === newBase)
+        return true;
+    const lastAxis = getAxis(lastBase);
+    if (newAxis !== lastAxis)
+        return false;
+    const basesInBlock = new Set();
+    basesInBlock.add(lastBase);
+    let blockLength = 1;
+    for (let i = moves.length - 2; i >= 0; i--) {
+        const base = getBaseMove(moves[i]);
+        if (getAxis(base) === newAxis) {
+            basesInBlock.add(base);
+            blockLength++;
+        }
+        else {
+            break;
+        }
+    }
+    if (basesInBlock.has(newBase))
+        return true;
+    const complement = ROTATION_PAIRS[newBase];
+    if (complement && basesInBlock.has(complement))
+        return true;
+    if (blockLength >= MAX_AXIS_BLOCK)
+        return true;
+    return false;
+}

package/dist-cjs/puzzles/cube4/state.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSolvedCube4State = createSolvedCube4State;
+exports.cloneCube4State = cloneCube4State;
+exports.cube4StatesEqual = cube4StatesEqual;
+exports.isSolvedCube4State = isSolvedCube4State;
+exports.areCentersReduced = areCentersReduced;
+exports.areWingsPaired = areWingsPaired;
+const types_js_1 = require("./types.js");
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+function createSolvedCube4State() {
+    const cp = new Uint8Array(types_js_1.CORNER_COUNT);
+    const co = new Uint8Array(types_js_1.CORNER_COUNT);
+    const wp = new Uint8Array(types_js_1.WING_COUNT);
+    const centers = new Uint8Array(types_js_1.CENTER_COUNT);
+    for (let i = 0; i < types_js_1.CORNER_COUNT; i++)
+        cp[i] = i;
+    for (let i = 0; i < types_js_1.WING_COUNT; i++)
+        wp[i] = i;
+    for (let i = 0; i < types_js_1.CENTER_COUNT; i++) {
+        centers[i] = Math.floor(i / types_js_1.CENTERS_PER_FACE);
+    }
+    return { cp, co, wp, centers };
+}
+// ---------------------------------------------------------------------------
+// Clone
+// ---------------------------------------------------------------------------
+function cloneCube4State(s) {
+    return {
+        cp: new Uint8Array(s.cp),
+        co: new Uint8Array(s.co),
+        wp: new Uint8Array(s.wp),
+        centers: new Uint8Array(s.centers)
+    };
+}
+// ---------------------------------------------------------------------------
+// Equality
+// ---------------------------------------------------------------------------
+function cube4StatesEqual(a, b) {
+    return (typedArrayEqual(a.cp, b.cp) &&
+        typedArrayEqual(a.co, b.co) &&
+        typedArrayEqual(a.wp, b.wp) &&
+        typedArrayEqual(a.centers, b.centers));
+}
+function isSolvedCube4State(state) {
+    return cube4StatesEqual(state, createSolvedCube4State());
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Check if centers are "reduced" — each face has exactly 4 centers of its color.
+ */
+function areCentersReduced(state) {
+    const counts = new Uint8Array(types_js_1.FACE_COUNT);
+    for (let i = 0; i < types_js_1.CENTER_COUNT; i++) {
+        counts[state.centers[i]] = counts[state.centers[i]] + 1;
+    }
+    for (let i = 0; i < types_js_1.FACE_COUNT; i++) {
+        if (counts[i] !== types_js_1.CENTERS_PER_FACE)
+            return false;
+    }
+    return true;
+}
+/**
+ * Check if wings are paired — wings 2k and 2k+1 occupy the same
+ * 3x3-edge slot (i.e. ⌊wp[pos]/2⌋ matches for the two positions
+ * in each pair slot).
+ */
+function areWingsPaired(state) {
+    for (let pair = 0; pair < 12; pair++) {
+        const posA = pair * 2;
+        const posB = pair * 2 + 1;
+        const pieceA = state.wp[posA];
+        const pieceB = state.wp[posB];
+        // Both wings in this slot must belong to the same 3x3-edge
+        if (Math.floor(pieceA / 2) !== Math.floor(pieceB / 2))
+            return false;
+    }
+    return true;
+}
+function typedArrayEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}

package/dist-cjs/puzzles/cube4/types.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * 4x4x4 Cube Types and Constants
+ *
+ * Piece counts:
+ *  - 8 corners (same as 3x3, with permutation and orientation)
+ *  - 24 wings (edge pieces without orientation)
+ *  - 24 centers (4 per face, identified by color 0-5)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUBE4_OUTER_MOVES = exports.CUBE4_ALL_MOVES = exports.CUBE4_FACE_MOVES = exports.B = exports.L = exports.D = exports.F = exports.R = exports.U = exports.CENTERS_PER_FACE = exports.FACE_COUNT = exports.CENTER_COUNT = exports.WING_COUNT = exports.CORNER_COUNT = void 0;
+exports.CORNER_COUNT = 8;
+exports.WING_COUNT = 24;
+exports.CENTER_COUNT = 24;
+exports.FACE_COUNT = 6;
+exports.CENTERS_PER_FACE = 4;
+// ---------- Faces ----------
+// Face indices: U=0, R=1, F=2, D=3, L=4, B=5
+exports.U = 0;
+exports.R = 1;
+exports.F = 2;
+exports.D = 3;
+exports.L = 4;
+exports.B = 5;
+exports.CUBE4_FACE_MOVES = [
+    "U", "D", "R", "L", "F", "B",
+    "Uw", "Dw", "Rw", "Lw", "Fw", "Bw"
+];
+exports.CUBE4_ALL_MOVES = exports.CUBE4_FACE_MOVES.flatMap((face) => [`${face}`, `${face}2`, `${face}'`]);
+// Outer-only moves (used in certain reduction phases)
+exports.CUBE4_OUTER_MOVES = [
+    "U", "U2", "U'", "D", "D2", "D'",
+    "R", "R2", "R'", "L", "L2", "L'",
+    "F", "F2", "F'", "B", "B2", "B'"
+];
+/**
+ * Corner numbering (same as 3x3):
+ *  0=URF  1=UFL  2=ULB  3=UBR
+ *  4=DFR  5=DLF  6=DBL  7=DRB
+ *
+ * Wing numbering (24 wings, grouped by the 3x3-edge they belong to):
+ *  The two wings of each 3x3 edge are numbered consecutively.
+ *  Wing 2k and Wing 2k+1 form the pair for 3x3 edge k.
+ *
+ *  Pair  0 (UR): wings  0, 1
+ *  Pair  1 (UF): wings  2, 3
+ *  Pair  2 (UL): wings  4, 5
+ *  Pair  3 (UB): wings  6, 7
+ *  Pair  4 (DR): wings  8, 9
+ *  Pair  5 (DF): wings 10, 11
+ *  Pair  6 (DL): wings 12, 13
+ *  Pair  7 (DB): wings 14, 15
+ *  Pair  8 (FR): wings 16, 17
+ *  Pair  9 (FL): wings 18, 19
+ *  Pair 10 (BL): wings 20, 21
+ *  Pair 11 (BR): wings 22, 23
+ *
+ * Center numbering (4 centers per face, in reading order of inner 2x2):
+ *  Face U: centers  0- 3
+ *  Face R: centers  4- 7
+ *  Face F: centers  8-11
+ *  Face D: centers 12-15
+ *  Face L: centers 16-19
+ *  Face B: centers 20-23
+ */

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCube5Scramble = exports.cube5ScrambleGenerator = exports.SCRAMBLE_LENGTH = exports.CUBE5_ALL_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "CUBE5_ALL_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE5_ALL_MOVES; } });
+Object.defineProperty(exports, "SCRAMBLE_LENGTH", { enumerable: true, get: function () { return types_js_1.SCRAMBLE_LENGTH; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "cube5ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube5ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube5Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube5Scramble; } });

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cube5ScrambleGenerator = void 0;
+exports.generateCube5Scramble = generateCube5Scramble;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+exports.cube5ScrambleGenerator = {
+    info: {
+        eventId: "555",
+        name: "5x5x5 Cube",
+        puzzle: "cube-5x5",
+        quality: "random-move",
+        generator: "cube5-random-move",
+        description: "Random-move 5x5 scramble with 60 moves."
+    },
+    generate(options = {}) {
+        return generateCube5Scramble(options);
+    }
+};
+function generateCube5Scramble(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const moves = [];
+    for (let i = 0; i < types_js_1.SCRAMBLE_LENGTH; i++) {
+        let move;
+        do {
+            move = random.choice(types_js_1.CUBE5_ALL_MOVES);
+        } while (isRedundant(moves, move));
+        moves.push(move);
+    }
+    const scramble = moves.join(" ");
+    const result = {
+        eventId: "555",
+        scramble,
+        moves,
+        quality: "random-move",
+        generator: "cube5-random-move",
+        metadata: {
+            totalMoves: moves.length,
+            distribution: "random-move-wca-format"
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+const MAX_AXIS_BLOCK = 4;
+function getBaseMove(move) {
+    if (move.endsWith("2") || move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return move;
+}
+function getAxis(base) {
+    if (base.includes("R") || base.includes("L"))
+        return "X";
+    if (base.includes("U") || base.includes("D"))
+        return "Y";
+    if (base.includes("F") || base.includes("B"))
+        return "Z";
+    return "";
+}
+function isRedundant(moves, newMove) {
+    if (moves.length === 0)
+        return false;
+    const newBase = getBaseMove(newMove);
+    const newAxis = getAxis(newBase);
+    const lastBase = getBaseMove(moves[moves.length - 1]);
+    // No same base move consecutively
+    if (lastBase === newBase)
+        return true;
+    const lastAxis = getAxis(lastBase);
+    // Different axis: always allowed
+    if (newAxis !== lastAxis)
+        return false;
+    // Same axis: scan the current block
+    const basesInBlock = new Set();
+    basesInBlock.add(lastBase);
+    let blockLength = 1;
+    for (let i = moves.length - 2; i >= 0; i--) {
+        const base = getBaseMove(moves[i]);
+        if (getAxis(base) === newAxis) {
+            basesInBlock.add(base);
+            blockLength++;
+        }
+        else {
+            break;
+        }
+    }
+    // No same base within the block
+    if (basesInBlock.has(newBase))
+        return true;
+    // Max block length
+    if (blockLength >= MAX_AXIS_BLOCK)
+        return true;
+    return false;
+}

package/dist-cjs/puzzles/cube5x5/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCRAMBLE_LENGTH = exports.CUBE5_ALL_MOVES = void 0;
+const BASE_MOVES = ["U", "D", "R", "L", "F", "B", "Uw", "Dw", "Rw", "Lw", "Fw", "Bw"];
+const SUFFIXES = ["", "2", "'"];
+exports.CUBE5_ALL_MOVES = BASE_MOVES.flatMap((base) => SUFFIXES.map(suffix => `${base}${suffix}`));
+exports.SCRAMBLE_LENGTH = 60;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCube6Scramble = exports.cube6ScrambleGenerator = exports.SCRAMBLE_LENGTH = exports.CUBE6_ALL_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "CUBE6_ALL_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE6_ALL_MOVES; } });
+Object.defineProperty(exports, "SCRAMBLE_LENGTH", { enumerable: true, get: function () { return types_js_1.SCRAMBLE_LENGTH; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "cube6ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube6ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube6Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube6Scramble; } });