@cubingcenter/scrambler 0.4.1 → 0.5.1

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

@@ -5,7 +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":"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"}
+{"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

@@ -7,6 +7,7 @@ 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";

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;AAa9F,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,CAgDzB"}

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 } from "./moves.js";
+import { areSkewbTablesLoaded, solveSkewbIndices, solveSkewbIndicesSync, verifySkewbScrambleIndices, SKEWB_MOVES } from "./solver/index.js";
 import { formatSkewbFacelets, toSkewbFacelets } from "./facelets.js";
 export const skewbScrambleGenerator = {
     info: {
@@ -9,41 +8,53 @@ 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 scrambleMoves = invertSkewbAlgorithm(solution);
+    const state = await generateRandomSkewbState(options);
+    // generateRandomSkewbState guarantees the tables are loaded, so use the
+    // sync solve on every call after the first (no extra microtask).
+    const solution = areSkewbTablesLoaded()
+        ? solveSkewbIndicesSync(state)
+        : await solveSkewbIndices(state);
+    const depth = solution.length;
+    // Scramble = inverse of the solution, reversed. For index m the inverse is
+    // m ^ 1 (moves are paired R/R', U/U', L/L', B/B').
+    const scrambleMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        scrambleMoves[index] = SKEWB_MOVES[solution[depth - 1 - index] ^ 1];
+    }
     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 (!verifySkewbScrambleIndices(state, solution)) {
             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.");
     }
     const facelets = toSkewbFacelets(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = SKEWB_MOVES[solution[index]];
+    }
     const result = {
         eventId: "skwb",
         scramble: formatSkewbAlgorithm(scrambleMoves),
         moves: scrambleMoves,
         quality: "random-state",
-        generator: "skewb-bfs",
+        generator: "skewb-optimal",
         metadata: {
             state,
             facelets,
             faceletString: formatSkewbFacelets(facelets),
-            solutionMoves: solution,
-            solutionDepth: solution.length,
+            solutionMoves,
+            solutionDepth: depth,
         },
     };
     if (options.seed !== undefined)

package/dist/puzzles/skewb/solver/browser-loader.d.ts

@@ -0,0 +1,20 @@
+export declare function getCachedBrowserTables(): {
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    centersTable: Uint16Array;
+    policyTable: Uint8Array;
+    evenCenterRank: Uint16Array;
+    orientClass: Uint8Array;
+    r7Sets: Uint16Array;
+} | undefined;
+export declare function clearCachedBrowserTables(): void;
+export declare function loadBrowserTables(baseUrl?: string): Promise<{
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    centersTable: Uint16Array;
+    policyTable: Uint8Array;
+    evenCenterRank: Uint16Array;
+    orientClass: Uint8Array;
+    r7Sets: Uint16Array;
+}>;
+//# sourceMappingURL=browser-loader.d.ts.map

package/dist/puzzles/skewb/solver/browser-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/browser-loader.ts"],"names":[],"mappings":"AAeA,wBAAgB,sBAAsB;sBATlB,WAAW;sBACX,WAAW;kBACf,WAAW;iBACZ,UAAU;oBACP,WAAW;iBACd,UAAU;YACf,WAAW;cAKpB;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,UAAU,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC,CAwCD"}

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

@@ -0,0 +1,86 @@
+import { SKEWB_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+import { fetchTableBuffer } from "../../shared/compressed-fetch.js";
+const TABLES_DIR = "puzzles/skewb/solver/generated";
+let cachedBrowserTables;
+export function getCachedBrowserTables() {
+    return cachedBrowserTables;
+}
+export function clearCachedBrowserTables() {
+    cachedBrowserTables = undefined;
+}
+export async function loadBrowserTables(baseUrl) {
+    if (cachedBrowserTables) {
+        return cachedBrowserTables;
+    }
+    const resolved = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolved);
+    const [permTable, orientTable, centersTable, helpers, policy] = await Promise.all([
+        fetchUint16Table(resolved, manifest.files.permutationTable, SKEWB_SOLVER_TABLE_METADATA.permutationTable.entries),
+        fetchUint16Table(resolved, manifest.files.orientationTable, SKEWB_SOLVER_TABLE_METADATA.orientationTable.entries),
+        fetchUint16Table(resolved, manifest.files.centersTable, SKEWB_SOLVER_TABLE_METADATA.centersTable.entries),
+        fetchUint8Table(resolved, manifest.files.helpers, SKEWB_SOLVER_TABLE_METADATA.helpers.entries),
+        fetchUint8Table(resolved, manifest.files.policyTable, SKEWB_SOLVER_TABLE_METADATA.policyTable.entries)
+    ]);
+    const helpersOffset = SKEWB_SOLVER_TABLE_METADATA.helpers;
+    const evenCenterRank = new Uint16Array(helpersOffset.evenCenterRankBytes / 2);
+    const rankView = new DataView(helpers.buffer, helpers.byteOffset);
+    for (let i = 0; i < evenCenterRank.length; i++) {
+        evenCenterRank[i] = rankView.getUint16(i * 2, true);
+    }
+    const orientClass = helpers.subarray(helpersOffset.evenCenterRankBytes, helpersOffset.evenCenterRankBytes + helpersOffset.orientClassBytes);
+    const r7Sets = new Uint16Array(helpersOffset.r7SetsEntries);
+    const view = new DataView(helpers.buffer, helpers.byteOffset + helpersOffset.evenCenterRankBytes + helpersOffset.orientClassBytes);
+    for (let i = 0; i < r7Sets.length; i++) {
+        r7Sets[i] = view.getUint16(i * 2, true);
+    }
+    cachedBrowserTables = {
+        permutationTable: permTable,
+        orientationTable: orientTable,
+        centersTable,
+        policyTable: policy,
+        evenCenterRank,
+        orientClass,
+        r7Sets
+    };
+    return cachedBrowserTables;
+}
+function resolveBaseUrl(provided) {
+    if (provided) {
+        return provided.replace(/\/$/, "");
+    }
+    if (typeof document !== "undefined") {
+        const script = document.currentScript;
+        if (script?.src) {
+            const base = new URL(".", script.src).href;
+            return base.replace(/\/$/, "");
+        }
+    }
+    return ".";
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/puzzles/skewb/solver/generated/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load skewb solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}
+async function fetchUint16Table(baseUrl, entry, expectedEntries) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(expectedEntries);
+    const view = new DataView(buffer);
+    for (let i = 0; i < values.length; i++) {
+        values[i] = view.getUint16(i * 2, true);
+    }
+    return values;
+}
+async function fetchUint8Table(baseUrl, entry, expectedEntries) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    return new Uint8Array(buffer);
+}

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

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

