@cubingcenter/scrambler 0.3.0 → 0.4.1

package/dist-cjs/puzzles/pyraminx/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.loadGeneratedPyraminxSolverTables = loadGeneratedPyraminxSolverTables;
+const browser_loader_js_1 = require("./browser-loader.js");
+let cachedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+async function loadGeneratedPyraminxSolverTables() {
+    if (isBrowser()) {
+        const browserTables = (0, browser_loader_js_1.getCachedBrowserTables)();
+        if (browserTables)
+            return browserTables;
+        throw new Error("Pyraminx 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.readGeneratedPyraminxSolverTables();
+}

package/dist-cjs/puzzles/pyraminx/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.loadGeneratedPyraminxSolverTables = exports.PYRAMINX_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, "PYRAMINX_SOLVER_TABLE_METADATA", { enumerable: true, get: function () { return table_metadata_js_1.PYRAMINX_SOLVER_TABLE_METADATA; } });
+var generated_assets_js_1 = require("./generated-assets.js");
+Object.defineProperty(exports, "loadGeneratedPyraminxSolverTables", { enumerable: true, get: function () { return generated_assets_js_1.loadGeneratedPyraminxSolverTables; } });

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

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGeneratedPyraminxSolverTables = readGeneratedPyraminxSolverTables;
+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/pyraminx/solver/generated";
+function readGeneratedPyraminxSolverTables() {
+    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 pyraminx solver table manifest version: ${manifest.version}`);
+    const centersTable = readUint8Table(assetDirectory, manifest.files.centersTable, table_metadata_js_1.PYRAMINX_SOLVER_TABLE_METADATA.centersTable.checksum);
+    const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, table_metadata_js_1.PYRAMINX_SOLVER_TABLE_METADATA.permutationTable.checksum);
+    const orientationTable = readUint8Table(assetDirectory, manifest.files.orientationTable, table_metadata_js_1.PYRAMINX_SOLVER_TABLE_METADATA.orientationTable.checksum);
+    const policyTable = readUint8Table(assetDirectory, manifest.files.policyTable, table_metadata_js_1.PYRAMINX_SOLVER_TABLE_METADATA.policyTable.checksum);
+    return { centersTable, permutationTable, orientationTable, policyTable };
+}
+function readUint8Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries)
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    const values = new Uint8Array(buffer);
+    assertChecksum(entry.file, checksum(values), expectedChecksum);
+    return values;
+}
+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 i = 0; i < values.length; i++)
+        values[i] = buffer.readUInt16LE(i * 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 pyraminx solver tables. Run pnpm pyraminx: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
+    }
+    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 i = 0; i < values.length; i++) {
+        hash ^= values[i];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solvePyraminx = solvePyraminx;
+exports.solvePyraminxWithInfo = solvePyraminxWithInfo;
+exports.solvePyraminxSync = solvePyraminxSync;
+exports.verifyPyraminxScramble = verifyPyraminxScramble;
+const tables_js_1 = require("./tables.js");
+async function solvePyraminx(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTables(state).moves;
+}
+async function solvePyraminxWithInfo(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTables(state);
+}
+function solveWithTables(state) {
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const policy = tables_js_1.POLICY_TABLE;
+    let c = (0, tables_js_1.getCentersIndex)(state.centers);
+    let p = (0, tables_js_1.getPermutationCompactIndex)(state.edgesPerm);
+    let o = (0, tables_js_1.getOrientationIndex)(state.edgesOrient);
+    let stateIndex = c + 81 * (p + tables_js_1.PERMUTATION_COUNT * o);
+    if (stateIndex === 0)
+        return { moves: [], depth: 0 };
+    const moves = [];
+    while (stateIndex !== 0) {
+        const m = (0, tables_js_1.getPolicyMoveFromPacked)(policy, stateIndex);
+        moves.push(tables_js_1.PYRAMINX_MOVES[m]);
+        c = centersTable[c * tables_js_1.MOVE_COUNT + m];
+        p = permTable[p * tables_js_1.MOVE_COUNT + m];
+        o = orientTable[o * tables_js_1.MOVE_COUNT + m];
+        stateIndex = c + 81 * (p + tables_js_1.PERMUTATION_COUNT * o);
+    }
+    return { moves, depth: moves.length };
+}
+// Synchronous variant for scripts that have already ensured tables are loaded
+function solvePyraminxSync(state) {
+    if (!tables_js_1.POLICY_TABLE)
+        throw new Error("Pyraminx tables not loaded");
+    return solveWithTables(state).moves;
+}
+const MOVE_INDEX = {
+    "U": 0, "U'": 1,
+    "L": 2, "L'": 3,
+    "R": 4, "R'": 5,
+    "B": 6, "B'": 7
+};
+const FACE_TIP = { U: 0, L: 1, R: 2, B: 3 };
+const TIP_MOVE = { u: 0, l: 1, r: 2, b: 3 };
+// Applies a full scramble (core + tips) over compact coordinate indexes and
+// compares against the target state. No full state clones; runs in O(moves).
+function verifyPyraminxScramble(state, finalMoves) {
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    if (!centersTable || !permTable || !orientTable) {
+        throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let c = 0;
+    let p = 0;
+    let o = 0;
+    const tips = [0, 0, 0, 0];
+    for (const move of finalMoves) {
+        const isInverse = move.endsWith("'");
+        const base = isInverse ? move.slice(0, -1) : move;
+        const faceTip = FACE_TIP[base];
+        if (faceTip !== undefined) {
+            const m = MOVE_INDEX[move];
+            c = centersTable[c * tables_js_1.MOVE_COUNT + m];
+            p = permTable[p * tables_js_1.MOVE_COUNT + m];
+            o = orientTable[o * tables_js_1.MOVE_COUNT + m];
+            tips[faceTip] = (tips[faceTip] + (isInverse ? 2 : 1)) % 3;
+        }
+        else {
+            const tipIndex = TIP_MOVE[base];
+            tips[tipIndex] = (tips[tipIndex] + (isInverse ? 2 : 1)) % 3;
+        }
+    }
+    return (c === (0, tables_js_1.getCentersIndex)(state.centers) &&
+        p === (0, tables_js_1.getPermutationCompactIndex)(state.edgesPerm) &&
+        o === (0, tables_js_1.getOrientationIndex)(state.edgesOrient) &&
+        tips[0] === state.tips[0] &&
+        tips[1] === state.tips[1] &&
+        tips[2] === state.tips[2] &&
+        tips[3] === state.tips[3]);
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PYRAMINX_SOLVER_TABLE_METADATA = void 0;
+exports.PYRAMINX_SOLVER_TABLE_METADATA = {
+    centersTable: {
+        entries: 648,
+        checksum: 4058180805
+    },
+    permutationTable: {
+        entries: 2880,
+        checksum: 4161414597
+    },
+    orientationTable: {
+        entries: 256,
+        checksum: 3608176069
+    },
+    policyTable: {
+        entries: 349920,
+        checksum: 4047562730,
+        maxDepth: 11
+    }
+};

package/dist-cjs/puzzles/pyraminx/solver/tables.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.CENTERS_TABLE = exports.PYRAMINX_MOVES = exports.POLICY_PACKED_ENTRIES = exports.STATE_COUNT = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.CENTERS_COUNT = exports.PERM_360_TO_720 = exports.PERM_720_TO_360 = exports.PERMUTATION_COUNT = exports.PERMUTATION_FULL_COUNT = void 0;
+exports.getPermutationIndex = getPermutationIndex;
+exports.getPermutationFromIndex = getPermutationFromIndex;
+exports.getOrientationIndex = getOrientationIndex;
+exports.getOrientationFromIndex = getOrientationFromIndex;
+exports.getCentersIndex = getCentersIndex;
+exports.getCentersFromIndex = getCentersFromIndex;
+exports.permutationParity = permutationParity;
+exports.getPermutationCompactIndex = getPermutationCompactIndex;
+exports.getPermutationCompactFromFull = getPermutationCompactFromFull;
+exports.getPermutationFullFromCompact = getPermutationFullFromCompact;
+exports.getStateIndex = getStateIndex;
+exports.getPyraminxStateFromIndex = getPyraminxStateFromIndex;
+exports.getPolicyMoveFromPacked = getPolicyMoveFromPacked;
+exports.generateCentersTable = generateCentersTable;
+exports.generatePermutationTable = generatePermutationTable;
+exports.generateOrientationTable = generateOrientationTable;
+exports.generatePolicyTable = generatePolicyTable;
+exports.checksum = checksum;
+exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.getPolicyMove = getPolicyMove;
+exports.getCentersTransition = getCentersTransition;
+exports.getPermutationTransition = getPermutationTransition;
+exports.getOrientationTransition = getOrientationTransition;
+exports.resetTablesForTests = resetTablesForTests;
+const generated_assets_js_1 = require("./generated-assets.js");
+const moves_js_1 = require("../moves.js");
+// ---------------------------------------------------------------------------
+// Coordinate encoding / decoding (kept from original solver.ts)
+// ---------------------------------------------------------------------------
+const FACT = [1, 1, 2, 6, 24, 120, 720];
+function getPermutationIndex(perm) {
+    let index = 0;
+    const n = perm.length;
+    for (let i = 0; i < n; i++) {
+        let count = 0;
+        for (let j = i + 1; j < n; j++) {
+            if (perm[j] < perm[i])
+                count++;
+        }
+        index += count * FACT[n - 1 - i];
+    }
+    return index;
+}
+function getPermutationFromIndex(index, n) {
+    const perm = Array(n).fill(0);
+    const temp = Array.from({ length: n }, (_, i) => i);
+    let val = index;
+    for (let i = 0; i < n; i++) {
+        const f = FACT[n - 1 - i];
+        const choice = Math.floor(val / f);
+        val %= f;
+        perm[i] = temp[choice];
+        temp.splice(choice, 1);
+    }
+    return perm;
+}
+function getOrientationIndex(orient) {
+    let index = 0;
+    for (let i = 0; i < 5; i++) {
+        index = (index << 1) | orient[i];
+    }
+    return index;
+}
+function getOrientationFromIndex(index) {
+    const orient = Array(6).fill(0);
+    let temp = index;
+    let sum = 0;
+    for (let i = 4; i >= 0; i--) {
+        const bit = temp & 1;
+        orient[i] = bit;
+        sum += bit;
+        temp >>= 1;
+    }
+    orient[5] = sum % 2 === 0 ? 0 : 1;
+    return orient;
+}
+function getCentersIndex(centers) {
+    return centers[0] + 3 * centers[1] + 9 * centers[2] + 27 * centers[3];
+}
+function getCentersFromIndex(index) {
+    let temp = index;
+    const centers = Array(4).fill(0);
+    for (let i = 0; i < 4; i++) {
+        centers[i] = temp % 3;
+        temp = Math.floor(temp / 3);
+    }
+    return centers;
+}
+function permutationParity(perm) {
+    let inv = 0;
+    for (let i = 0; i < perm.length; i++)
+        for (let j = i + 1; j < perm.length; j++)
+            if (perm[i] > perm[j])
+                inv++;
+    return inv % 2;
+}
+// Compact mapping: only even permutations (360) are reachable
+exports.PERMUTATION_FULL_COUNT = 720;
+exports.PERMUTATION_COUNT = 360;
+exports.PERM_720_TO_360 = new Int16Array(exports.PERMUTATION_FULL_COUNT).fill(-1);
+exports.PERM_360_TO_720 = new Uint16Array(exports.PERMUTATION_COUNT);
+(function initPermMapping() {
+    let compact = 0;
+    for (let full = 0; full < exports.PERMUTATION_FULL_COUNT; full++) {
+        const perm = getPermutationFromIndex(full, 6);
+        if (permutationParity(perm) === 0) {
+            exports.PERM_720_TO_360[full] = compact;
+            exports.PERM_360_TO_720[compact] = full;
+            compact++;
+        }
+    }
+})();
+function getPermutationCompactIndex(perm) {
+    const full = getPermutationIndex(perm);
+    const compact = exports.PERM_720_TO_360[full];
+    if (compact === -1)
+        throw new Error("Unreachable pyraminx permutation (odd parity)");
+    return compact;
+}
+function getPermutationCompactFromFull(full) {
+    const c = exports.PERM_720_TO_360[full];
+    if (c === -1)
+        throw new Error(`Full perm index ${full} is odd parity`);
+    return c;
+}
+function getPermutationFullFromCompact(compact) {
+    return exports.PERM_360_TO_720[compact];
+}
+function getStateIndex(state) {
+    const c = getCentersIndex(state.centers);
+    const p = getPermutationCompactIndex(state.edgesPerm);
+    const o = getOrientationIndex(state.edgesOrient);
+    return c + 81 * (p + exports.PERMUTATION_COUNT * o);
+}
+function getPyraminxStateFromIndex(index) {
+    let val = index;
+    const centersIdx = val % 81;
+    val = Math.floor(val / 81);
+    const permCompact = val % exports.PERMUTATION_COUNT;
+    const orientIdx = Math.floor(val / exports.PERMUTATION_COUNT);
+    const permFull = getPermutationFullFromCompact(permCompact);
+    return {
+        centers: getCentersFromIndex(centersIdx),
+        edgesPerm: getPermutationFromIndex(permFull, 6),
+        edgesOrient: getOrientationFromIndex(orientIdx),
+        tips: [0, 0, 0, 0]
+    };
+}
+// ---------------------------------------------------------------------------
+// Table constants
+// ---------------------------------------------------------------------------
+exports.CENTERS_COUNT = 81;
+exports.ORIENTATION_COUNT = 32;
+exports.MOVE_COUNT = 8;
+exports.STATE_COUNT = 81 * exports.PERMUTATION_COUNT * exports.ORIENTATION_COUNT; // 933_120
+exports.POLICY_PACKED_ENTRIES = Math.ceil((exports.STATE_COUNT * 3) / 8); // 349_920
+// 3-bit little-endian unpacking of the packed policy table.
+function getPolicyMoveFromPacked(packed, stateIndex) {
+    const bits = stateIndex * 3;
+    const byteIndex = bits >> 3;
+    const offset = bits & 7;
+    const word = (packed[byteIndex] | ((packed[byteIndex + 1] ?? 0) << 8)) >> offset;
+    return word & 0x07;
+}
+exports.PYRAMINX_MOVES = [
+    "U", "U'", "L", "L'", "R", "R'", "B", "B'"
+];
+// ---------------------------------------------------------------------------
+// Table generation (used by generate script)
+// ---------------------------------------------------------------------------
+function generateCentersTable() {
+    const table = new Uint8Array(exports.CENTERS_COUNT * exports.MOVE_COUNT);
+    for (let c = 0; c < exports.CENTERS_COUNT; c++) {
+        const centers = getCentersFromIndex(c);
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const state = {
+                centers: [...centers],
+                edgesPerm: [0, 1, 2, 3, 4, 5],
+                edgesOrient: [0, 0, 0, 0, 0, 0],
+                tips: [0, 0, 0, 0]
+            };
+            const next = (0, moves_js_1.applyPyraminxMove)(state, exports.PYRAMINX_MOVES[m]);
+            table[c * exports.MOVE_COUNT + m] = getCentersIndex(next.centers);
+        }
+    }
+    return table;
+}
+function generatePermutationTable() {
+    const table = new Uint16Array(exports.PERMUTATION_COUNT * exports.MOVE_COUNT);
+    for (let pCompact = 0; pCompact < exports.PERMUTATION_COUNT; pCompact++) {
+        const full = getPermutationFullFromCompact(pCompact);
+        const perm = getPermutationFromIndex(full, 6);
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const state = {
+                centers: [0, 0, 0, 0],
+                edgesPerm: [...perm],
+                edgesOrient: [0, 0, 0, 0, 0, 0],
+                tips: [0, 0, 0, 0]
+            };
+            const next = (0, moves_js_1.applyPyraminxMove)(state, exports.PYRAMINX_MOVES[m]);
+            const nextFull = getPermutationIndex(next.edgesPerm);
+            table[pCompact * exports.MOVE_COUNT + m] = getPermutationCompactFromFull(nextFull);
+        }
+    }
+    return table;
+}
+function generateOrientationTable() {
+    const table = new Uint8Array(exports.ORIENTATION_COUNT * exports.MOVE_COUNT);
+    for (let o = 0; o < exports.ORIENTATION_COUNT; o++) {
+        const orient = getOrientationFromIndex(o);
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const state = {
+                centers: [0, 0, 0, 0],
+                edgesPerm: [0, 1, 2, 3, 4, 5],
+                edgesOrient: [...orient],
+                tips: [0, 0, 0, 0]
+            };
+            const next = (0, moves_js_1.applyPyraminxMove)(state, exports.PYRAMINX_MOVES[m]);
+            table[o * exports.MOVE_COUNT + m] = getOrientationIndex(next.edgesOrient);
+        }
+    }
+    return table;
+}
+// BFS from solved stores, for each state, the inverse of the move that first
+// discovered it: an optimal move toward solved. Packed 3 bits per state
+// (8 moves; the solved entry is never read, the solve loop exits first).
+function generatePolicyTable(centersTable, permTable, orientTable) {
+    const distances = new Uint8Array(exports.STATE_COUNT).fill(255);
+    const policy = new Uint8Array(exports.STATE_COUNT);
+    const solvedIdx = 0; // c=0,p=0,o=0 => 0
+    distances[solvedIdx] = 0;
+    const queue = new Uint32Array(exports.STATE_COUNT);
+    let read = 0;
+    let write = 1;
+    queue[0] = solvedIdx;
+    let maxDepth = 0;
+    while (read < write) {
+        const curr = queue[read++];
+        const dist = distances[curr];
+        const c = curr % 81;
+        const rem = Math.floor(curr / 81);
+        const p = rem % exports.PERMUTATION_COUNT;
+        const o = Math.floor(rem / exports.PERMUTATION_COUNT);
+        const nextDist = dist + 1;
+        for (let m = 0; m < exports.MOVE_COUNT; m++) {
+            const nc = centersTable[c * exports.MOVE_COUNT + m];
+            const np = permTable[p * exports.MOVE_COUNT + m];
+            const no = orientTable[o * exports.MOVE_COUNT + m];
+            const next = nc + 81 * (np + exports.PERMUTATION_COUNT * no);
+            if (distances[next] === 255) {
+                distances[next] = nextDist;
+                policy[next] = m ^ 1; // inverse move of the discovery edge
+                if (nextDist > maxDepth)
+                    maxDepth = nextDist;
+                queue[write++] = next;
+            }
+        }
+    }
+    const packed = new Uint8Array(exports.POLICY_PACKED_ENTRIES);
+    for (let i = 0; i < exports.STATE_COUNT; i++) {
+        const bits = i * 3;
+        const byteIndex = bits >> 3;
+        const offset = bits & 7;
+        const value = policy[i] & 0x07;
+        packed[byteIndex] |= (value << offset) & 0xff;
+        if (offset > 5) {
+            packed[byteIndex + 1] |= value >> (8 - offset);
+        }
+    }
+    return { packed, maxDepth };
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < values.length; i++) {
+        hash ^= values[i];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+// ---------------------------------------------------------------------------
+// Runtime table loading (mirrors cube2/cube3)
+// ---------------------------------------------------------------------------
+let tablesLoaded = false;
+exports.CENTERS_TABLE = null;
+exports.PERMUTATION_TABLE = null;
+exports.ORIENTATION_TABLE = null;
+exports.POLICY_TABLE = null;
+async function ensureTablesLoaded() {
+    if (tablesLoaded)
+        return;
+    const tables = await (0, generated_assets_js_1.loadGeneratedPyraminxSolverTables)();
+    exports.CENTERS_TABLE = tables.centersTable;
+    exports.PERMUTATION_TABLE = tables.permutationTable;
+    exports.ORIENTATION_TABLE = tables.orientationTable;
+    exports.POLICY_TABLE = tables.policyTable;
+    tablesLoaded = true;
+}
+function getPolicyMove(stateIndex) {
+    if (!exports.POLICY_TABLE)
+        throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");
+    return getPolicyMoveFromPacked(exports.POLICY_TABLE, stateIndex);
+}
+function getCentersTransition(centerIdx, move) {
+    if (!exports.CENTERS_TABLE)
+        throw new Error("Pyraminx solver tables not loaded.");
+    return exports.CENTERS_TABLE[centerIdx * exports.MOVE_COUNT + move];
+}
+function getPermutationTransition(permIdx, move) {
+    if (!exports.PERMUTATION_TABLE)
+        throw new Error("Pyraminx solver tables not loaded.");
+    return exports.PERMUTATION_TABLE[permIdx * exports.MOVE_COUNT + move];
+}
+function getOrientationTransition(orientIdx, move) {
+    if (!exports.ORIENTATION_TABLE)
+        throw new Error("Pyraminx solver tables not loaded.");
+    return exports.ORIENTATION_TABLE[orientIdx * exports.MOVE_COUNT + move];
+}
+function resetTablesForTests() {
+    tablesLoaded = false;
+    exports.CENTERS_TABLE = null;
+    exports.PERMUTATION_TABLE = null;
+    exports.ORIENTATION_TABLE = null;
+    exports.POLICY_TABLE = null;
+}

package/dist-cjs/puzzles/shared/compressed-fetch.js

@@ -0,0 +1,71 @@
+"use strict";
+// Shared browser-only helper to fetch solver tables, preferring the
+// precompressed .br/.gz variants (decompressed with DecompressionStream)
+// and falling back to the raw .bin file.
+//
+// Node never uses this module: node-loader.ts reads the .bin files directly
+// from the filesystem.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTableBuffer = fetchTableBuffer;
+// DecompressionStream only guarantees "gzip"/"deflate"; "br" support varies,
+// so probe once and never attempt formats the runtime cannot decompress.
+const SUPPORTED_FORMATS = (() => {
+    if (typeof DecompressionStream === "undefined")
+        return [];
+    const supported = [];
+    for (const [suffix, format] of [["br", "br"], ["gz", "gzip"]]) {
+        try {
+            new DecompressionStream(format);
+            supported.push([suffix, format]);
+        }
+        catch {
+            // format not supported by this runtime
+        }
+    }
+    return supported;
+})();
+async function fetchTableBuffer(baseUrl, dir, file, options = {}) {
+    const urlFor = (name) => `${baseUrl}/${dir}/${name}`;
+    const cachedFetch = options.cacheName === undefined ? undefined : makeCachedFetch(options.cacheName);
+    if (options.compressed !== false && SUPPORTED_FORMATS.length > 0) {
+        for (const [suffix, format] of SUPPORTED_FORMATS) {
+            try {
+                const response = await (cachedFetch ? cachedFetch(urlFor(`${file}.${suffix}`)) : fetch(urlFor(`${file}.${suffix}`)));
+                if (response.ok && response.body) {
+                    const stream = response.body.pipeThrough(new DecompressionStream(format));
+                    return await new Response(stream).arrayBuffer();
+                }
+            }
+            catch {
+                // try the next candidate
+            }
+        }
+    }
+    const response = await (cachedFetch ? cachedFetch(urlFor(file)) : fetch(urlFor(file)));
+    if (!response.ok) {
+        throw new Error(`Failed to load ${file}: ${response.status} ${response.statusText}`);
+    }
+    return response.arrayBuffer();
+}
+function makeCachedFetch(cacheName) {
+    return async (url) => {
+        if (typeof caches === "undefined") {
+            return fetch(url);
+        }
+        try {
+            const cache = await caches.open(cacheName);
+            const cached = await cache.match(url);
+            if (cached) {
+                return cached;
+            }
+            const response = await fetch(url);
+            if (response.ok) {
+                await cache.put(url, response.clone());
+            }
+            return response;
+        }
+        catch {
+            return fetch(url);
+        }
+    };
+}