@cubingcenter/scrambler 0.4.1 → 0.5.0

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

@@ -1,6 +1,39 @@
 "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.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.skewbScrambleGenerator = exports.generateSkewbScramble = exports.getStateFromIndex = exports.getStateIndex = exports.solveSkewb = exports.toSkewbFacelets = exports.getSkewbFaceOrder = exports.formatSkewbFacelets = exports.createSolvedSkewbFacelets = exports.generateRandomSkewbState = exports.isOneMoveFromSolvedSkewbState = exports.isAllowedRandomSkewbState = exports.validateSkewbState = exports.permutationParity = exports.skewbStatesEqual = exports.isSolvedSkewbState = exports.createSolvedSkewbState = exports.cloneSkewbState = exports.parseSkewbMove = exports.parseSkewbAlgorithm = exports.invertSkewbMove = exports.invertSkewbAlgorithm = exports.formatSkewbAlgorithm = exports.applySkewbMove = exports.applySkewbAlgorithm = exports.SKEWB_FACES = exports.SKEWB_MOVES = void 0;
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.skewbScrambleGenerator = exports.generateSkewbScramble = exports.solver = exports.getStateFromIndex = exports.getStateIndex = exports.verifySkewbSolution = exports.verifySkewbScramble = exports.solveSkewbSync = exports.solveSkewbWithInfo = exports.solveSkewb = exports.toSkewbFacelets = exports.getSkewbFaceOrder = exports.formatSkewbFacelets = exports.createSolvedSkewbFacelets = exports.generateRandomSkewbState = exports.isOneMoveFromSolvedSkewbState = exports.isAllowedRandomSkewbState = exports.validateSkewbState = exports.permutationParity = exports.skewbStatesEqual = exports.isSolvedSkewbState = exports.createSolvedSkewbState = exports.cloneSkewbState = exports.parseSkewbMove = exports.parseSkewbAlgorithm = exports.invertSkewbMove = exports.invertSkewbAlgorithm = exports.formatSkewbAlgorithm = exports.applySkewbMove = exports.applySkewbAlgorithm = exports.SKEWB_FACES = exports.SKEWB_MOVES = void 0;
 const index_js_1 = require("../../core/index.js");
 const scrambler_js_1 = require("./scrambler.js");
 (0, index_js_1.registerScrambleGenerator)(scrambler_js_1.skewbScrambleGenerator);