package/dist/puzzles/skewb/solver/generated-assets.d.ts

@@ -0,0 +1,10 @@
+export declare function loadGeneratedSkewbSolverTables(): Promise<{
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    centersTable: Uint16Array;
+    policyTable: Uint8Array;
+    evenCenterRank: Uint16Array;
+    orientClass: Uint8Array;
+    r7Sets: Uint16Array;
+}>;
+//# sourceMappingURL=generated-assets.d.ts.map

package/dist/puzzles/skewb/solver/generated-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/generated-assets.ts"],"names":[],"mappings":"AAgBA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,UAAU,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC,CAYD"}

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

@@ -0,0 +1,24 @@
+import { getCachedBrowserTables } from "./browser-loader.js";
+let cachedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+export async function loadGeneratedSkewbSolverTables() {
+    if (isBrowser()) {
+        const browserTables = getCachedBrowserTables();
+        if (browserTables)
+            return browserTables;
+        throw new Error("Skewb solver tables are not loaded. " +
+            "In browser environments, call `initializeScrambler(baseUrl)` " +
+            "before generating scrambles.");
+    }
+    cachedTables ??= await loadNodeTables();
+    return cachedTables;
+}
+async function loadNodeTables() {
+    const loader = await import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./node-loader.js");
+    return loader.readGeneratedSkewbSolverTables();
+}

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

