@cubingcenter/scrambler 0.3.0 → 0.4.1

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

@@ -0,0 +1,300 @@
+import { loadGeneratedPyraminxSolverTables } from "./generated-assets.js";
+import { applyPyraminxMove } from "../moves.js";
+// ---------------------------------------------------------------------------
+// Coordinate encoding / decoding (kept from original solver.ts)
+// ---------------------------------------------------------------------------
+const FACT = [1, 1, 2, 6, 24, 120, 720];
+export 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;
+}
+export 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;
+}
+export function getOrientationIndex(orient) {
+    let index = 0;
+    for (let i = 0; i < 5; i++) {
+        index = (index << 1) | orient[i];
+    }
+    return index;
+}
+export 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;
+}
+export function getCentersIndex(centers) {
+    return centers[0] + 3 * centers[1] + 9 * centers[2] + 27 * centers[3];
+}
+export 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;
+}
+export 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
+export const PERMUTATION_FULL_COUNT = 720;
+export const PERMUTATION_COUNT = 360;
+export const PERM_720_TO_360 = new Int16Array(PERMUTATION_FULL_COUNT).fill(-1);
+export const PERM_360_TO_720 = new Uint16Array(PERMUTATION_COUNT);
+(function initPermMapping() {
+    let compact = 0;
+    for (let full = 0; full < PERMUTATION_FULL_COUNT; full++) {
+        const perm = getPermutationFromIndex(full, 6);
+        if (permutationParity(perm) === 0) {
+            PERM_720_TO_360[full] = compact;
+            PERM_360_TO_720[compact] = full;
+            compact++;
+        }
+    }
+})();
+export function getPermutationCompactIndex(perm) {
+    const full = getPermutationIndex(perm);
+    const compact = PERM_720_TO_360[full];
+    if (compact === -1)
+        throw new Error("Unreachable pyraminx permutation (odd parity)");
+    return compact;
+}
+export function getPermutationCompactFromFull(full) {
+    const c = PERM_720_TO_360[full];
+    if (c === -1)
+        throw new Error(`Full perm index ${full} is odd parity`);
+    return c;
+}
+export function getPermutationFullFromCompact(compact) {
+    return PERM_360_TO_720[compact];
+}
+export function getStateIndex(state) {
+    const c = getCentersIndex(state.centers);
+    const p = getPermutationCompactIndex(state.edgesPerm);
+    const o = getOrientationIndex(state.edgesOrient);
+    return c + 81 * (p + PERMUTATION_COUNT * o);
+}
+export function getPyraminxStateFromIndex(index) {
+    let val = index;
+    const centersIdx = val % 81;
+    val = Math.floor(val / 81);
+    const permCompact = val % PERMUTATION_COUNT;
+    const orientIdx = Math.floor(val / PERMUTATION_COUNT);
+    const permFull = getPermutationFullFromCompact(permCompact);
+    return {
+        centers: getCentersFromIndex(centersIdx),
+        edgesPerm: getPermutationFromIndex(permFull, 6),
+        edgesOrient: getOrientationFromIndex(orientIdx),
+        tips: [0, 0, 0, 0]
+    };
+}
+// ---------------------------------------------------------------------------
+// Table constants
+// ---------------------------------------------------------------------------
+export const CENTERS_COUNT = 81;
+export const ORIENTATION_COUNT = 32;
+export const MOVE_COUNT = 8;
+export const STATE_COUNT = 81 * PERMUTATION_COUNT * ORIENTATION_COUNT; // 933_120
+export const POLICY_PACKED_ENTRIES = Math.ceil((STATE_COUNT * 3) / 8); // 349_920
+// 3-bit little-endian unpacking of the packed policy table.
+export 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;
+}
+export const PYRAMINX_MOVES = [
+    "U", "U'", "L", "L'", "R", "R'", "B", "B'"
+];
+// ---------------------------------------------------------------------------
+// Table generation (used by generate script)
+// ---------------------------------------------------------------------------
+export function generateCentersTable() {
+    const table = new Uint8Array(CENTERS_COUNT * MOVE_COUNT);
+    for (let c = 0; c < CENTERS_COUNT; c++) {
+        const centers = getCentersFromIndex(c);
+        for (let m = 0; m < 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 = applyPyraminxMove(state, PYRAMINX_MOVES[m]);
+            table[c * MOVE_COUNT + m] = getCentersIndex(next.centers);
+        }
+    }
+    return table;
+}
+export function generatePermutationTable() {
+    const table = new Uint16Array(PERMUTATION_COUNT * MOVE_COUNT);
+    for (let pCompact = 0; pCompact < PERMUTATION_COUNT; pCompact++) {
+        const full = getPermutationFullFromCompact(pCompact);
+        const perm = getPermutationFromIndex(full, 6);
+        for (let m = 0; m < 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 = applyPyraminxMove(state, PYRAMINX_MOVES[m]);
+            const nextFull = getPermutationIndex(next.edgesPerm);
+            table[pCompact * MOVE_COUNT + m] = getPermutationCompactFromFull(nextFull);
+        }
+    }
+    return table;
+}
+export function generateOrientationTable() {
+    const table = new Uint8Array(ORIENTATION_COUNT * MOVE_COUNT);
+    for (let o = 0; o < ORIENTATION_COUNT; o++) {
+        const orient = getOrientationFromIndex(o);
+        for (let m = 0; m < 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 = applyPyraminxMove(state, PYRAMINX_MOVES[m]);
+            table[o * 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).
+export function generatePolicyTable(centersTable, permTable, orientTable) {
+    const distances = new Uint8Array(STATE_COUNT).fill(255);
+    const policy = new Uint8Array(STATE_COUNT);
+    const solvedIdx = 0; // c=0,p=0,o=0 => 0
+    distances[solvedIdx] = 0;
+    const queue = new Uint32Array(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 % PERMUTATION_COUNT;
+        const o = Math.floor(rem / PERMUTATION_COUNT);
+        const nextDist = dist + 1;
+        for (let m = 0; m < MOVE_COUNT; m++) {
+            const nc = centersTable[c * MOVE_COUNT + m];
+            const np = permTable[p * MOVE_COUNT + m];
+            const no = orientTable[o * MOVE_COUNT + m];
+            const next = nc + 81 * (np + 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(POLICY_PACKED_ENTRIES);
+    for (let i = 0; i < 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 };
+}
+export 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;
+export let CENTERS_TABLE = null;
+export let PERMUTATION_TABLE = null;
+export let ORIENTATION_TABLE = null;
+export let POLICY_TABLE = null;
+export async function ensureTablesLoaded() {
+    if (tablesLoaded)
+        return;
+    const tables = await loadGeneratedPyraminxSolverTables();
+    CENTERS_TABLE = tables.centersTable;
+    PERMUTATION_TABLE = tables.permutationTable;
+    ORIENTATION_TABLE = tables.orientationTable;
+    POLICY_TABLE = tables.policyTable;
+    tablesLoaded = true;
+}
+export function getPolicyMove(stateIndex) {
+    if (!POLICY_TABLE)
+        throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");
+    return getPolicyMoveFromPacked(POLICY_TABLE, stateIndex);
+}
+export function getCentersTransition(centerIdx, move) {
+    if (!CENTERS_TABLE)
+        throw new Error("Pyraminx solver tables not loaded.");
+    return CENTERS_TABLE[centerIdx * MOVE_COUNT + move];
+}
+export function getPermutationTransition(permIdx, move) {
+    if (!PERMUTATION_TABLE)
+        throw new Error("Pyraminx solver tables not loaded.");
+    return PERMUTATION_TABLE[permIdx * MOVE_COUNT + move];
+}
+export function getOrientationTransition(orientIdx, move) {
+    if (!ORIENTATION_TABLE)
+        throw new Error("Pyraminx solver tables not loaded.");
+    return ORIENTATION_TABLE[orientIdx * MOVE_COUNT + move];
+}
+export function resetTablesForTests() {
+    tablesLoaded = false;
+    CENTERS_TABLE = null;
+    PERMUTATION_TABLE = null;
+    ORIENTATION_TABLE = null;
+    POLICY_TABLE = null;
+}

package/dist/puzzles/shared/compressed-fetch.d.ts

@@ -0,0 +1,12 @@
+export interface FetchTableBufferOptions {
+    /** Cache API cache name to store responses in (used by cube3). */
+    cacheName?: string;
+    /**
+     * Whether the manifest advertises precompressed variants for this file.
+     * Defaults to true (old manifests without the flag keep the old behavior);
+     * set to false to skip .br/.gz attempts entirely.
+     */
+    compressed?: boolean;
+}
+export declare function fetchTableBuffer(baseUrl: string, dir: string, file: string, options?: FetchTableBufferOptions): Promise<ArrayBuffer>;
+//# sourceMappingURL=compressed-fetch.d.ts.map

package/dist/puzzles/shared/compressed-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressed-fetch.d.ts","sourceRoot":"","sources":["../../../src/puzzles/shared/compressed-fetch.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,uBAAuB;IACtC,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAkBD,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,WAAW,CAAC,CAuBtB"}

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

@@ -0,0 +1,68 @@
+// 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.
+// 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;
+})();
+export 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);
+        }
+    };
+}

