@cubingcenter/scrambler 0.1.0

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

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCube3Move = applyCube3Move;
+exports.applyCube3Algorithm = applyCube3Algorithm;
+exports.invertCube3Algorithm = invertCube3Algorithm;
+exports.parseCube3Algorithm = parseCube3Algorithm;
+exports.formatCube3Algorithm = formatCube3Algorithm;
+exports.parseCube3Move = parseCube3Move;
+exports.invertCube3Move = invertCube3Move;
+const types_js_1 = require("./types.js");
+const state_js_1 = require("./state.js");
+const FACE_MOVE_TABLES = {
+    U: {
+        corners: { permutation: [3, 0, 1, 2, 4, 5, 6, 7], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+        edges: { permutation: [3, 0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    D: {
+        corners: { permutation: [0, 1, 2, 3, 5, 6, 7, 4], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+        edges: { permutation: [0, 1, 2, 3, 5, 6, 7, 4, 8, 9, 10, 11], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    R: {
+        corners: { permutation: [4, 1, 2, 0, 7, 5, 6, 3], orientation: [2, 0, 0, 1, 1, 0, 0, 2] },
+        edges: { permutation: [8, 1, 2, 3, 11, 5, 6, 7, 4, 9, 10, 0], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    L: {
+        corners: { permutation: [0, 2, 6, 3, 4, 1, 5, 7], orientation: [0, 1, 2, 0, 0, 2, 1, 0] },
+        edges: { permutation: [0, 1, 10, 3, 4, 5, 9, 7, 8, 2, 6, 11], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    F: {
+        corners: { permutation: [1, 5, 2, 3, 0, 4, 6, 7], orientation: [1, 2, 0, 0, 2, 1, 0, 0] },
+        edges: { permutation: [0, 9, 2, 3, 4, 8, 6, 7, 1, 5, 10, 11], orientation: [0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0] }
+    },
+    B: {
+        corners: { permutation: [0, 1, 3, 7, 4, 5, 2, 6], orientation: [0, 0, 1, 2, 0, 0, 2, 1] },
+        edges: { permutation: [0, 1, 2, 11, 4, 5, 6, 10, 8, 9, 3, 7], orientation: [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1] }
+    }
+};
+function applyCube3Move(state, move) {
+    const { face, turns } = parseMoveParts(move);
+    let next = (0, state_js_1.cloneCube3State)(state);
+    for (let index = 0; index < turns; index += 1) {
+        next = applyFaceMove(next, FACE_MOVE_TABLES[face]);
+    }
+    return next;
+}
+function applyCube3Algorithm(state, moves) {
+    return moves.reduce((current, move) => applyCube3Move(current, move), state);
+}
+function invertCube3Algorithm(moves) {
+    return [...moves].reverse().map(invertCube3Move);
+}
+function parseCube3Algorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    const faces = { U: 'U', D: 'D', R: 'R', L: 'L', F: 'F', B: 'B' };
+    const rotateX = (times) => {
+        for (let i = 0; i < times; i++) {
+            const tempU = faces.U, tempF = faces.F, tempD = faces.D, tempB = faces.B;
+            faces.U = tempF;
+            faces.F = tempD;
+            faces.D = tempB;
+            faces.B = tempU;
+        }
+    };
+    const rotateY = (times) => {
+        for (let i = 0; i < times; i++) {
+            const tempF = faces.F, tempL = faces.L, tempB = faces.B, tempR = faces.R;
+            faces.F = tempR;
+            faces.R = tempB;
+            faces.B = tempL;
+            faces.L = tempF;
+        }
+    };
+    const rotateZ = (times) => {
+        for (let i = 0; i < times; i++) {
+            const tempU = faces.U, tempR = faces.R, tempD = faces.D, tempL = faces.L;
+            faces.U = tempL;
+            faces.L = tempD;
+            faces.D = tempR;
+            faces.R = tempU;
+        }
+    };
+    const result = [];
+    const tokens = trimmed.split(/\s+/).filter(Boolean);
+    for (const token of tokens) {
+        const base = token[0];
+        if (!base)
+            continue;
+        let isWide = false;
+        let isPrime = false;
+        let isDouble = false;
+        let moveName = base;
+        if (token.length > 1) {
+            if (token.includes('w')) {
+                isWide = true;
+                moveName = base.toUpperCase();
+            }
+            if (token.includes("'"))
+                isPrime = true;
+            if (token.includes("2"))
+                isDouble = true;
+        }
+        if (base >= 'a' && base <= 'z' && base !== 'x' && base !== 'y' && base !== 'z') {
+            isWide = true;
+            moveName = base.toUpperCase();
+        }
+        const suffix = isDouble ? "2" : isPrime ? "'" : "";
+        const oppSuffix = isDouble ? "2" : isPrime ? "" : "'";
+        const times = isDouble ? 2 : isPrime ? 3 : 1;
+        const emit = (f, suff) => result.push(`${faces[f]}${suff}`);
+        switch (moveName) {
+            case 'U':
+            case 'D':
+            case 'R':
+            case 'L':
+            case 'F':
+            case 'B':
+                if (isWide) {
+                    if (moveName === 'R') {
+                        emit('R', suffix);
+                        emit('L', oppSuffix);
+                        rotateX(times);
+                    }
+                    else if (moveName === 'L') {
+                        emit('L', suffix);
+                        emit('R', oppSuffix);
+                        rotateX((4 - times) % 4);
+                    }
+                    else if (moveName === 'U') {
+                        emit('U', suffix);
+                        emit('D', oppSuffix);
+                        rotateY(times);
+                    }
+                    else if (moveName === 'D') {
+                        emit('D', suffix);
+                        emit('U', oppSuffix);
+                        rotateY((4 - times) % 4);
+                    }
+                    else if (moveName === 'F') {
+                        emit('F', suffix);
+                        emit('B', oppSuffix);
+                        rotateZ(times);
+                    }
+                    else if (moveName === 'B') {
+                        emit('B', suffix);
+                        emit('F', oppSuffix);
+                        rotateZ((4 - times) % 4);
+                    }
+                }
+                else {
+                    emit(moveName, suffix);
+                }
+                break;
+            case 'M':
+                emit('L', suffix);
+                emit('R', oppSuffix);
+                rotateX((4 - times) % 4);
+                break;
+            case 'E':
+                emit('D', suffix);
+                emit('U', oppSuffix);
+                rotateY((4 - times) % 4);
+                break;
+            case 'S':
+                emit('F', suffix);
+                emit('B', oppSuffix);
+                rotateZ(times);
+                break;
+            case 'x':
+                rotateX(times);
+                break;
+            case 'y':
+                rotateY(times);
+                break;
+            case 'z':
+                rotateZ(times);
+                break;
+            default:
+                throw new Error(`Invalid 3x3 move: ${token}`);
+        }
+    }
+    return result;
+}
+function formatCube3Algorithm(moves) {
+    return moves.join(" ");
+}
+function parseCube3Move(value) {
+    if (types_js_1.CUBE3_MOVES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid 3x3 move: ${value}`);
+}
+function invertCube3Move(move) {
+    const { face, suffix } = parseMoveParts(move);
+    if (suffix === "2") {
+        return move;
+    }
+    return `${face}${suffix === "'" ? "" : "'"}`;
+}
+function applyFaceMove(state, table) {
+    return {
+        corners: {
+            permutation: table.corners.permutation.map((source) => state.corners.permutation[source]),
+            orientation: table.corners.permutation.map((source, target) => ((state.corners.orientation[source] + table.corners.orientation[target]) % 3))
+        },
+        edges: {
+            permutation: table.edges.permutation.map((source) => state.edges.permutation[source]),
+            orientation: table.edges.permutation.map((source, target) => ((state.edges.orientation[source] + table.edges.orientation[target]) % 2))
+        }
+    };
+}
+function parseMoveParts(move) {
+    const face = move[0];
+    const suffix = move.slice(1);
+    const turns = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    return { face, suffix, turns };
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomCube3State = generateRandomCube3State;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+const validation_js_1 = require("./validation.js");
+const subset_state_js_1 = require("./subset-state.js");
+function generateRandomCube3State(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    if (options.subset) {
+        return (0, subset_state_js_1.generateSubsetCube3State)(options.subset, random);
+    }
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomCube3State)(state)) {
+            return state;
+        }
+    }
+    throw new Error("Unable to generate a non-trivial random 3x3 state.");
+}
+function createLegalRandomState(random) {
+    const cornerPermutation = shuffledRange(types_js_1.CORNER_COUNT, random);
+    const edgePermutation = shuffledRange(types_js_1.EDGE_COUNT, random);
+    if ((0, validation_js_1.permutationParity)(cornerPermutation) !== (0, validation_js_1.permutationParity)(edgePermutation)) {
+        swap(edgePermutation, 0, 1);
+    }
+    return {
+        corners: {
+            permutation: cornerPermutation,
+            orientation: randomOrientations(types_js_1.CORNER_COUNT, 3, random)
+        },
+        edges: {
+            permutation: edgePermutation,
+            orientation: randomOrientations(types_js_1.EDGE_COUNT, 2, random)
+        }
+    };
+}
+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);
+        swap(values, index, swapIndex);
+    }
+    return values;
+}
+function randomOrientations(length, modulo, random) {
+    const orientations = Array(length).fill(0);
+    let total = 0;
+    for (let index = 0; index < length - 1; index += 1) {
+        const orientation = random.nextInt(modulo);
+        orientations[index] = orientation;
+        total += orientation;
+    }
+    orientations[length - 1] = (modulo - (total % modulo)) % modulo;
+    return orientations;
+}
+function swap(values, left, right) {
+    const temporary = values[left];
+    values[left] = values[right];
+    values[right] = temporary;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cube3ScrambleGenerator = void 0;
+exports.generateCube3Scramble = generateCube3Scramble;
+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 index_js_1 = require("./solver/index.js");
+exports.cube3ScrambleGenerator = {
+    info: {
+        eventId: "333",
+        name: "3x3x3 Cube",
+        puzzle: "cube-3x3",
+        quality: "random-state",
+        generator: "cube3-two-phase",
+        description: "Random-state 3x3 scramble generated by the CubingCenter two-phase solver."
+    },
+    generate(options = {}) {
+        return generateCube3Scramble(options);
+    }
+};
+async function generateCube3Scramble(options = {}) {
+    const state = (0, random_state_js_1.generateRandomCube3State)(options);
+    const solution = await (0, index_js_1.solveCube3State)(state);
+    const scrambleMoves = (0, moves_js_1.invertCube3Algorithm)(solution.moves);
+    if (!options.skipValidation) {
+        const scrambledState = (0, moves_js_1.applyCube3Algorithm)((0, state_js_1.createSolvedCube3State)(), scrambleMoves);
+        if (!(0, state_js_1.cube3StatesEqual)(scrambledState, state)) {
+            throw new Error("Generated 3x3 scramble does not reproduce the target random state.");
+        }
+        if (!(0, state_js_1.isSolvedCube3State)(solution.state)) {
+            throw new Error("Generated 3x3 solution does not solve the target random state.");
+        }
+        if (scrambleMoves.length < 2) {
+            throw new Error("Generated 3x3 scramble is too short.");
+        }
+    }
+    const facelets = (0, facelets_js_1.toCube3Facelets)(state);
+    const result = {
+        eventId: "333",
+        scramble: (0, moves_js_1.formatCube3Algorithm)(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "cube3-two-phase",
+        metadata: {
+            generator: "cube3-two-phase",
+            generatorVersion: "1.0.0",
+            faceletString: (0, facelets_js_1.formatCube3Facelets)(facelets),
+            state: JSON.parse(JSON.stringify(state)),
+            solutionMoves: solution.moves,
+            solutionDepth: solution.depth,
+            phase1Depth: solution.phase1.depth,
+            phase2Depth: solution.phase2.depth,
+            visitedNodes: solution.visitedNodes,
+            ...options.metadata
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}

package/dist-cjs/puzzles/cube3/solver/browser-loader.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedBrowserTables = getCachedBrowserTables;
+exports.clearCachedBrowserTables = clearCachedBrowserTables;
+exports.loadBrowserTables = loadBrowserTables;
+let browserTables;
+function resolveBaseUrl(provided) {
+    if (provided) {
+        return provided.replace(/\/$/, "");
+    }
+    if (typeof document !== "undefined") {
+        const script = document.currentScript;
+        if (script?.src) {
+            const base = new URL(".", script.src).href;
+            return base.replace(/\/$/, "");
+        }
+    }
+    return ".";
+}
+function getCachedBrowserTables() {
+    return browserTables;
+}
+function clearCachedBrowserTables() {
+    browserTables = undefined;
+}
+async function loadBrowserTables(baseUrl) {
+    if (browserTables) {
+        return browserTables;
+    }
+    const resolvedBase = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolvedBase);
+    browserTables = {
+        phase1Moves: manifest.phase1Moves,
+        phase2Moves: manifest.phase2Moves,
+        moveTables: {
+            cornerOrientation: await fetchMoveTable(resolvedBase, manifest.moveTables.cornerOrientation),
+            edgeOrientation: await fetchMoveTable(resolvedBase, manifest.moveTables.edgeOrientation),
+            udSlice: await fetchMoveTable(resolvedBase, manifest.moveTables.udSlice),
+            cornerPermutation: await fetchMoveTable(resolvedBase, manifest.moveTables.cornerPermutation),
+            udEdgePermutation: await fetchMoveTable(resolvedBase, manifest.moveTables.udEdgePermutation),
+            slicePermutation: await fetchMoveTable(resolvedBase, manifest.moveTables.slicePermutation)
+        },
+        pruningTables: {
+            cornerOrientation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerOrientation),
+            edgeOrientation: await fetchPruningTable(resolvedBase, manifest.pruningTables.edgeOrientation),
+            udSlice: await fetchPruningTable(resolvedBase, manifest.pruningTables.udSlice),
+            cornerOrientationEdgeOrientation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerOrientationEdgeOrientation),
+            cornerPermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerPermutation),
+            udEdgePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.udEdgePermutation),
+            slicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.slicePermutation),
+            cornerPermutationSlicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerPermutationSlicePermutation),
+            udEdgePermutationSlicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.udEdgePermutationSlicePermutation)
+        }
+    };
+    return browserTables;
+}
+const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
+async function cachedFetch(url) {
+    // Try Cache API first
+    if (typeof caches !== "undefined") {
+        try {
+            const cache = await caches.open(CACHE_NAME);
+            const cached = await cache.match(url);
+            if (cached) {
+                return cached.arrayBuffer();
+            }
+            const response = await fetch(url);
+            if (response.ok) {
+                // Clone before reading so we can store the clone
+                await cache.put(url, response.clone());
+            }
+            return response.arrayBuffer();
+        }
+        catch {
+            // Cache API failed (e.g. quota exceeded, private mode) — fall through
+        }
+    }
+    // Fallback: plain fetch
+    const response = await fetch(url);
+    return response.arrayBuffer();
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/puzzles/cube3/solver/generated/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const manifest = await response.json();
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported 3x3 solver table manifest version: ${manifest.version}`);
+    }
+    return manifest;
+}
+async function fetchMoveTable(baseUrl, entry) {
+    const url = `${baseUrl}/puzzles/cube3/solver/generated/${entry.file}`;
+    const buffer = await cachedFetch(url);
+    const expectedBytes = entry.range * entry.moves.length * 4;
+    if (buffer.byteLength !== expectedBytes) {
+        throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
+    }
+    const values = new Int32Array(entry.range * entry.moves.length);
+    const view = new DataView(buffer);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = view.getInt32(index * 4, true);
+    }
+    return {
+        coordinate: entry.coordinate,
+        moves: entry.moves,
+        range: entry.range,
+        solvedCoordinate: entry.solvedCoordinate,
+        values,
+        checksum: checksum(values)
+    };
+}
+async function fetchPruningTable(baseUrl, entry) {
+    const url = `${baseUrl}/puzzles/cube3/solver/generated/${entry.file}`;
+    const buffer = await cachedFetch(url);
+    const expectedBytes = Math.ceil(entry.range / 2);
+    if (buffer.byteLength !== expectedBytes) {
+        throw new Error(`Invalid byte size for ${entry.coordinate} pruning table.`);
+    }
+    const values = new Uint8Array(buffer);
+    return {
+        coordinate: entry.coordinate,
+        moves: entry.moves,
+        range: entry.range,
+        values,
+        checksum: checksum(values),
+        maxDepth: entry.maxDepth ?? 0
+    };
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < values.length; index += 1) {
+        hash ^= values[index];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}