@cubingcenter/scrambler 0.4.0 → 0.5.0

package/dist-cjs/puzzles/skewb/solver/node-loader.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGeneratedSkewbSolverTables = readGeneratedSkewbSolverTables;
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const table_metadata_js_1 = require("./table-metadata.js");
+const GENERATED_DIRECTORY = "puzzles/skewb/solver/generated";
+function readGeneratedSkewbSolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, "manifest.json"), "utf8"));
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported skewb solver table manifest version: ${manifest.version}`);
+    }
+    const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.permutationTable.checksum);
+    const orientationTable = readUint16Table(assetDirectory, manifest.files.orientationTable, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.orientationTable.checksum);
+    const centersTable = readUint16Table(assetDirectory, manifest.files.centersTable, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.centersTable.checksum);
+    const helpersBuffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, manifest.files.helpers.file));
+    if (helpersBuffer.length !== manifest.files.helpers.entries) {
+        throw new Error(`Invalid byte size for ${manifest.files.helpers.file}`);
+    }
+    assertChecksum(manifest.files.helpers.file, checksum(new Uint8Array(helpersBuffer)), table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.checksum);
+    const evenCenterRank = new Uint16Array(table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes / 2);
+    for (let i = 0; i < evenCenterRank.length; i++) {
+        evenCenterRank[i] = helpersBuffer.readUInt16LE(i * 2);
+    }
+    const orientClass = new Uint8Array(helpersBuffer.subarray(table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes + table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.orientClassBytes));
+    const r7SetsBuffer = helpersBuffer.subarray(table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes + table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.orientClassBytes);
+    const r7Sets = new Uint16Array(table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.r7SetsEntries);
+    for (let i = 0; i < r7Sets.length; i++) {
+        r7Sets[i] = r7SetsBuffer.readUInt16LE(i * 2);
+    }
+    const policyBuffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, manifest.files.policyTable.file));
+    if (policyBuffer.length !== manifest.files.policyTable.entries) {
+        throw new Error(`Invalid byte size for ${manifest.files.policyTable.file}`);
+    }
+    const policyTable = new Uint8Array(policyBuffer);
+    assertChecksum(manifest.files.policyTable.file, checksum(policyTable), table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.policyTable.checksum);
+    return { permutationTable, orientationTable, centersTable, policyTable, evenCenterRank, orientClass, r7Sets };
+}
+function readUint16Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(entry.entries);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = buffer.readUInt16LE(index * 2);
+    }
+    assertChecksum(entry.file, checksum(values), expectedChecksum);
+    return values;
+}
+function resolveGeneratedAssetDirectory() {
+    const envDirectory = process.env.CUBINGCENTER_SCRAMBLER_TABLES_DIR;
+    if (envDirectory && (0, node_fs_1.existsSync)(node_path_1.default.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(candidate, "manifest.json"))) {
+            return candidate;
+        }
+    }
+    throw new Error("Unable to find generated skewb solver tables. Run pnpm skewb:tables.");
+}
+function getAssetDirectoryCandidates() {
+    const cwd = process.cwd();
+    const candidates = [
+        node_path_1.default.join(cwd, "src", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = (0, node_module_1.createRequire)(node_path_1.default.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(node_path_1.default.join(node_path_1.default.dirname(packageEntry), GENERATED_DIRECTORY));
+    }
+    catch {
+        // Source-tree usage is covered by the cwd candidates.
+    }
+    return candidates;
+}
+function assertChecksum(file, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Checksum mismatch for ${file}: expected ${expected}, received ${actual}.`);
+    }
+}
+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;
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveSkewb = solveSkewb;
+exports.solveSkewbWithInfo = solveSkewbWithInfo;
+exports.solveSkewbSync = solveSkewbSync;
+exports.verifySkewbScramble = verifySkewbScramble;
+exports.verifySkewbSolution = verifySkewbSolution;
+const tables_js_1 = require("./tables.js");
+async function solveSkewb(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTables(state).moves;
+}
+async function solveSkewbWithInfo(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTables(state);
+}
+// Synchronous variant for scripts that have already ensured tables are loaded
+function solveSkewbSync(state) {
+    if (!tables_js_1.POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTables(state).moves;
+}
+function solveWithTables(state) {
+    const policy = tables_js_1.POLICY_TABLE;
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    if (state.corners.permutation[0] !== 0) {
+        throw new Error("The Skewb solver requires the UFR corner (index 0) to be fixed " +
+            "as the frame of reference. Please normalize the state before solving.");
+    }
+    let r7 = (0, tables_js_1.getPerm7Index)(state.corners.permutation);
+    let rO = (0, tables_js_1.getOrientationIndex)(state.corners.orientation);
+    let rC = (0, tables_js_1.getCenterIndex)(state.centers);
+    let rank = (0, tables_js_1.rankFromComponents)(r7, rO, rC);
+    if (rank === tables_js_1.SOLVED_RANK) {
+        return { moves: [], depth: 0 };
+    }
+    const moves = [];
+    while (rank !== tables_js_1.SOLVED_RANK) {
+        const m = (0, tables_js_1.getPolicyMoveFromPacked)(policy, rank);
+        moves.push(tables_js_1.SKEWB_MOVES[m]);
+        r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
+        rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];
+        rC = centersTable[rC * tables_js_1.MOVE_COUNT + m];
+        rank = (0, tables_js_1.rankFromComponents)(r7, rO, rC);
+    }
+    return { moves, depth: moves.length };
+}
+// ---------------------------------------------------------------------------
+// Coordinate-walking verification (no full state clones)
+// ---------------------------------------------------------------------------
+const MOVE_INDEX = {};
+for (let i = 0; i < tables_js_1.SKEWB_MOVES.length; i++) {
+    MOVE_INDEX[tables_js_1.SKEWB_MOVES[i]] = i;
+}
+function walkSkewbCoordinates(start, moves) {
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    if (!permTable || !orientTable || !centersTable) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let { r7, rO, rC } = start;
+    for (const move of moves) {
+        const m = MOVE_INDEX[move];
+        r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
+        rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];
+        rC = centersTable[rC * tables_js_1.MOVE_COUNT + m];
+    }
+    return { r7, rO, rC };
+}
+function verifySkewbScramble(state, scrambleMoves) {
+    const final = walkSkewbCoordinates({ r7: 0, rO: 0, rC: 0 }, scrambleMoves);
+    return (final.r7 === (0, tables_js_1.getPerm7Index)(state.corners.permutation) &&
+        final.rO === (0, tables_js_1.getOrientationIndex)(state.corners.orientation) &&
+        final.rC === (0, tables_js_1.getCenterIndex)(state.centers));
+}
+function verifySkewbSolution(state, solutionMoves) {
+    const final = walkSkewbCoordinates({
+        r7: (0, tables_js_1.getPerm7Index)(state.corners.permutation),
+        rO: (0, tables_js_1.getOrientationIndex)(state.corners.orientation),
+        rC: (0, tables_js_1.getCenterIndex)(state.centers)
+    }, solutionMoves);
+    return final.r7 === 0 && final.rO === 0 && final.rC === 0;
+}