package/dist/puzzles/skewb/index.d.ts

@@ -7,4 +7,5 @@ export { generateRandomSkewbState } from "./random-state.js";
 export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
 export { solveSkewb, getStateIndex, getStateFromIndex } from "./solver.js";
 export { generateSkewbScramble, skewbScrambleGenerator } from "./scrambler.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/puzzles/skewb/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC/G,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAC;AAClI,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC/G,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAC;AAClI,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAE/E,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/skewb/index.js

@@ -1,3 +1,6 @@
+import { registerScrambleGenerator } from "../../core/index.js";
+import { skewbScrambleGenerator } from "./scrambler.js";
+registerScrambleGenerator(skewbScrambleGenerator);
 export { SKEWB_MOVES, SKEWB_FACES } from "./types.js";
 export { applySkewbAlgorithm, applySkewbMove, formatSkewbAlgorithm, invertSkewbAlgorithm, invertSkewbMove, parseSkewbAlgorithm, parseSkewbMove, } from "./moves.js";
 export { cloneSkewbState, createSolvedSkewbState, isSolvedSkewbState, skewbStatesEqual, } from "./state.js";
@@ -6,3 +9,4 @@ export { generateRandomSkewbState } from "./random-state.js";
 export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
 export { solveSkewb, getStateIndex, getStateFromIndex } from "./solver.js";
 export { generateSkewbScramble, skewbScrambleGenerator } from "./scrambler.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";