@@ -32,16 +65,21 @@ Object.defineProperty(exports, "createSolvedSkewbFacelets", { enumerable: true,
 Object.defineProperty(exports, "formatSkewbFacelets", { enumerable: true, get: function () { return facelets_js_1.formatSkewbFacelets; } });
 Object.defineProperty(exports, "getSkewbFaceOrder", { enumerable: true, get: function () { return facelets_js_1.getSkewbFaceOrder; } });
 Object.defineProperty(exports, "toSkewbFacelets", { enumerable: true, get: function () { return facelets_js_1.toSkewbFacelets; } });
-var solver_js_1 = require("./solver.js");
-Object.defineProperty(exports, "solveSkewb", { enumerable: true, get: function () { return solver_js_1.solveSkewb; } });
-Object.defineProperty(exports, "getStateIndex", { enumerable: true, get: function () { return solver_js_1.getStateIndex; } });
-Object.defineProperty(exports, "getStateFromIndex", { enumerable: true, get: function () { return solver_js_1.getStateFromIndex; } });
+var index_js_2 = require("./solver/index.js");
+Object.defineProperty(exports, "solveSkewb", { enumerable: true, get: function () { return index_js_2.solveSkewb; } });
+Object.defineProperty(exports, "solveSkewbWithInfo", { enumerable: true, get: function () { return index_js_2.solveSkewbWithInfo; } });
+Object.defineProperty(exports, "solveSkewbSync", { enumerable: true, get: function () { return index_js_2.solveSkewbSync; } });
+Object.defineProperty(exports, "verifySkewbScramble", { enumerable: true, get: function () { return index_js_2.verifySkewbScramble; } });
+Object.defineProperty(exports, "verifySkewbSolution", { enumerable: true, get: function () { return index_js_2.verifySkewbSolution; } });
+Object.defineProperty(exports, "getStateIndex", { enumerable: true, get: function () { return index_js_2.getStateIndex; } });
+Object.defineProperty(exports, "getStateFromIndex", { enumerable: true, get: function () { return index_js_2.getStateFromIndex; } });
+exports.solver = __importStar(require("./solver/index.js"));
 var scrambler_js_2 = require("./scrambler.js");
 Object.defineProperty(exports, "generateSkewbScramble", { enumerable: true, get: function () { return scrambler_js_2.generateSkewbScramble; } });
 Object.defineProperty(exports, "skewbScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.skewbScrambleGenerator; } });
-var index_js_2 = require("../../core/index.js");
-Object.defineProperty(exports, "generateScramble", { enumerable: true, get: function () { return index_js_2.generateScramble; } });
-Object.defineProperty(exports, "generateScrambles", { enumerable: true, get: function () { return index_js_2.generateScrambles; } });
-Object.defineProperty(exports, "getEventInfo", { enumerable: true, get: function () { return index_js_2.getEventInfo; } });
-Object.defineProperty(exports, "getSupportedEvents", { enumerable: true, get: function () { return index_js_2.getSupportedEvents; } });
-Object.defineProperty(exports, "initializeScrambler", { enumerable: true, get: function () { return index_js_2.initializeScrambler; } });
+var index_js_3 = require("../../core/index.js");
+Object.defineProperty(exports, "generateScramble", { enumerable: true, get: function () { return index_js_3.generateScramble; } });
+Object.defineProperty(exports, "generateScrambles", { enumerable: true, get: function () { return index_js_3.generateScrambles; } });
+Object.defineProperty(exports, "getEventInfo", { enumerable: true, get: function () { return index_js_3.getEventInfo; } });
+Object.defineProperty(exports, "getSupportedEvents", { enumerable: true, get: function () { return index_js_3.getSupportedEvents; } });
+Object.defineProperty(exports, "initializeScrambler", { enumerable: true, get: function () { return index_js_3.initializeScrambler; } });

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

@@ -2,29 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRandomSkewbState = generateRandomSkewbState;
 const index_js_1 = require("../../random/index.js");
-const validation_js_1 = require("./validation.js");
-const moves_js_1 = require("./moves.js");
-const state_js_1 = require("./state.js");
-const types_js_1 = require("./types.js");
-function generateRandomSkewbState(options = {}) {
+const index_js_2 = require("./solver/index.js");
+async function generateRandomSkewbState(options = {}) {
+    await (0, index_js_2.ensureTablesLoaded)();
     const random = (0, index_js_1.createRandomSource)(options.seed);
     const rejectTrivial = options.rejectTrivial ?? true;
+    const trivialRanks = rejectTrivial ? getTrivialRanks() : null;
+    // Exact uniform sampling: the compact rank is a bijection over the
+    // 3,149,280 reachable states, so a uniform rank gives every state exactly
+    // the same probability (unlike a finite random walk, which only approaches
+    // uniformity). Trivial states (solved / one move from solved) are rejected
+    // and resampled, which keeps the conditional distribution uniform.
     for (let attempt = 0; attempt < 100; attempt++) {
-        const state = createLegalRandomState(random);
-        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomSkewbState)(state))
-            return state;
+        const rank = random.nextInt(index_js_2.STATE_COUNT);
+        if (trivialRanks && trivialRanks.has(rank))
+            continue;
+        return (0, index_js_2.getStateFromRank)(rank);
     }
     throw new Error("Unable to generate a non-trivial random Skewb state.");
 }
-function createLegalRandomState(random) {
-    // Generate a random reachable Skewb state via random walk from solved.
-    // Skewb has 3,149,280 reachable states with WCA moves (fixed corner).
-    // A walk of 30+ moves is sufficient to approach uniform distribution.
-    let state = (0, state_js_1.createSolvedSkewbState)();
-    const walkLength = 30 + random.nextInt(5); // 30-34 moves
-    for (let i = 0; i < walkLength; i++) {
-        const move = random.choice([...types_js_1.SKEWB_MOVES]);
-        state = (0, moves_js_1.applySkewbMove)(state, move);
+let trivialRanks = null;
+function getTrivialRanks() {
+    if (!trivialRanks) {
+        const ranks = new Set([index_js_2.SOLVED_RANK]);
+        for (let m = 0; m < index_js_2.MOVE_COUNT; m++) {
+            const r7 = (0, index_js_2.getPermutationTransition)(0, m);
+            const rO = (0, index_js_2.getOrientationTransition)(0, m);
+            const rC = (0, index_js_2.getCentersTransition)(0, m);
+            ranks.add((0, index_js_2.rankFromComponents)(r7, rO, rC));
+        }
+        trivialRanks = ranks;
     }
-    return state;
+    return trivialRanks;
 }

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

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.skewbScrambleGenerator = void 0;
 exports.generateSkewbScramble = generateSkewbScramble;
 const random_state_js_1 = require("./random-state.js");
-const state_js_1 = require("./state.js");
 const moves_js_1 = require("./moves.js");
-const solver_js_1 = require("./solver.js");
+const index_js_1 = require("./solver/index.js");
 const facelets_js_1 = require("./facelets.js");
 exports.skewbScrambleGenerator = {
     info: {
@@ -13,25 +12,23 @@ exports.skewbScrambleGenerator = {
         name: "Skewb",
         puzzle: "skewb",
         quality: "random-state",
-        generator: "skewb-bfs",
-        description: "Random-state Skewb scramble generated by an optimal bidirectional BFS solver.",
+        generator: "skewb-optimal",
+        description: "Random-state Skewb scramble generated by an optimal solver with precalculated tables.",
     },
     generate(options = {}) {
         return generateSkewbScramble(options);
     },
 };
 async function generateSkewbScramble(options = {}) {
-    const state = (0, random_state_js_1.generateRandomSkewbState)(options);
-    const solution = (0, solver_js_1.solveSkewb)(state);
+    const state = await (0, random_state_js_1.generateRandomSkewbState)(options);
+    const solution = await (0, index_js_1.solveSkewb)(state);
     const scrambleMoves = (0, moves_js_1.invertSkewbAlgorithm)(solution);
     if (!options.skipValidation) {
-        const scrambledState = (0, moves_js_1.applySkewbAlgorithm)((0, state_js_1.createSolvedSkewbState)(), scrambleMoves);
-        if (!(0, state_js_1.skewbStatesEqual)(scrambledState, state)) {
+        // If the scramble reproduces the target state, its inverse (the
+        // solution) solves it by construction, so a single walk suffices.
+        if (!(0, index_js_1.verifySkewbScramble)(state, scrambleMoves)) {
             throw new Error("Generated Skewb scramble does not reproduce the target random state.");
         }
-        if (!(0, state_js_1.isSolvedSkewbState)((0, moves_js_1.applySkewbAlgorithm)(state, solution))) {
-            throw new Error("Generated Skewb solution does not solve the target random state.");
-        }
         if (scrambleMoves.length < 2)
             throw new Error("Generated Skewb scramble is too short.");
     }
@@ -41,7 +38,7 @@ async function generateSkewbScramble(options = {}) {
         scramble: (0, moves_js_1.formatSkewbAlgorithm)(scrambleMoves),
         moves: scrambleMoves,
         quality: "random-state",
-        generator: "skewb-bfs",
+        generator: "skewb-optimal",
         metadata: {
             state,
             facelets,

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedBrowserTables = getCachedBrowserTables;
+exports.clearCachedBrowserTables = clearCachedBrowserTables;
+exports.loadBrowserTables = loadBrowserTables;
+const table_metadata_js_1 = require("./table-metadata.js");
+const compressed_fetch_js_1 = require("../../shared/compressed-fetch.js");
+const TABLES_DIR = "puzzles/skewb/solver/generated";
+let cachedBrowserTables;
+function getCachedBrowserTables() {
+    return cachedBrowserTables;
+}
+function clearCachedBrowserTables() {
+    cachedBrowserTables = undefined;
+}
+async function loadBrowserTables(baseUrl) {
+    if (cachedBrowserTables) {
+        return cachedBrowserTables;
+    }
+    const resolved = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolved);
+    const [permTable, orientTable, centersTable, helpers, policy] = await Promise.all([
+        fetchUint16Table(resolved, manifest.files.permutationTable, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.permutationTable.entries),
+        fetchUint16Table(resolved, manifest.files.orientationTable, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.orientationTable.entries),
+        fetchUint16Table(resolved, manifest.files.centersTable, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.centersTable.entries),
+        fetchUint8Table(resolved, manifest.files.helpers, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers.entries),
+        fetchUint8Table(resolved, manifest.files.policyTable, table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.policyTable.entries)
+    ]);
+    const helpersOffset = table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA.helpers;
+    const evenCenterRank = new Uint16Array(helpersOffset.evenCenterRankBytes / 2);
+    const rankView = new DataView(helpers.buffer, helpers.byteOffset);
+    for (let i = 0; i < evenCenterRank.length; i++) {
+        evenCenterRank[i] = rankView.getUint16(i * 2, true);
+    }
+    const orientClass = helpers.subarray(helpersOffset.evenCenterRankBytes, helpersOffset.evenCenterRankBytes + helpersOffset.orientClassBytes);
+    const r7Sets = new Uint16Array(helpersOffset.r7SetsEntries);
+    const view = new DataView(helpers.buffer, helpers.byteOffset + helpersOffset.evenCenterRankBytes + helpersOffset.orientClassBytes);
+    for (let i = 0; i < r7Sets.length; i++) {
+        r7Sets[i] = view.getUint16(i * 2, true);
+    }
+    cachedBrowserTables = {
+        permutationTable: permTable,
+        orientationTable: orientTable,
+        centersTable,
+        policyTable: policy,
+        evenCenterRank,
+        orientClass,
+        r7Sets
+    };
+    return cachedBrowserTables;
+}
+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 ".";
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/puzzles/skewb/solver/generated/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load skewb solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}
+async function fetchUint16Table(baseUrl, entry, expectedEntries) {
+    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(expectedEntries);
+    const view = new DataView(buffer);
+    for (let i = 0; i < values.length; i++) {
+        values[i] = view.getUint16(i * 2, true);
+    }
+    return values;
+}
+async function fetchUint8Table(baseUrl, entry, expectedEntries) {
+    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    return new Uint8Array(buffer);
+}

package/dist-cjs/puzzles/skewb/solver/generated/manifest.json

@@ -0,0 +1,31 @@
+{
+  "version": 1,
+  "files": {
+    "permutationTable": {
+      "file": "permutation-table.bin",
+      "entries": 40320,
+      "checksum": 3073532981
+    },
+    "orientationTable": {
+      "file": "orientation-table.bin",
+      "entries": 17496,
+      "checksum": 2128852053
+    },
+    "centersTable": {
+      "file": "centers-table.bin",
+      "entries": 5760,
+      "checksum": 360885765
+    },
+    "helpers": {
+      "file": "helpers.bin",
+      "entries": 29547,
+      "checksum": 4284555735
+    },
+    "policyTable": {
+      "file": "policy.bin",
+      "entries": 1180980,
+      "checksum": 1294485891,
+      "maxDepth": 11
+    }
+  }
+}

package/dist-cjs/puzzles/skewb/solver/generated-assets.js

@@ -0,0 +1,60 @@
+"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.loadGeneratedSkewbSolverTables = loadGeneratedSkewbSolverTables;
+const browser_loader_js_1 = require("./browser-loader.js");
+let cachedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+async function loadGeneratedSkewbSolverTables() {
+    if (isBrowser()) {
+        const browserTables = (0, browser_loader_js_1.getCachedBrowserTables)();
+        if (browserTables)
+            return browserTables;
+        throw new Error("Skewb solver tables are not loaded. " +
+            "In browser environments, call `initializeScrambler(baseUrl)` " +
+            "before generating scrambles.");
+    }
+    cachedTables ??= await loadNodeTables();
+    return cachedTables;
+}
+async function loadNodeTables() {
+    const loader = await Promise.resolve().then(() => __importStar(require(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./node-loader.js")));
+    return loader.readGeneratedSkewbSolverTables();
+}

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

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGeneratedSkewbSolverTables = exports.SKEWB_SOLVER_TABLE_METADATA = void 0;
+__exportStar(require("./tables.js"), exports);
+__exportStar(require("./search.js"), exports);
+var table_metadata_js_1 = require("./table-metadata.js");
+Object.defineProperty(exports, "SKEWB_SOLVER_TABLE_METADATA", { enumerable: true, get: function () { return table_metadata_js_1.SKEWB_SOLVER_TABLE_METADATA; } });
+var generated_assets_js_1 = require("./generated-assets.js");
+Object.defineProperty(exports, "loadGeneratedSkewbSolverTables", { enumerable: true, get: function () { return generated_assets_js_1.loadGeneratedSkewbSolverTables; } });

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