@cubingcenter/scrambler 0.4.0 → 0.5.0

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/facelets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAgC5D,wBAAgB,yBAAyB,IAAI,aAAa,CASzD;AAaD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAsBhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAErD"}
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA0D5D,wBAAgB,yBAAyB,IAAI,aAAa,CASzD;AAaD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAqBhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAErD"}

package/dist/puzzles/skewb/facelets.js

@@ -1,6 +1,7 @@
 // Facelets model matching cubingcenter-viz/src/puzzles/skewb.ts
 // Each face has 5 stickers: 0=center, 1=TL,2=TR,3=BL,4=BR (net layout)
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const FACE_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 // Canonical sticker faces per corner position: [UD sticker, RL sticker, FB sticker]
 const CORNER_STICKERS = [
     ["U", "R", "F"],
@@ -23,43 +24,65 @@ const CORNER_SLOTS = [
     [["D", 4], ["R", 4], ["B", 3]],
     [["D", 3], ["L", 3], ["B", 4]],
 ];
+// For each (position, piece, orientation) the three facelet writes, flattened:
+// face index, sticker slot index and sticker color index, so the hot loop is
+// pure table lookups (no tuple destructuring, no modulo).
+const CORNER_WRITE_COUNT = 8 * 8 * 3 * 3;
+const WRITE_FACE = new Int8Array(CORNER_WRITE_COUNT);
+const WRITE_SLOT = new Int8Array(CORNER_WRITE_COUNT);
+const WRITE_COLOR = new Int8Array(CORNER_WRITE_COUNT);
+for (let pos = 0; pos < 8; pos++) {
+    const slots = CORNER_SLOTS[pos];
+    for (let piece = 0; piece < 8; piece++) {
+        const stickers = CORNER_STICKERS[piece];
+        for (let ori = 0; ori < 3; ori++) {
+            const base = ((pos * 8 + piece) * 3 + ori) * 3;
+            for (let i = 0; i < 3; i++) {
+                const [face, idx] = slots[i];
+                const color = stickers[(i + 3 - ori) % 3];
+                WRITE_FACE[base + i] = FACE_INDEX[face];
+                WRITE_SLOT[base + i] = idx;
+                WRITE_COLOR[base + i] = FACE_INDEX[color];
+            }
+        }
+    }
+}
 export function createSolvedSkewbFacelets() {
     return {
-        U: Array.from({ length: 5 }, () => "U"),
-        R: Array.from({ length: 5 }, () => "R"),
-        F: Array.from({ length: 5 }, () => "F"),
-        D: Array.from({ length: 5 }, () => "D"),
-        L: Array.from({ length: 5 }, () => "L"),
-        B: Array.from({ length: 5 }, () => "B"),
+        U: ["U", "U", "U", "U", "U"],
+        R: ["R", "R", "R", "R", "R"],
+        F: ["F", "F", "F", "F", "F"],
+        D: ["D", "D", "D", "D", "D"],
+        L: ["L", "L", "L", "L", "L"],
+        B: ["B", "B", "B", "B", "B"],
     };
 }
 function createEmptySkewbFacelets() {
     return {
-        U: Array(5).fill("?"),
-        R: Array(5).fill("?"),
-        F: Array(5).fill("?"),
-        D: Array(5).fill("?"),
-        L: Array(5).fill("?"),
-        B: Array(5).fill("?"),
+        U: ["?", "?", "?", "?", "?"],
+        R: ["?", "?", "?", "?", "?"],
+        F: ["?", "?", "?", "?", "?"],
+        D: ["?", "?", "?", "?", "?"],
+        L: ["?", "?", "?", "?", "?"],
+        B: ["?", "?", "?", "?", "?"],
     };
 }
 export function toSkewbFacelets(state) {
     const facelets = createEmptySkewbFacelets();
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    const perm = state.corners.permutation;
+    const orient = state.corners.orientation;
+    const centers = state.centers;
     // centers
     for (let face = 0; face < 6; face++) {
-        const targetFace = FACE_ORDER[face];
-        facelets[targetFace][0] = FACE_ORDER[state.centers[face]];
+        faces[face][0] = FACE_ORDER[centers[face]];
     }
-    // corners
+    // corners (unrolled 3 writes per position)
     for (let pos = 0; pos < 8; pos++) {
-        const piece = state.corners.permutation[pos];
-        const ori = state.corners.orientation[pos];
-        const slots = CORNER_SLOTS[pos];
-        const stickers = CORNER_STICKERS[piece];
-        for (let i = 0; i < 3; i++) {
-            const [face, idx] = slots[i];
-            facelets[face][idx] = stickers[(i + 3 - ori) % 3];
-        }
+        const base = ((pos * 8 + perm[pos]) * 3 + orient[pos]) * 3;
+        faces[WRITE_FACE[base]][WRITE_SLOT[base]] = FACE_ORDER[WRITE_COLOR[base]];
+        faces[WRITE_FACE[base + 1]][WRITE_SLOT[base + 1]] = FACE_ORDER[WRITE_COLOR[base + 1]];
+        faces[WRITE_FACE[base + 2]][WRITE_SLOT[base + 2]] = FACE_ORDER[WRITE_COLOR[base + 2]];
     }
     return facelets;
 }

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

@@ -5,6 +5,8 @@ export { cloneSkewbState, createSolvedSkewbState, isSolvedSkewbState, skewbState
 export { permutationParity, validateSkewbState, isAllowedRandomSkewbState, isOneMoveFromSolvedSkewbState } from "./validation.js";
 export { generateRandomSkewbState } from "./random-state.js";
 export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
-export { solveSkewb, getStateIndex, getStateFromIndex } from "./solver.js";
+export { solveSkewb, solveSkewbWithInfo, solveSkewbSync, verifySkewbScramble, verifySkewbSolution, getStateIndex, getStateFromIndex, } from "./solver/index.js";
+export * as solver from "./solver/index.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,EACL,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,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,8 +1,13 @@
+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";
 export { permutationParity, validateSkewbState, isAllowedRandomSkewbState, isOneMoveFromSolvedSkewbState } from "./validation.js";
 export { generateRandomSkewbState } from "./random-state.js";
 export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
-export { solveSkewb, getStateIndex, getStateFromIndex } from "./solver.js";
+export { solveSkewb, solveSkewbWithInfo, solveSkewbSync, verifySkewbScramble, verifySkewbSolution, getStateIndex, getStateFromIndex, } from "./solver/index.js";
+export * as solver from "./solver/index.js";
 export { generateSkewbScramble, skewbScrambleGenerator } from "./scrambler.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";

package/dist/puzzles/skewb/random-state.d.ts

@@ -1,3 +1,3 @@
 import type { SkewbRandomStateOptions, SkewbState } from "./types.js";
-export declare function generateRandomSkewbState(options?: SkewbRandomStateOptions): SkewbState;
+export declare function generateRandomSkewbState(options?: SkewbRandomStateOptions): Promise<SkewbState>;
 //# sourceMappingURL=random-state.d.ts.map

package/dist/puzzles/skewb/random-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMtE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAS1F"}
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/random-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAatE,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,UAAU,CAAC,CAiBrB"}

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

@@ -1,27 +1,34 @@
 import { createRandomSource } from "../../random/index.js";
-import { isAllowedRandomSkewbState } from "./validation.js";
-import { applySkewbMove } from "./moves.js";
-import { createSolvedSkewbState } from "./state.js";
-import { SKEWB_MOVES } from "./types.js";
-export function generateRandomSkewbState(options = {}) {
+import { ensureTablesLoaded, getCentersTransition, getOrientationTransition, getPermutationTransition, getStateFromRank, MOVE_COUNT, rankFromComponents, SOLVED_RANK, STATE_COUNT, } from "./solver/index.js";
+export async function generateRandomSkewbState(options = {}) {
+    await ensureTablesLoaded();
     const random = 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 || isAllowedRandomSkewbState(state))
-            return state;
+        const rank = random.nextInt(STATE_COUNT);
+        if (trivialRanks && trivialRanks.has(rank))
+            continue;
+        return 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 = createSolvedSkewbState();
-    const walkLength = 30 + random.nextInt(5); // 30-34 moves
-    for (let i = 0; i < walkLength; i++) {
-        const move = random.choice([...SKEWB_MOVES]);
-        state = applySkewbMove(state, move);
+let trivialRanks = null;
+function getTrivialRanks() {
+    if (!trivialRanks) {
+        const ranks = new Set([SOLVED_RANK]);
+        for (let m = 0; m < MOVE_COUNT; m++) {
+            const r7 = getPermutationTransition(0, m);
+            const rO = getOrientationTransition(0, m);
+            const rC = getCentersTransition(0, m);
+            ranks.add(rankFromComponents(r7, rO, rC));
+        }
+        trivialRanks = ranks;
     }
-    return state;
+    return trivialRanks;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAO9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CAiCzB"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAM9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CA+BzB"}

package/dist/puzzles/skewb/scrambler.js

@@ -1,7 +1,6 @@
 import { generateRandomSkewbState } from "./random-state.js";
-import { createSolvedSkewbState, isSolvedSkewbState, skewbStatesEqual } from "./state.js";
-import { applySkewbAlgorithm, formatSkewbAlgorithm, invertSkewbAlgorithm } from "./moves.js";
-import { solveSkewb } from "./solver.js";
+import { formatSkewbAlgorithm, invertSkewbAlgorithm } from "./moves.js";
+import { solveSkewb, verifySkewbScramble } from "./solver/index.js";
 import { formatSkewbFacelets, toSkewbFacelets } from "./facelets.js";
 export const skewbScrambleGenerator = {
     info: {
@@ -9,25 +8,23 @@ export const 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);
     },
 };
 export async function generateSkewbScramble(options = {}) {
-    const state = generateRandomSkewbState(options);
-    const solution = solveSkewb(state);
+    const state = await generateRandomSkewbState(options);
+    const solution = await solveSkewb(state);
     const scrambleMoves = invertSkewbAlgorithm(solution);
     if (!options.skipValidation) {
-        const scrambledState = applySkewbAlgorithm(createSolvedSkewbState(), scrambleMoves);
-        if (!skewbStatesEqual(scrambledState, state)) {
+        // If the scramble reproduces the target state, its inverse (the
+        // solution) solves it by construction, so a single walk suffices.
+        if (!verifySkewbScramble(state, scrambleMoves)) {
             throw new Error("Generated Skewb scramble does not reproduce the target random state.");
         }
-        if (!isSolvedSkewbState(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.");
     }
@@ -37,7 +34,7 @@ export async function generateSkewbScramble(options = {}) {
         scramble: formatSkewbAlgorithm(scrambleMoves),
         moves: scrambleMoves,
         quality: "random-state",
-        generator: "skewb-bfs",
+        generator: "skewb-optimal",
         metadata: {
             state,
             facelets,