package/dist/puzzles/skewb/scrambler.js

@@ -5,7 +5,7 @@ import { solveSkewb } from "./solver.js";
 import { formatSkewbFacelets, toSkewbFacelets } from "./facelets.js";
 export const skewbScrambleGenerator = {
     info: {
-        eventId: "skewb",
+        eventId: "skwb",
         name: "Skewb",
         puzzle: "skewb",
         quality: "random-state",
@@ -33,7 +33,7 @@ export async function generateSkewbScramble(options = {}) {
     }
     const facelets = toSkewbFacelets(state);
     const result = {
-        eventId: "skewb",
+        eventId: "skwb",
         scramble: formatSkewbAlgorithm(scrambleMoves),
         moves: scrambleMoves,
         quality: "random-state",

package/dist-cjs/core/api.js

@@ -1,4 +1,37 @@
 "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 = initializeScrambler;
 exports.registerScrambleGenerator = registerScrambleGenerator;
@@ -8,8 +41,6 @@ exports.generateScramble = generateScramble;
 exports.generateScrambles = generateScrambles;
 const errors_js_1 = require("./errors.js");
 const registry_js_1 = require("./registry.js");
-const browser_loader_js_1 = require("../puzzles/cube2/solver/browser-loader.js");
-const browser_loader_js_2 = require("../puzzles/cube3/solver/browser-loader.js");
 /**
  * Pre-load solver tables in browser environments.
  * In Node.js this is a no-op (tables are read lazily from the filesystem).
@@ -26,16 +57,25 @@ async function initializeScrambler(baseUrl, eventId) {
         // Node.js — tables are loaded on-demand from the filesystem
         return;
     }
+    // Lazy imports keep per-puzzle subpath bundles from pulling in the
+    // loaders of every other puzzle.
     if (eventId === "222" || eventId === "222so") {
-        await (0, browser_loader_js_1.loadBrowserTables)(baseUrl);
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/cube2/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
     }
     else if (eventId === "333") {
-        await (0, browser_loader_js_2.loadBrowserTables)(baseUrl);
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/cube3/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
+    }
+    else if (eventId === "pymx") {
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/pyraminx/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
     }
     else if (!eventId) {
         await Promise.all([
-            (0, browser_loader_js_1.loadBrowserTables)(baseUrl),
-            (0, browser_loader_js_2.loadBrowserTables)(baseUrl)
+            Promise.resolve().then(() => __importStar(require("../puzzles/cube2/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
+            Promise.resolve().then(() => __importStar(require("../puzzles/cube3/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
+            Promise.resolve().then(() => __importStar(require("../puzzles/pyraminx/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl))
         ]);
     }
 }

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

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateClockScramble = exports.clockScrambleGenerator = void 0;
-var scrambler_js_1 = require("./scrambler.js");
-Object.defineProperty(exports, "clockScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.clockScrambleGenerator; } });
-Object.defineProperty(exports, "generateClockScramble", { enumerable: true, get: function () { return scrambler_js_1.generateClockScramble; } });
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.generateClockScramble = exports.clockScrambleGenerator = 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.clockScrambleGenerator);
+var scrambler_js_2 = require("./scrambler.js");
+Object.defineProperty(exports, "clockScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.clockScrambleGenerator; } });
+Object.defineProperty(exports, "generateClockScramble", { enumerable: true, get: function () { return scrambler_js_2.generateClockScramble; } });
+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; } });

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

@@ -4,7 +4,7 @@ exports.clockScrambleGenerator = void 0;
 exports.generateClockScramble = generateClockScramble;
 exports.clockScrambleGenerator = {
     info: {
-        eventId: "clkwca",
+        eventId: "clck",
         name: "Clock",
         puzzle: "clock",
         quality: "random-state",
@@ -42,7 +42,7 @@ async function generateClockScramble(options = {}) {
     const finalPinsStr = finalPins.join(" ");
     const scramble = [...moves, finalPinsStr].filter(Boolean).join(" ");
     return {
-        eventId: "clkwca",
+        eventId: "clck",
         scramble,
         moves, // For moves we return the steps without final pins as parsed moves, or just string array
         quality: "random-state",

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

@@ -33,7 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solver = exports.toCube2Facelets = exports.getCube2FaceOrder = exports.formatCube2Facelets = exports.generateCube2Scramble = exports.cube2ScrambleGenerator = exports.generateRandomCube2State = exports.validateCube2State = exports.permutationParity = exports.isOneMoveFromSolvedCube2State = exports.isAllowedRandomCube2State = exports.isSolvedCube2State = exports.cube2StatesEqual = exports.createSolvedCube2State = exports.cloneCube2State = exports.parseCube2Move = exports.parseCube2Algorithm = exports.invertCube2Move = exports.invertCube2Algorithm = exports.formatCube2Algorithm = exports.applyCube2Move = exports.applyCube2Algorithm = exports.CORNER_COUNT = exports.CUBE2_MOVES = void 0;
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.solver = exports.toCube2Facelets = exports.getCube2FaceOrder = exports.formatCube2Facelets = exports.generateCube2Scramble = exports.cube2ScrambleGenerator = exports.generateRandomCube2State = exports.validateCube2State = exports.permutationParity = exports.isOneMoveFromSolvedCube2State = exports.isAllowedRandomCube2State = exports.isSolvedCube2State = exports.cube2StatesEqual = exports.createSolvedCube2State = exports.cloneCube2State = exports.parseCube2Move = exports.parseCube2Algorithm = exports.invertCube2Move = exports.invertCube2Algorithm = exports.formatCube2Algorithm = exports.applyCube2Move = exports.applyCube2Algorithm = exports.CORNER_COUNT = exports.CUBE2_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.cube2ScrambleGenerator);
 var types_js_1 = require("./types.js");
 Object.defineProperty(exports, "CUBE2_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE2_MOVES; } });
 Object.defineProperty(exports, "CORNER_COUNT", { enumerable: true, get: function () { return types_js_1.CORNER_COUNT; } });
@@ -57,11 +60,17 @@ Object.defineProperty(exports, "permutationParity", { enumerable: true, get: fun
 Object.defineProperty(exports, "validateCube2State", { enumerable: true, get: function () { return validation_js_1.validateCube2State; } });
 var random_state_js_1 = require("./random-state.js");
 Object.defineProperty(exports, "generateRandomCube2State", { enumerable: true, get: function () { return random_state_js_1.generateRandomCube2State; } });
-var scrambler_js_1 = require("./scrambler.js");
-Object.defineProperty(exports, "cube2ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube2ScrambleGenerator; } });
-Object.defineProperty(exports, "generateCube2Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube2Scramble; } });
+var scrambler_js_2 = require("./scrambler.js");
+Object.defineProperty(exports, "cube2ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.cube2ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube2Scramble", { enumerable: true, get: function () { return scrambler_js_2.generateCube2Scramble; } });
 var facelets_js_1 = require("./facelets.js");
 Object.defineProperty(exports, "formatCube2Facelets", { enumerable: true, get: function () { return facelets_js_1.formatCube2Facelets; } });
 Object.defineProperty(exports, "getCube2FaceOrder", { enumerable: true, get: function () { return facelets_js_1.getCube2FaceOrder; } });
 Object.defineProperty(exports, "toCube2Facelets", { enumerable: true, get: function () { return facelets_js_1.toCube2Facelets; } });
 exports.solver = __importStar(require("./solver/index.js"));
+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; } });

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

@@ -4,7 +4,6 @@ exports.cube2ScrambleGenerator = void 0;
 exports.generateCube2Scramble = generateCube2Scramble;
 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.cube2ScrambleGenerator = {
@@ -25,11 +24,10 @@ async function generateCube2Scramble(options = {}) {
     const solution = await (0, index_js_1.solveCube2State)(state);
     const scrambleMoves = (0, moves_js_1.invertCube2Algorithm)(solution.moves);
     if (!options.skipValidation) {
-        const scrambledState = (0, moves_js_1.applyCube2Algorithm)((0, state_js_1.createSolvedCube2State)(), scrambleMoves);
-        if (!(0, state_js_1.cube2StatesEqual)(scrambledState, state)) {
+        if (!(0, index_js_1.verifyCube2Scramble)(state, scrambleMoves)) {
             throw new Error("Generated 2x2 scramble does not reproduce the target random state.");
         }
-        if (!(0, state_js_1.isSolvedCube2State)(solution.state)) {
+        if (!(0, index_js_1.verifyCube2Solution)(state, solution.moves)) {
             throw new Error("Generated 2x2 solution does not solve the target random state.");
         }
         if (scrambleMoves.length < 2) {

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

@@ -4,6 +4,8 @@ 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/cube2/solver/generated";
 let cachedBrowserTables;
 function getCachedBrowserTables() {
     return cachedBrowserTables;
@@ -55,12 +57,7 @@ async function fetchManifest(baseUrl) {
     return manifest;
 }
 async function fetchUint16Table(baseUrl, entry, expectedEntries) {
-    const url = `${baseUrl}/puzzles/cube2/solver/generated/${entry.file}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to load ${entry.file}: ${response.status} ${response.statusText}`);
-    }
-    const buffer = await response.arrayBuffer();
+    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}`);
     }
@@ -72,12 +69,7 @@ async function fetchUint16Table(baseUrl, entry, expectedEntries) {
     return values;
 }
 async function fetchUint8Table(baseUrl, entry, expectedEntries) {
-    const url = `${baseUrl}/puzzles/cube2/solver/generated/${entry.file}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to load ${entry.file}: ${response.status} ${response.statusText}`);
-    }
-    const buffer = await response.arrayBuffer();
+    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}`);
     }

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

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solveCube2State = void 0;
+exports.verifyCube2Solution = exports.verifyCube2Scramble = exports.solveCube2State = void 0;
 var search_js_1 = require("./search.js");
 Object.defineProperty(exports, "solveCube2State", { enumerable: true, get: function () { return search_js_1.solveCube2State; } });
+Object.defineProperty(exports, "verifyCube2Scramble", { enumerable: true, get: function () { return search_js_1.verifyCube2Scramble; } });
+Object.defineProperty(exports, "verifyCube2Solution", { enumerable: true, get: function () { return search_js_1.verifyCube2Solution; } });