package/dist-cjs/puzzles/skewb/solver/table-metadata.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKEWB_SOLVER_TABLE_METADATA = void 0;
+exports.SKEWB_SOLVER_TABLE_METADATA = {
+    permutationTable: {
+        entries: 40320, // PERMUTATION_COUNT (5040) * MOVE_COUNT (8)
+        checksum: 3073532981
+    },
+    orientationTable: {
+        entries: 17496, // ORIENTATION_COUNT (2187) * MOVE_COUNT (8)
+        checksum: 2128852053
+    },
+    centersTable: {
+        entries: 5760, // CENTER_COUNT (720) * MOVE_COUNT (8)
+        checksum: 360885765
+    },
+    helpers: {
+        evenCenterRankBytes: 1440, // 720 * 2 (Uint16, sentinel 65535)
+        orientClassBytes: 2187,
+        r7SetsEntries: 12960, // EVEN_CENTER_COUNT (360) * ORIENT_CLASS_COUNT (9) * PER_SET_SIZE (4)
+        entries: 1440 + 2187 + 12960 * 2,
+        checksum: 4284555735
+    },
+    policyTable: {
+        entries: 1180980, // ceil(STATE_COUNT (3_149_280) * 3 / 8)
+        checksum: 1294485891,
+        maxDepth: 11
+    }
+};