@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist-cjs/puzzles/cube4/reduction/solve.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * Full 4x4 solve orchestration: reduction (phases 1-3) + the 3x3 finish
+ * (phase 4), returning the move sequence that solves the given state.
+ * The scramble for a sampled state is the inverted solution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveCube4State = solveCube4State;
+const moves_js_1 = require("../moves.js");
+const center1_js_1 = require("./center1.js");
+const center2_js_1 = require("./center2.js");
+const center3_js_1 = require("./center3.js");
+const pairing_coordinate_js_1 = require("./pairing-coordinate.js");
+const edge3_js_1 = require("./edge3.js");
+const phase3_search_js_1 = require("./phase3-search.js");
+const phase4_js_1 = require("./phase4.js");
+const index_js_1 = require("../../cube3/solver/index.js");
+const state_js_1 = require("../state.js");
+function cornerPermutationParity(cp) {
+    let parity = 0;
+    const seen = new Array(8).fill(false);
+    for (let start = 0; start < 8; start++) {
+        if (seen[start] || cp[start] === start)
+            continue;
+        let length = 0;
+        let current = start;
+        while (!seen[current]) {
+            seen[current] = true;
+            current = cp[current];
+            length++;
+        }
+        parity ^= (length - 1) & 1;
+    }
+    return parity;
+}
+const ROT_MOVES = {
+    "x": ["Rw", "Lw'"],
+    "y": ["Uw", "Dw'"],
+    "z": ["Fw", "Bw'"],
+    "x'": ["Rw'", "Lw"],
+    "y'": ["Uw'", "Dw"],
+    "z'": ["Fw'", "Bw"]
+};
+const VALID_24_ORIENTATIONS = (() => {
+    const map = new Map();
+    const solved = (0, state_js_1.createSolvedCube4State)();
+    const queue = [{ state: solved, path: [] }];
+    map.set(`${solved.centers[0]},${solved.centers[4]},${solved.centers[8]}`, []);
+    while (queue.length > 0) {
+        const { state, path } = queue.shift();
+        for (const [rot, moves] of Object.entries(ROT_MOVES)) {
+            const nextState = (0, moves_js_1.applyCube4Algorithm)(state, moves);
+            const key = `${nextState.centers[0]},${nextState.centers[4]},${nextState.centers[8]}`;
+            if (!map.has(key)) {
+                const nextPath = [...path, rot];
+                map.set(key, nextPath);
+                queue.push({ state: nextState, path: nextPath });
+            }
+        }
+    }
+    return map;
+})();
+const ROT_MAP = {
+    "x": { "U": "B", "R": "R", "F": "U", "D": "F", "L": "L", "B": "D" },
+    "x'": { "U": "F", "R": "R", "F": "D", "D": "B", "L": "L", "B": "U" },
+    "y": { "U": "U", "R": "F", "F": "L", "D": "D", "L": "B", "B": "R" },
+    "y'": { "U": "U", "R": "B", "F": "R", "D": "D", "L": "F", "B": "L" },
+    "z": { "U": "R", "R": "D", "F": "F", "D": "L", "L": "U", "B": "B" },
+    "z'": { "U": "L", "R": "U", "F": "F", "D": "R", "L": "D", "B": "B" }
+};
+const INVERT_ROT = {
+    "x": "x'", "x'": "x",
+    "y": "y'", "y'": "y",
+    "z": "z'", "z'": "z"
+};
+function rotateMove(move, rot) {
+    const map = ROT_MAP[rot];
+    const face = move[0];
+    const newFace = map[face];
+    return (newFace + move.slice(1));
+}
+function rotateAlgorithm(alg, rotSeq) {
+    let res = [...alg];
+    for (const r of rotSeq) {
+        res = res.map((m) => rotateMove(m, r));
+    }
+    return res;
+}
+function invertRotationSequence(rotSeq) {
+    return [...rotSeq].reverse().map((r) => INVERT_ROT[r]);
+}
+function applyCubeRotation(state, rotSeq) {
+    let s = state;
+    for (const r of rotSeq) {
+        s = (0, moves_js_1.applyCube4Algorithm)(s, ROT_MOVES[r]);
+    }
+    return s;
+}
+const STANDARD_ORDER = [
+    "U", "U2", "U'", "R", "R2", "R'", "F", "F2", "F'", "D", "D2", "D'",
+    "L", "L2", "L'", "B", "B2", "B'",
+    "Uw", "Uw2", "Uw'", "Rw", "Rw2", "Rw'", "Fw", "Fw2", "Fw'",
+    "Dw", "Dw2", "Dw'", "Lw", "Lw2", "Lw'", "Bw", "Bw2", "Bw'"
+];
+const STD_INDEX = new Map(STANDARD_ORDER.map((m, i) => [m, i]));
+function baseOf(move) {
+    return move.replace(/[2']$/, "");
+}
+function axisClass(base) {
+    return { U: 0, D: 0, R: 1, L: 1, F: 2, B: 2 }[base];
+}
+function isCancelled(previous, current) {
+    const pb = baseOf(previous);
+    const cb = baseOf(current);
+    if (pb === cb)
+        return true;
+    if (axisClass(pb) === axisClass(cb)) {
+        return STD_INDEX.get(previous) > STD_INDEX.get(current);
+    }
+    return false;
+}
+function solveCenter1Diverse(centers, urf, tables, cap = 80) {
+    const startMask = (0, center1_js_1.center1Mask)(centers, urf);
+    const solutions = [];
+    const path = [];
+    const minH = (0, center1_js_1.getCenter1Distance)(startMask, tables);
+    for (let maxD = minH; maxD <= minH + 1; maxD++) {
+        const dfs = (mask, depth, lm) => {
+            if (solutions.length >= cap)
+                return true;
+            const h = (0, center1_js_1.getCenter1Distance)(mask, tables);
+            if (h === 0) {
+                solutions.push({
+                    moves: path.slice(0, depth).map((m) => center1_js_1.CENTER1_MOVES[m]),
+                    length: depth
+                });
+                return false;
+            }
+            if (depth + h > maxD)
+                return false;
+            for (let m = 0; m < center1_js_1.CENTER1_MOVES.length; m++) {
+                if (lm >= 0 && Math.floor(lm / 3) === Math.floor(m / 3))
+                    continue;
+                const next = (0, center1_js_1.applyCenter1Move)(mask, tables.moveMaps, m);
+                path[depth] = m;
+                if (dfs(next, depth + 1, m))
+                    return true;
+            }
+            return false;
+        };
+        if (dfs(startMask, 0, -1))
+            break;
+    }
+    return solutions;
+}
+const phase3Solver = new phase3_search_js_1.FastPhase3Solver();
+/**
+ * Solve a 4x4 state with the reduction solver + the cube3 two-phase finish.
+ * `solveCube3` is injected (the cube3 solver loads its tables lazily).
+ */
+async function solveCube4State(state, tables, solveCube3) {
+    const sym = (0, edge3_js_1.getSymTables)();
+    const cornerParity = cornerPermutationParity(state.cp);
+    const p1Sols = solveCenter1Diverse(state.centers, 0, tables.center1, 80);
+    p1Sols.sort((a, b) => a.moves.length - b.moves.length);
+    const minP1 = p1Sols[0]?.moves.length ?? 0;
+    const candidates = [];
+    const moveLog = new Array(25);
+    function searchPhase2(c, r, maxl, lm, depth, bridgeState, p1Moves) {
+        if ((0, center2_js_1.isCenter2Goal)(c, r)) {
+            if (maxl === 0) {
+                const moves2 = moveLog.slice(0, depth).map((m) => center2_js_1.CENTER2_MOVES[m]);
+                const s2 = (0, moves_js_1.applyCube4Algorithm)(bridgeState, moves2);
+                const pairing = (0, pairing_coordinate_js_1.encodePairingState)(s2.wp);
+                if (pairing) {
+                    const eXc = (pairing.parity ^ cornerParity);
+                    const ct3 = (0, center3_js_1.encodeCenter3)(s2, eXc).coordinate;
+                    const cdist = tables.center3.pruning[ct3];
+                    if (cdist !== 0xff && cdist !== undefined) {
+                        const symIdx = (0, edge3_js_1.getMvSymFrom)(pairing.edge, pairing.edge, 20, sym.sym2Raw, sym.sym2Mask, sym.raw2Sym, sym.mvrot, sym.mvroto);
+                        const edist = (tables.edge3.distances[(symIdx >> 3) >> 1] >>
+                            (((symIdx >> 3) & 1) * 4)) &
+                            0x0f;
+                        candidates.push({
+                            moves12: [...p1Moves, ...moves2],
+                            length12: p1Moves.length + moves2.length,
+                            ct3,
+                            cdist,
+                            edge: pairing.edge,
+                            edist,
+                            value: p1Moves.length + moves2.length + Math.max(cdist, edist),
+                            state: s2
+                        });
+                        if (candidates.length >= 60)
+                            return true;
+                    }
+                }
+            }
+            return false;
+        }
+        if (maxl === 0)
+            return false;
+        for (let m = 0; m < center2_js_1.CENTER2_SEARCH_MOVES.length; m++) {
+            if (lm >= 0 && isCancelled(center2_js_1.CENTER2_SEARCH_MOVES[lm], center2_js_1.CENTER2_SEARCH_MOVES[m])) {
+                continue;
+            }
+            const nc = tables.center2.ctMove[c * center2_js_1.CENTER2_MOVES.length + m];
+            const nr = tables.center2.rlMove[r * center2_js_1.CENTER2_MOVES.length + m];
+            const prun = tables.center2.pruning[nc * center2_js_1.CENTER2_RL_STATES + nr];
+            if (prun >= maxl)
+                continue;
+            moveLog[depth] = m;
+            if (searchPhase2(nc, nr, maxl - 1, m, depth + 1, bridgeState, p1Moves))
+                return true;
+        }
+        return false;
+    }
+    let MAX_P2 = 8;
+    do {
+        OUTER: for (let length12 = minP1; length12 < minP1 + 14; length12++) {
+            for (const p1 of p1Sols) {
+                if (p1.moves.length > length12)
+                    break;
+                const length2 = length12 - p1.moves.length;
+                if (length2 > MAX_P2 || length2 < 0)
+                    continue;
+                const s1 = (0, moves_js_1.applyCube4Algorithm)(state, p1.moves);
+                const bridge = (0, center2_js_1.center2Bridge)(s1);
+                if (!bridge)
+                    continue;
+                const prun = tables.center2.pruning[bridge.encoded.ct * center2_js_1.CENTER2_RL_STATES + bridge.encoded.rl];
+                if (prun > length2)
+                    continue;
+                const fullP1Moves = [...p1.moves, ...bridge.alignment];
+                if (searchPhase2(bridge.encoded.ct, bridge.encoded.rl, length2, -1, 0, bridge.state, fullP1Moves)) {
+                    break OUTER;
+                }
+            }
+        }
+        MAX_P2++;
+    } while (candidates.length === 0 && MAX_P2 <= 14);
+    if (candidates.length === 0) {
+        throw new Error("4x4 solve: no valid phase 2 candidates found.");
+    }
+    candidates.sort((a, b) => a.value - b.value);
+    let solvedCand = null;
+    let solvedMoves3 = null;
+    let standardReduced = null;
+    let rotPath = [];
+    let rotToStandard = [];
+    let MAX_LENGTH3 = 13;
+    let yieldCounter = 0;
+    do {
+        for (let length123 = candidates[0].value; length123 < 45; length123++) {
+            for (let i = 0; i < Math.min(candidates.length, 60); i++) {
+                const cand = candidates[i];
+                if (cand.value > length123)
+                    break;
+                const length3 = length123 - cand.length12;
+                if (length3 > MAX_LENGTH3 || length3 < 0)
+                    continue;
+                if (cand.edist <= length3 && cand.cdist <= length3) {
+                    if (++yieldCounter % 100 === 0)
+                        await new Promise(r => setTimeout(r, 0));
+                    const moves3 = await phase3Solver.solveLength(cand.edge, cand.ct3, cand.edist, length3, tables.center3, tables.edge3.distances);
+                    if (!moves3)
+                        continue;
+                    const reduced = (0, moves_js_1.applyCube4Algorithm)(cand.state, moves3);
+                    const key = `${reduced.centers[0]},${reduced.centers[4]},${reduced.centers[8]}`;
+                    const path = VALID_24_ORIENTATIONS.get(key);
+                    if (!path)
+                        continue;
+                    solvedCand = cand;
+                    solvedMoves3 = moves3;
+                    rotPath = path;
+                    rotToStandard = invertRotationSequence(rotPath);
+                    standardReduced = applyCubeRotation(reduced, rotToStandard);
+                    break;
+                }
+            }
+            if (solvedCand)
+                break;
+        }
+        MAX_LENGTH3++;
+    } while (!solvedCand && MAX_LENGTH3 <= 18);
+    if (!solvedCand || !solvedMoves3 || !standardReduced) {
+        throw new Error("4x4 solve: reduction failed across all candidates.");
+    }
+    const cube3State = (0, phase4_js_1.toCube3State)(standardReduced);
+    if (!cube3State) {
+        throw new Error("4x4 solve: failed to convert reduced 4x4 state to 3x3 state.");
+    }
+    let cube3Solution;
+    try {
+        cube3Solution = await solveCube3(cube3State);
+    }
+    catch (error) {
+        if (error instanceof index_js_1.Cube3Phase2SearchError) {
+            throw error;
+        }
+        throw error;
+    }
+    const fullSolInOriginal = [
+        ...solvedCand.moves12,
+        ...solvedMoves3,
+        ...rotateAlgorithm(cube3Solution.moves, rotPath)
+    ];
+    const fullSolToStandard = [
+        ...fullSolInOriginal,
+        ...rotToStandard.flatMap((r) => ROT_MOVES[r])
+    ];
+    const scramble = (0, moves_js_1.invertCube4Algorithm)(fullSolToStandard);
+    return { moves: fullSolToStandard, scramble };
+}

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

@@ -1,4 +1,9 @@
 "use strict";
+/**
+ * The 4x4 scramble generator: sample a uniform random state, solve it with
+ * the reduction solver (phases 1-4), and invert the solution. The scramble
+ * always reproduces the sampled target state and facelets exactly.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -34,102 +39,140 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cube4ScrambleGenerator = void 0;
+exports.isCube4TablesLoaded = isCube4TablesLoaded;
 exports.generateCube4Scramble = generateCube4Scramble;
-const state_js_1 = require("./state.js");
 const moves_js_1 = require("./moves.js");
+const random_state_js_1 = require("./random-state.js");
+const state_js_1 = require("./state.js");
 const facelets_js_1 = require("./facelets.js");
-const SCRAMBLE_LENGTH = 40;
+const solve_js_1 = require("./reduction/solve.js");
+const index_js_1 = require("../cube3/solver/index.js");
+let cachedTables;
+async function loadCube4Tables(baseUrl) {
+    if (cachedTables)
+        return cachedTables;
+    const isBrowser = typeof window !== "undefined" ||
+        typeof document !== "undefined" ||
+        (typeof self !== "undefined" && typeof self.importScripts === "function") ||
+        (typeof navigator !== "undefined" && /Moz|WebKit/.test(navigator.userAgent));
+    const isNode = typeof process !== "undefined" && process.versions?.node != null;
+    if (isBrowser && !isNode) {
+        const loader = await Promise.resolve().then(() => __importStar(require(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        "./reduction/browser-loader.js")));
+        const cached = loader.getCachedCube4Tables();
+        if (cached) {
+            cachedTables = cached;
+            return cached;
+        }
+        const tables = await loader.loadCube4ReductionTablesBrowser(baseUrl);
+        cachedTables = tables;
+        return tables;
+    }
+    const loader = await Promise.resolve().then(() => __importStar(require(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./reduction/node-loader.js")));
+    const tables = await loader.loadCube4ReductionTables();
+    cachedTables = tables;
+    return tables;
+}
+function isCube4TablesLoaded() {
+    // For the scrambler retry logic, we need to know if tables are already
+    // loaded to avoid re-loading on every attempt.
+    try {
+        // @ts-ignore
+        const loader = globalThis;
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 exports.cube4ScrambleGenerator = {
     info: {
         eventId: "444",
         name: "4x4x4 Cube",
         puzzle: "cube-4x4",
         quality: "random-state",
-        generator: "cubing-scramble",
-        description: "Random-state 4x4 scramble generated by cubing.js."
+        generator: "cube4-reduction",
+        description: "Random-state 4x4 scramble via the reduction solver (centers + pairing + 3x3 finish)."
     },
     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++;
+    const tables = await loadCube4Tables();
+    let lastError;
+    // Retry with different states if the solver fails to find a physical
+    // reduction (some random states are outside the solver's effective
+    // horizon with the current candidate/length caps).
+    for (let attempt = 0; attempt < 5; attempt++) {
+        let attemptOptions;
+        if (attempt === 0) {
+            attemptOptions = options;
         }
         else {
-            break;
+            attemptOptions = { ...options };
+            if (options.seed !== undefined) {
+                attemptOptions.seed = `${options.seed}:retry${attempt}`;
+            }
+            else {
+                delete attemptOptions.seed;
+            }
+        }
+        const attemptState = (0, random_state_js_1.generateRandomCube4State)(attemptOptions);
+        try {
+            const solvePromise = (0, solve_js_1.solveCube4State)(attemptState, tables, (cube3State) => (0, index_js_1.solveCube3State)(cube3State));
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("4x4 solve: timeout")), 20000));
+            const { scramble: scrambleMoves } = await Promise.race([solvePromise, timeoutPromise]);
+            if (!options.skipValidation) {
+                const scrambledState = (0, moves_js_1.applyCube4Algorithm)((0, state_js_1.createSolvedCube4State)(), scrambleMoves);
+                if (!(0, state_js_1.cube4StatesEqual)(scrambledState, attemptState)) {
+                    throw new Error("Generated 4x4 scramble does not reproduce the target random state.");
+                }
+            }
+            const facelets = (0, facelets_js_1.toCube4Facelets)(attemptState);
+            const result = {
+                eventId: "444",
+                scramble: (0, moves_js_1.formatCube4Algorithm)(scrambleMoves),
+                moves: scrambleMoves,
+                quality: "random-state",
+                generator: "cube4-reduction",
+                metadata: {
+                    generator: "cube4-reduction",
+                    state: attemptState,
+                    facelets,
+                    faceletString: (0, facelets_js_1.formatCube4Facelets)(facelets),
+                    distribution: "random-state",
+                    ...options.metadata
+                }
+            };
+            if (options.seed !== undefined) {
+                result.seed = options.seed;
+            }
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            // Retry on deterministic reduction / 3x3 failures (some random states are
+            // outside the solver's horizon with the current caps).
+            const msg = error instanceof Error ? error.message : String(error);
+            const isPhase2Error = typeof error?.name === "string" &&
+                error.name.includes("Cube3Phase2");
+            if (error instanceof Error &&
+                (msg.includes("reduction failed") ||
+                    msg.includes("failed to convert") ||
+                    msg.includes("no valid phase 2") ||
+                    msg.includes("timeout") ||
+                    isPhase2Error ||
+                    msg.includes("Phase 2 solution not found"))) {
+                continue;
+            }
+            throw error;
         }
     }
-    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;
+    throw lastError;
 }

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCube4State = validateCube4State;
+exports.isOneMoveFromSolvedCube4State = isOneMoveFromSolvedCube4State;
+exports.isTrivialCube4State = isTrivialCube4State;
+exports.isAllowedRandomCube4State = isAllowedRandomCube4State;
+const types_js_1 = require("./types.js");
+const moves_js_1 = require("./moves.js");
+const state_js_1 = require("./state.js");
+function validateCube4State(state) {
+    const errors = [
+        ...validatePermutation("corner", state.cp, types_js_1.CORNER_COUNT),
+        ...validateOrientations("corner", state.co, types_js_1.CORNER_COUNT, 3),
+        ...validatePermutation("wing", state.wp, types_js_1.WING_COUNT),
+        ...validateCenters(state.centers)
+    ];
+    if (errors.length === 0) {
+        const cornerOrientation = sum(state.co) % 3;
+        if (cornerOrientation !== 0) {
+            errors.push("Corner orientation sum must be divisible by 3.");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+// The 36 single-move states (12 base faces × 3 suffixes), precomputed once so
+// the hot random-state path checks "solved or one move from solved" with pure
+// array comparisons.
+const ONE_MOVE_FROM_SOLVED_STATES = types_js_1.CUBE4_ALL_MOVES.map((move) => (0, moves_js_1.applyCube4Move)((0, state_js_1.createSolvedCube4State)(), move));
+function isOneMoveFromSolvedCube4State(state) {
+    return ONE_MOVE_FROM_SOLVED_STATES.some((candidate) => (0, state_js_1.cube4StatesEqual)(candidate, state));
+}
+function isTrivialCube4State(state) {
+    return (0, state_js_1.isSolvedCube4State)(state) || isOneMoveFromSolvedCube4State(state);
+}
+function isAllowedRandomCube4State(state) {
+    return validateCube4State(state).valid && !isTrivialCube4State(state);
+}
+function validatePermutation(label, permutation, length) {
+    const errors = [];
+    const seen = new Set();
+    if (permutation.length !== length) {
+        errors.push(`${label} permutation must contain ${length} values.`);
+    }
+    for (const value of permutation) {
+        if (!Number.isInteger(value) || value < 0 || value >= length) {
+            errors.push(`${label} permutation contains out-of-range value: ${value}.`);
+            continue;
+        }
+        if (seen.has(value)) {
+            errors.push(`${label} permutation contains duplicate value: ${value}.`);
+        }
+        seen.add(value);
+    }
+    return errors;
+}
+function validateOrientations(label, orientations, length, modulo) {
+    const errors = [];
+    if (orientations.length !== length) {
+        errors.push(`${label} orientation must contain ${length} values.`);
+    }
+    for (const value of orientations) {
+        if (!Number.isInteger(value) || value < 0 || value >= modulo) {
+            errors.push(`${label} orientation contains out-of-range value: ${value}.`);
+        }
+    }
+    return errors;
+}
+function validateCenters(centers) {
+    const errors = [];
+    if (centers.length !== types_js_1.CENTER_COUNT) {
+        errors.push(`centers must contain ${types_js_1.CENTER_COUNT} values.`);
+    }
+    const counts = new Uint8Array(types_js_1.FACE_COUNT);
+    for (const value of centers) {
+        if (!Number.isInteger(value) || value < 0 || value >= types_js_1.FACE_COUNT) {
+            errors.push(`center contains out-of-range color: ${value}.`);
+            continue;
+        }
+        counts[value] = counts[value] + 1;
+    }
+    for (let face = 0; face < types_js_1.FACE_COUNT; face += 1) {
+        if (counts[face] !== types_js_1.CENTERS_PER_FACE) {
+            errors.push(`center color ${face} must appear exactly ${types_js_1.CENTERS_PER_FACE} times.`);
+        }
+    }
+    return errors;
+}
+function sum(values) {
+    let total = 0;
+    for (const value of values) {
+        total += value;
+    }
+    return total;
+}