@@ -0,0 +1,5 @@
+export * from "./tables.js";
+export * from "./search.js";
+export { SKEWB_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+export { loadGeneratedSkewbSolverTables } from "./generated-assets.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./tables.js";
+export * from "./search.js";
+export { SKEWB_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+export { loadGeneratedSkewbSolverTables } from "./generated-assets.js";

package/dist/puzzles/skewb/solver/node-loader.d.ts

@@ -0,0 +1,10 @@
+export declare function readGeneratedSkewbSolverTables(): {
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    centersTable: Uint16Array;
+    policyTable: Uint8Array;
+    evenCenterRank: Uint16Array;
+    orientClass: Uint8Array;
+    r7Sets: Uint16Array;
+};
+//# sourceMappingURL=node-loader.d.ts.map

package/dist/puzzles/skewb/solver/node-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/node-loader.ts"],"names":[],"mappings":"AAkBA,wBAAgB,8BAA8B,IAAI;IAChD,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,UAAU,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;CACrB,CA6DA"}

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

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { SKEWB_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+const GENERATED_DIRECTORY = "puzzles/skewb/solver/generated";
+export function readGeneratedSkewbSolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = JSON.parse(readFileSync(path.join(assetDirectory, "manifest.json"), "utf8"));
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported skewb solver table manifest version: ${manifest.version}`);
+    }
+    const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, SKEWB_SOLVER_TABLE_METADATA.permutationTable.checksum);
+    const orientationTable = readUint16Table(assetDirectory, manifest.files.orientationTable, SKEWB_SOLVER_TABLE_METADATA.orientationTable.checksum);
+    const centersTable = readUint16Table(assetDirectory, manifest.files.centersTable, SKEWB_SOLVER_TABLE_METADATA.centersTable.checksum);
+    const helpersBuffer = readFileSync(path.join(assetDirectory, manifest.files.helpers.file));
+    if (helpersBuffer.length !== manifest.files.helpers.entries) {
+        throw new Error(`Invalid byte size for ${manifest.files.helpers.file}`);
+    }
+    assertChecksum(manifest.files.helpers.file, checksum(new Uint8Array(helpersBuffer)), SKEWB_SOLVER_TABLE_METADATA.helpers.checksum);
+    const evenCenterRank = new Uint16Array(SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes / 2);
+    for (let i = 0; i < evenCenterRank.length; i++) {
+        evenCenterRank[i] = helpersBuffer.readUInt16LE(i * 2);
+    }
+    const orientClass = new Uint8Array(helpersBuffer.subarray(SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes, SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes + SKEWB_SOLVER_TABLE_METADATA.helpers.orientClassBytes));
+    const r7SetsBuffer = helpersBuffer.subarray(SKEWB_SOLVER_TABLE_METADATA.helpers.evenCenterRankBytes + SKEWB_SOLVER_TABLE_METADATA.helpers.orientClassBytes);
+    const r7Sets = new Uint16Array(SKEWB_SOLVER_TABLE_METADATA.helpers.r7SetsEntries);
+    for (let i = 0; i < r7Sets.length; i++) {
+        r7Sets[i] = r7SetsBuffer.readUInt16LE(i * 2);
+    }
+    const policyBuffer = readFileSync(path.join(assetDirectory, manifest.files.policyTable.file));
+    if (policyBuffer.length !== manifest.files.policyTable.entries) {
+        throw new Error(`Invalid byte size for ${manifest.files.policyTable.file}`);
+    }
+    const policyTable = new Uint8Array(policyBuffer);
+    assertChecksum(manifest.files.policyTable.file, checksum(policyTable), SKEWB_SOLVER_TABLE_METADATA.policyTable.checksum);
+    return { permutationTable, orientationTable, centersTable, policyTable, evenCenterRank, orientClass, r7Sets };
+}
+function readUint16Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = readFileSync(path.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(entry.entries);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = buffer.readUInt16LE(index * 2);
+    }
+    assertChecksum(entry.file, checksum(values), expectedChecksum);
+    return values;
+}
+function resolveGeneratedAssetDirectory() {
+    const envDirectory = process.env.CUBINGCENTER_SCRAMBLER_TABLES_DIR;
+    if (envDirectory && existsSync(path.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if (existsSync(path.join(candidate, "manifest.json"))) {
+            return candidate;
+        }
+    }
+    throw new Error("Unable to find generated skewb solver tables. Run pnpm skewb:tables.");
+}
+function getAssetDirectoryCandidates() {
+    const cwd = process.cwd();
+    const candidates = [
+        path.join(cwd, "src", GENERATED_DIRECTORY),
+        path.join(cwd, "dist", GENERATED_DIRECTORY),
+        path.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = createRequire(path.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(path.join(path.dirname(packageEntry), GENERATED_DIRECTORY));
+    }
+    catch {
+        // Source-tree usage is covered by the cwd candidates.
+    }
+    return candidates;
+}
+function assertChecksum(file, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Checksum mismatch for ${file}: expected ${expected}, received ${actual}.`);
+    }
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < values.length; index += 1) {
+        hash ^= values[index];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

package/dist/puzzles/skewb/solver/search.d.ts

@@ -0,0 +1,14 @@
+import type { SkewbMove, SkewbState } from "../types.js";
+export interface SkewbSolution {
+    moves: SkewbMove[];
+    depth: number;
+}
+export declare function solveSkewb(state: SkewbState): Promise<SkewbMove[]>;
+export declare function solveSkewbWithInfo(state: SkewbState): Promise<SkewbSolution>;
+export declare function solveSkewbIndices(state: SkewbState): Promise<number[]>;
+export declare function solveSkewbIndicesSync(state: SkewbState): number[];
+export declare function solveSkewbSync(state: SkewbState): SkewbMove[];
+export declare function verifySkewbScramble(state: SkewbState, scrambleMoves: readonly SkewbMove[]): boolean;
+export declare function verifySkewbScrambleIndices(state: SkewbState, solution: readonly number[]): boolean;
+export declare function verifySkewbSolution(state: SkewbState, solutionMoves: readonly SkewbMove[]): boolean;
+//# sourceMappingURL=search.d.ts.map

package/dist/puzzles/skewb/solver/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiBzD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAGxE;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAGlF;AAKD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAG5E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKjE;AAGD,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,CAK7D;AA4ED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAID,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAwBlG;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG"}

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

@@ -0,0 +1,120 @@
+import { ensureTablesLoaded, getCenterIndex, getOrientationIndex, getPerm7Index, getPolicyMoveFromPacked, MOVE_COUNT, PERMUTATION_TABLE, ORIENTATION_TABLE, CENTERS_TABLE, POLICY_TABLE, rankFromComponents, SKEWB_MOVES, SOLVED_RANK } from "./tables.js";
+export async function solveSkewb(state) {
+    await ensureTablesLoaded();
+    return solveWithTables(state).moves;
+}
+export async function solveSkewbWithInfo(state) {
+    await ensureTablesLoaded();
+    return solveWithTables(state);
+}
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..7) in walk order. The inverse of index m is m ^ 1 (moves are
+// paired R/R', U/U', L/L', B/B').
+export async function solveSkewbIndices(state) {
+    await ensureTablesLoaded();
+    return solveWithTablesIndices(state);
+}
+export function solveSkewbIndicesSync(state) {
+    if (!POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTablesIndices(state);
+}
+// Synchronous variant for scripts that have already ensured tables are loaded
+export function solveSkewbSync(state) {
+    if (!POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTables(state).moves;
+}
+function solveWithTables(state) {
+    const indices = solveWithTablesIndices(state);
+    const moves = indices.map((index) => SKEWB_MOVES[index]);
+    return { moves, depth: moves.length };
+}
+function solveWithTablesIndices(state) {
+    const policy = POLICY_TABLE;
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    const centersTable = CENTERS_TABLE;
+    if (state.corners.permutation[0] !== 0) {
+        throw new Error("The Skewb solver requires the UFR corner (index 0) to be fixed " +
+            "as the frame of reference. Please normalize the state before solving.");
+    }
+    let r7 = getPerm7Index(state.corners.permutation);
+    let rO = getOrientationIndex(state.corners.orientation);
+    let rC = getCenterIndex(state.centers);
+    let rank = rankFromComponents(r7, rO, rC);
+    if (rank === SOLVED_RANK) {
+        return [];
+    }
+    const moves = [];
+    while (rank !== SOLVED_RANK) {
+        const m = getPolicyMoveFromPacked(policy, rank);
+        moves.push(m);
+        r7 = permTable[r7 * MOVE_COUNT + m];
+        rO = orientTable[rO * MOVE_COUNT + m];
+        rC = centersTable[rC * MOVE_COUNT + m];
+        rank = rankFromComponents(r7, rO, rC);
+    }
+    return moves;
+}
+// ---------------------------------------------------------------------------
+// Coordinate-walking verification (no full state clones)
+// ---------------------------------------------------------------------------
+const MOVE_INDEX = {};
+for (let i = 0; i < SKEWB_MOVES.length; i++) {
+    MOVE_INDEX[SKEWB_MOVES[i]] = i;
+}
+function walkSkewbCoordinates(start, moves) {
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    const centersTable = CENTERS_TABLE;
+    if (!permTable || !orientTable || !centersTable) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let { r7, rO, rC } = start;
+    for (const move of moves) {
+        const m = MOVE_INDEX[move];
+        r7 = permTable[r7 * MOVE_COUNT + m];
+        rO = orientTable[rO * MOVE_COUNT + m];
+        rC = centersTable[rC * MOVE_COUNT + m];
+    }
+    return { r7, rO, rC };
+}
+export function verifySkewbScramble(state, scrambleMoves) {
+    const final = walkSkewbCoordinates({ r7: 0, rO: 0, rC: 0 }, scrambleMoves);
+    return (final.r7 === getPerm7Index(state.corners.permutation) &&
+        final.rO === getOrientationIndex(state.corners.orientation) &&
+        final.rC === getCenterIndex(state.centers));
+}
+// Numeric verification for the hot scramble path: replays the scramble (the
+// solution reversed with m ^ 1 inverses) without any string parsing.
+export function verifySkewbScrambleIndices(state, solution) {
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    const centersTable = CENTERS_TABLE;
+    if (!permTable || !orientTable || !centersTable) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let r7 = 0;
+    let rO = 0;
+    let rC = 0;
+    for (let index = solution.length - 1; index >= 0; index -= 1) {
+        const m = solution[index] ^ 1;
+        r7 = permTable[r7 * MOVE_COUNT + m];
+        rO = orientTable[rO * MOVE_COUNT + m];
+        rC = centersTable[rC * MOVE_COUNT + m];
+    }
+    return (r7 === getPerm7Index(state.corners.permutation) &&
+        rO === getOrientationIndex(state.corners.orientation) &&
+        rC === getCenterIndex(state.centers));
+}
+export function verifySkewbSolution(state, solutionMoves) {
+    const final = walkSkewbCoordinates({
+        r7: getPerm7Index(state.corners.permutation),
+        rO: getOrientationIndex(state.corners.orientation),
+        rC: getCenterIndex(state.centers)
+    }, solutionMoves);
+    return final.r7 === 0 && final.rO === 0 && final.rC === 0;
+}