@cubingcenter/scrambler 0.6.3 → 0.8.0

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

@@ -1,29 +1,48 @@
 import { SQ1_SOLVER_TABLE_METADATA } from "./table-metadata.js";
 import { fetchTableBuffer } from "../../shared/compressed-fetch.js";
 const TABLES_DIR = "puzzles/sq1/solver/generated";
+const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
 let cachedBrowserTables;
+let cachedBrowserTablesPromise;
 export function getCachedBrowserTables() {
     return cachedBrowserTables;
 }
 export function clearCachedBrowserTables() {
     cachedBrowserTables = undefined;
+    cachedBrowserTablesPromise = undefined;
 }
 export async function loadBrowserTables(baseUrl) {
     if (cachedBrowserTables) {
         return cachedBrowserTables;
     }
+    if (cachedBrowserTablesPromise) {
+        // One shared in-flight promise: concurrent calls trigger exactly one
+        // fetch pass (dedup).
+        return cachedBrowserTablesPromise;
+    }
+    const promise = fetchTables(baseUrl);
+    cachedBrowserTablesPromise = promise;
+    promise.then(() => { }, () => {
+        // A failed load must not poison the dedup slot: purge the rejected
+        // promise so a later call retries from scratch.
+        if (cachedBrowserTablesPromise === promise)
+            cachedBrowserTablesPromise = undefined;
+    });
+    return promise;
+}
+async function fetchTables(baseUrl) {
     const resolved = resolveBaseUrl(baseUrl);
     const manifest = await fetchManifest(resolved);
     const [shapeIdx, shapePrun, shapeTopMove, shapeBottomMove, shapeTwistMove, squareTwistMove, squareTopMove, squareBottomMove, squarePrun] = await Promise.all([
-        fetchInt32Table(resolved, manifest.files.shapeIdx, SQ1_SOLVER_TABLE_METADATA.shapeIdx.entries),
-        fetchInt8Table(resolved, manifest.files.shapePrun, SQ1_SOLVER_TABLE_METADATA.shapePrun.entries),
-        fetchInt32Table(resolved, manifest.files.shapeTopMove, SQ1_SOLVER_TABLE_METADATA.shapeTopMove.entries),
-        fetchInt32Table(resolved, manifest.files.shapeBottomMove, SQ1_SOLVER_TABLE_METADATA.shapeBottomMove.entries),
-        fetchInt32Table(resolved, manifest.files.shapeTwistMove, SQ1_SOLVER_TABLE_METADATA.shapeTwistMove.entries),
-        fetchUint16Table(resolved, manifest.files.squareTwistMove, SQ1_SOLVER_TABLE_METADATA.squareTwistMove.entries),
-        fetchUint16Table(resolved, manifest.files.squareTopMove, SQ1_SOLVER_TABLE_METADATA.squareTopMove.entries),
-        fetchUint16Table(resolved, manifest.files.squareBottomMove, SQ1_SOLVER_TABLE_METADATA.squareBottomMove.entries),
-        fetchInt8Table(resolved, manifest.files.squarePrun, SQ1_SOLVER_TABLE_METADATA.squarePrun.entries),
+        fetchInt32Table(resolved, manifest.files.shapeIdx, SQ1_SOLVER_TABLE_METADATA.shapeIdx),
+        fetchInt8Table(resolved, manifest.files.shapePrun, SQ1_SOLVER_TABLE_METADATA.shapePrun),
+        fetchInt32Table(resolved, manifest.files.shapeTopMove, SQ1_SOLVER_TABLE_METADATA.shapeTopMove),
+        fetchInt32Table(resolved, manifest.files.shapeBottomMove, SQ1_SOLVER_TABLE_METADATA.shapeBottomMove),
+        fetchInt32Table(resolved, manifest.files.shapeTwistMove, SQ1_SOLVER_TABLE_METADATA.shapeTwistMove),
+        fetchUint16Table(resolved, manifest.files.squareTwistMove, SQ1_SOLVER_TABLE_METADATA.squareTwistMove),
+        fetchUint16Table(resolved, manifest.files.squareTopMove, SQ1_SOLVER_TABLE_METADATA.squareTopMove),
+        fetchUint16Table(resolved, manifest.files.squareBottomMove, SQ1_SOLVER_TABLE_METADATA.squareBottomMove),
+        fetchInt8Table(resolved, manifest.files.squarePrun, SQ1_SOLVER_TABLE_METADATA.squarePrun),
     ]);
     cachedBrowserTables = {
         shapeIdx,
@@ -59,34 +78,47 @@ async function fetchManifest(baseUrl) {
     }
     return (await response.json());
 }
-async function fetchInt32Table(baseUrl, entry, expectedEntries) {
-    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
-    if (buffer.byteLength !== expectedEntries * 4) {
-        throw new Error(`Invalid byte size for ${entry.file}`);
-    }
-    const values = new Int32Array(expectedEntries);
+/**
+ * Fetch + verify with the SAME checks as node-loader.ts: byte length from
+ * the manifest entries, FNV-1a checksum against the table-metadata
+ * constants (node skips the checksum when that constant is 0 = "unchecked";
+ * the browser mirrors the guard).
+ */
+async function fetchInt32Table(baseUrl, entry, meta) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedBytes: entry.entries * 4,
+        ...(meta.checksum !== 0 ? { expectedFnv1a: { value: meta.checksum, elementSize: 4 } } : {})
+    });
+    const values = new Int32Array(entry.entries);
     const view = new DataView(buffer);
     for (let i = 0; i < values.length; i++) {
         values[i] = view.getInt32(i * 4, true);
     }
     return values;
 }
-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);
+async function fetchUint16Table(baseUrl, entry, meta) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedBytes: entry.entries * 2,
+        ...(meta.checksum !== 0 ? { expectedFnv1a: { value: meta.checksum, elementSize: 2 } } : {})
+    });
+    const values = new Uint16Array(entry.entries);
     const view = new DataView(buffer);
     for (let i = 0; i < values.length; i++) {
         values[i] = view.getUint16(i * 2, true);
     }
     return values;
 }
-async function fetchInt8Table(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}`);
-    }
+async function fetchInt8Table(baseUrl, entry, meta) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedBytes: entry.entries,
+        // Square-1's int8 tables hash SIGNED values in node (Int8Array).
+        ...(meta.checksum !== 0 ? { expectedFnv1a: { value: meta.checksum, elementSize: 1, signed: true } } : {})
+    });
     return new Int8Array(buffer);
 }

package/dist-cjs/core/api.js

@@ -80,8 +80,16 @@ async function initializeScrambler(baseUrl, eventId) {
         await loadBrowserTables(baseUrl);
     }
     else if (eventId === "444") {
-        const { loadCube4ReductionTablesBrowser } = await Promise.resolve().then(() => __importStar(require("../puzzles/cube4/reduction/browser-loader.js")));
-        await loadCube4ReductionTablesBrowser(baseUrl);
+        // Reduction ends with a 3x3 solve in the same worker. Initializing 444
+        // must also load those required tables, including the caller's base URL.
+        const [cube4, cube3] = await Promise.all([
+            Promise.resolve().then(() => __importStar(require("../puzzles/cube4/reduction/browser-loader.js"))),
+            Promise.resolve().then(() => __importStar(require("../puzzles/cube3/solver/browser-loader.js")))
+        ]);
+        await Promise.all([
+            cube4.loadCube4ReductionTablesBrowser(baseUrl),
+            cube3.loadBrowserTables(baseUrl)
+        ]);
     }
     else if (!eventId) {
         await Promise.all([

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

@@ -6,23 +6,42 @@ 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";
+const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
 let cachedBrowserTables;
+let cachedBrowserTablesPromise;
 function getCachedBrowserTables() {
     return cachedBrowserTables;
 }
 function clearCachedBrowserTables() {
     cachedBrowserTables = undefined;
+    cachedBrowserTablesPromise = undefined;
 }
 async function loadBrowserTables(baseUrl) {
     if (cachedBrowserTables) {
         return cachedBrowserTables;
     }
+    if (cachedBrowserTablesPromise) {
+        // One shared in-flight promise: concurrent calls trigger exactly one
+        // fetch pass (dedup).
+        return cachedBrowserTablesPromise;
+    }
+    const promise = fetchTables(baseUrl);
+    cachedBrowserTablesPromise = promise;
+    promise.then(() => { }, () => {
+        // A failed load must not poison the dedup slot: purge the rejected
+        // promise so a later call retries from scratch.
+        if (cachedBrowserTablesPromise === promise)
+            cachedBrowserTablesPromise = undefined;
+    });
+    return promise;
+}
+async function fetchTables(baseUrl) {
     const resolved = resolveBaseUrl(baseUrl);
     const manifest = await fetchManifest(resolved);
     const [permTable, orientTable, dist] = await Promise.all([
-        fetchUint16Table(resolved, manifest.files.permutationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.permutationTable.entries),
-        fetchUint16Table(resolved, manifest.files.orientationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.orientationTable.entries),
-        fetchUint8Table(resolved, manifest.files.policy, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.policy.entries)
+        fetchUint16Table(resolved, manifest.files.permutationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.permutationTable),
+        fetchUint16Table(resolved, manifest.files.orientationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.orientationTable),
+        fetchUint8Table(resolved, manifest.files.policy, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.policy)
     ]);
     cachedBrowserTables = {
         permutationTable: permTable,
@@ -56,22 +75,31 @@ async function fetchManifest(baseUrl) {
     }
     return manifest;
 }
-async function fetchUint16Table(baseUrl, entry, expectedEntries) {
-    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
-    if (buffer.byteLength !== expectedEntries * 2) {
-        throw new Error(`Invalid byte size for ${entry.file}`);
-    }
-    const values = new Uint16Array(expectedEntries);
+/**
+ * Fetch + verify with the SAME checks as node-loader.ts: byte length from
+ * the manifest entries, FNV-1a checksum against the table-metadata
+ * constants (the values node asserts against).
+ */
+async function fetchUint16Table(baseUrl, entry, meta) {
+    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedBytes: entry.entries * 2,
+        expectedFnv1a: { value: meta.checksum, elementSize: 2 }
+    });
+    const values = new Uint16Array(entry.entries);
     const view = new DataView(buffer);
     for (let i = 0; i < values.length; i++) {
         values[i] = view.getUint16(i * 2, true);
     }
     return values;
 }
-async function fetchUint8Table(baseUrl, entry, expectedEntries) {
-    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
-    if (buffer.byteLength !== expectedEntries) {
-        throw new Error(`Invalid byte size for ${entry.file}`);
-    }
+async function fetchUint8Table(baseUrl, entry, meta) {
+    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedBytes: entry.entries,
+        expectedFnv1a: { value: meta.checksum, elementSize: 1 }
+    });
     return new Uint8Array(buffer);
 }

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

@@ -35,7 +35,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadGeneratedCube2SolverTables = loadGeneratedCube2SolverTables;
 const browser_loader_js_1 = require("./browser-loader.js");
-let cachedTables;
+const load_once_js_1 = require("../../shared/load-once.js");
+// One shared in-flight promise for the node fs load (same pattern as
+// cube3/solver/generated-assets.ts): the previous `cached ??= await …` raced —
+// concurrent callers interleaving on the await both ran `loadNodeTables()`
+// (two filesystem reads, last assignment wins). On rejection the slot is
+// purged so the next call can retry.
+const nodeTablesSlot = { promise: undefined };
 function isBrowser() {
     return typeof self !== "undefined";
 }
@@ -49,8 +55,7 @@ async function loadGeneratedCube2SolverTables() {
             "In browser environments, call `initializeScrambler(baseUrl)` " +
             "before generating scrambles.");
     }
-    cachedTables ??= await loadNodeTables();
-    return cachedTables;
+    return (0, load_once_js_1.loadOnce)(nodeTablesSlot, loadNodeTables);
 }
 async function loadNodeTables() {
     const loader = await Promise.resolve().then(() => __importStar(require(

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

@@ -37,7 +37,7 @@ function solveWithTablesIndices(state) {
     }
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
-    const policy = tables_js_1.POLICY_TABLE;
+    const policy = tables_js_1.POLICY_TABLE_EXPANDED;
     let permIndex = (0, tables_js_1.encodePermutation)(state.corners.permutation);
     let orientIndex = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
     const moves = [];
@@ -45,7 +45,7 @@ function solveWithTablesIndices(state) {
     // candidate scanning (the old BFS-distance gradient walk) is needed.
     let combined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
     while (combined !== 0) {
-        const m = (policy[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        const m = policy[combined];
         moves.push(m);
         permIndex = permTable[permIndex * tables_js_1.MOVE_COUNT + m];
         orientIndex = orientTable[orientIndex * tables_js_1.MOVE_COUNT + m];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BFS_MOVES = exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
+exports.BFS_MOVES = exports.POLICY_TABLE_EXPANDED = exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
 exports.encodePermutation = encodePermutation;
 exports.encodeOrientation = encodeOrientation;
 exports.ensureTablesLoaded = ensureTablesLoaded;
@@ -64,6 +64,12 @@ let tablesLoaded = false;
 exports.PERMUTATION_TABLE = null;
 exports.ORIENTATION_TABLE = null;
 exports.POLICY_TABLE = null;
+/**
+ * Byte-expanded policy (one optimal move per state, no bit-unpacking in
+ * the hot walk). Built at load from the packed table: +3.7 MB RAM,
+ * zero wire/format change.
+ */
+exports.POLICY_TABLE_EXPANDED = null;
 async function ensureTablesLoaded() {
     if (tablesLoaded) {
         return;
@@ -72,8 +78,16 @@ async function ensureTablesLoaded() {
     exports.PERMUTATION_TABLE = tables.permutationTable;
     exports.ORIENTATION_TABLE = tables.orientationTable;
     exports.POLICY_TABLE = tables.policyTable;
+    exports.POLICY_TABLE_EXPANDED = expandNibblePolicy(tables.policyTable, exports.PERMUTATION_COUNT * exports.ORIENTATION_COUNT);
     tablesLoaded = true;
 }
+function expandNibblePolicy(packed, count) {
+    const expanded = new Uint8Array(count);
+    for (let index = 0; index < count; index += 1) {
+        expanded[index] = (packed[index >> 1] >> ((index & 1) << 2)) & 0x0f;
+    }
+    return expanded;
+}
 function areCube2TablesLoaded() {
     return tablesLoaded;
 }
@@ -81,7 +95,7 @@ function areCube2TablesLoaded() {
 // Public API
 // ---------------------------------------------------------------------------
 function getDistance(permIndex, orientIndex) {
-    if (!exports.POLICY_TABLE) {
+    if (!exports.POLICY_TABLE_EXPANDED) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
     const permTable = exports.PERMUTATION_TABLE;
@@ -91,7 +105,7 @@ function getDistance(permIndex, orientIndex) {
     let combined = p * exports.ORIENTATION_COUNT + o;
     let distance = 0;
     while (combined !== 0) {
-        const m = (exports.POLICY_TABLE[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        const m = exports.POLICY_TABLE_EXPANDED[combined];
         p = permTable[p * exports.MOVE_COUNT + m];
         o = orientTable[o * exports.MOVE_COUNT + m];
         combined = p * exports.ORIENTATION_COUNT + o;

package/dist-cjs/puzzles/cube3/moves.js

@@ -35,16 +35,114 @@ const FACE_MOVE_TABLES = {
         edges: { permutation: [0, 1, 2, 11, 4, 5, 6, 10, 8, 9, 3, 7], orientation: [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1] }
     }
 };
-function applyCube3Move(state, move) {
+function quarterEffect(face) {
+    const table = FACE_MOVE_TABLES[face];
+    return {
+        cornerPermutation: table.corners.permutation,
+        cornerOrientation: table.corners.orientation,
+        edgePermutation: table.edges.permutation,
+        edgeOrientation: table.edges.orientation
+    };
+}
+// Compose two effects (apply `first`, then `second`) into one so a move of
+// any suffix costs exactly one pass over the state — no per-quarter-turn
+// cloning, no intermediate states, no closure allocations.
+function composeEffects(first, second) {
+    const cornerPermutation = new Array(8);
+    const cornerOrientation = new Array(8);
+    const edgePermutation = new Array(12);
+    const edgeOrientation = new Array(12);
+    for (let i = 0; i < 8; i++) {
+        const source = second.cornerPermutation[i];
+        cornerPermutation[i] = first.cornerPermutation[source];
+        cornerOrientation[i] = (first.cornerOrientation[source] + second.cornerOrientation[i]) % 3;
+    }
+    for (let i = 0; i < 12; i++) {
+        const source = second.edgePermutation[i];
+        edgePermutation[i] = first.edgePermutation[source];
+        edgeOrientation[i] = (first.edgeOrientation[source] + second.edgeOrientation[i]) % 2;
+    }
+    return { cornerPermutation, cornerOrientation, edgePermutation, edgeOrientation };
+}
+function powerEffect(face, turns) {
+    const quarter = quarterEffect(face);
+    if (turns === 1)
+        return quarter;
+    const half = composeEffects(quarter, quarter);
+    if (turns === 2)
+        return half;
+    return composeEffects(half, quarter);
+}
+// Total effect per move string, built once at module load (mirrors the 4x4
+// fast path): one lookup + one pass per move.
+const COMPOSED_EFFECTS = Object.fromEntries(types_js_1.CUBE3_MOVES.map((move) => {
+    const face = move[0];
+    const suffix = move.slice(1);
+    const turns = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    return [move, powerEffect(face, turns)];
+}));
+function effectForMove(move) {
+    const hit = COMPOSED_EFFECTS[move];
+    if (hit !== undefined)
+        return hit;
     const { face, turns } = parseMoveParts(move);
-    let next = (0, state_js_1.cloneCube3State)(state);
-    for (let index = 0; index < turns; index += 1) {
-        next = applyFaceMove(next, FACE_MOVE_TABLES[face]);
+    return powerEffect(face, turns);
+}
+function applyCube3Move(state, move) {
+    const effect = effectForMove(move);
+    const cornerPermutation = new Array(8);
+    const cornerOrientation = new Array(8);
+    const edgePermutation = new Array(12);
+    const edgeOrientation = new Array(12);
+    for (let i = 0; i < 8; i++) {
+        const source = effect.cornerPermutation[i];
+        cornerPermutation[i] = state.corners.permutation[source];
+        cornerOrientation[i] =
+            (state.corners.orientation[source] + effect.cornerOrientation[i]) % 3;
     }
-    return next;
+    for (let i = 0; i < 12; i++) {
+        const source = effect.edgePermutation[i];
+        edgePermutation[i] = state.edges.permutation[source];
+        edgeOrientation[i] =
+            (state.edges.orientation[source] + effect.edgeOrientation[i]) % 2;
+    }
+    return {
+        corners: { permutation: cornerPermutation, orientation: cornerOrientation },
+        edges: { permutation: edgePermutation, orientation: edgeOrientation }
+    };
 }
 function applyCube3Algorithm(state, moves) {
-    return moves.reduce((current, move) => applyCube3Move(current, move), state);
+    if (moves.length === 0)
+        return (0, state_js_1.cloneCube3State)(state);
+    let curCp = [...state.corners.permutation];
+    let curCo = [...state.corners.orientation];
+    let curEp = [...state.edges.permutation];
+    let curEo = [...state.edges.orientation];
+    let nxtCp = new Array(8);
+    let nxtCo = new Array(8);
+    let nxtEp = new Array(12);
+    let nxtEo = new Array(12);
+    for (const move of moves) {
+        const effect = effectForMove(move);
+        for (let i = 0; i < 8; i++) {
+            const source = effect.cornerPermutation[i];
+            nxtCp[i] = curCp[source];
+            nxtCo[i] = (curCo[source] + effect.cornerOrientation[i]) % 3;
+        }
+        for (let i = 0; i < 12; i++) {
+            const source = effect.edgePermutation[i];
+            nxtEp[i] = curEp[source];
+            nxtEo[i] = (curEo[source] + effect.edgeOrientation[i]) % 2;
+        }
+        [curCp, nxtCp] = [nxtCp, curCp];
+        [curCo, nxtCo] = [nxtCo, curCo];
+        [curEp, nxtEp] = [nxtEp, curEp];
+        [curEo, nxtEo] = [nxtEo, curEo];
+    }
+    return {
+        corners: { permutation: curCp, orientation: curCo },
+        edges: { permutation: curEp, orientation: curEo }
+    };
 }
 function invertCube3Algorithm(moves) {
     return [...moves].reverse().map(invertCube3Move);
@@ -199,18 +297,6 @@ function invertCube3Move(move) {
     }
     return `${face}${suffix === "'" ? "" : "'"}`;
 }
-function applyFaceMove(state, table) {
-    return {
-        corners: {
-            permutation: table.corners.permutation.map((source) => state.corners.permutation[source]),
-            orientation: table.corners.permutation.map((source, target) => ((state.corners.orientation[source] + table.corners.orientation[target]) % 3))
-        },
-        edges: {
-            permutation: table.edges.permutation.map((source) => state.edges.permutation[source]),
-            orientation: table.edges.permutation.map((source, target) => ((state.edges.orientation[source] + table.edges.orientation[target]) % 2))
-        }
-    };
-}
 function parseMoveParts(move) {
     const face = move[0];
     const suffix = move.slice(1);

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

@@ -22,7 +22,7 @@ exports.cube3ScrambleGenerator = {
 };
 async function generateCube3Scramble(options = {}) {
     const state = (0, random_state_js_1.generateRandomCube3State)(options);
-    const solution = await (0, index_js_1.solveCube3State)(state);
+    const solution = await (0, index_js_1.solveCube3State)(state, options.solver ?? {});
     const scrambleMoves = (0, moves_js_1.invertCube3Algorithm)(solution.moves);
     if (!options.skipValidation) {
         const scrambledState = (0, moves_js_1.applyCube3Algorithm)((0, state_js_1.createSolvedCube3State)(), scrambleMoves);

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

@@ -7,6 +7,7 @@ const compressed_fetch_js_1 = require("../../shared/compressed-fetch.js");
 const TABLES_DIR = "puzzles/cube3/solver/generated";
 const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
 let browserTables;
+let browserTablesPromise;
 function resolveBaseUrl(provided) {
     if (provided) {
         return provided.replace(/\/$/, "");
@@ -25,11 +26,28 @@ function getCachedBrowserTables() {
 }
 function clearCachedBrowserTables() {
     browserTables = undefined;
+    browserTablesPromise = undefined;
 }
 async function loadBrowserTables(baseUrl) {
     if (browserTables) {
         return browserTables;
     }
+    if (browserTablesPromise) {
+        // One shared in-flight promise: concurrent calls trigger exactly one
+        // fetch pass (dedup).
+        return browserTablesPromise;
+    }
+    const promise = fetchTables(baseUrl);
+    browserTablesPromise = promise;
+    promise.then(() => { }, () => {
+        // A failed load must not poison the dedup slot: purge the rejected
+        // promise so a later call retries from scratch.
+        if (browserTablesPromise === promise)
+            browserTablesPromise = undefined;
+    });
+    return promise;
+}
+async function fetchTables(baseUrl) {
     const resolvedBase = resolveBaseUrl(baseUrl);
     const manifest = await fetchManifest(resolvedBase);
     browserTables = {
@@ -63,19 +81,15 @@ async function fetchJointTables(baseUrl, entries) {
         return undefined;
     }
     const fetchJoint = async (entry) => {
+        // Verified by fetchTableBuffer with the SAME checks as node-loader.ts:
+        // nibble-packed byte length + FNV-1a over the packed bytes.
         const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, {
             cacheName: CACHE_NAME,
-            compressed: entry.compressed !== false
+            compressed: entry.compressed !== false,
+            expectedBytes: Math.ceil((entry.rangeA * entry.rangeB) / 2),
+            expectedFnv1a: { value: entry.checksum, elementSize: 1 }
         });
-        const expectedBytes = Math.ceil((entry.rangeA * entry.rangeB) / 2);
-        if (buffer.byteLength !== expectedBytes) {
-            throw new Error(`Invalid byte size for ${entry.file}.`);
-        }
-        const values = new Uint8Array(buffer);
-        if (checksum(values) !== entry.checksum) {
-            throw new Error(`Checksum mismatch for ${entry.file}.`);
-        }
-        return values;
+        return new Uint8Array(buffer);
     };
     return {
         jointUdCo: await fetchJoint(entries.udCo),
@@ -95,15 +109,23 @@ async function fetchManifest(baseUrl) {
     return manifest;
 }
 async function fetchMoveTable(baseUrl, entry) {
-    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, { cacheName: CACHE_NAME, compressed: entry.compressed !== false });
-    const expectedBytes = entry.range * entry.moves.length * 4;
-    if (buffer.byteLength !== expectedBytes) {
-        throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
-    }
-    const values = new Int32Array(entry.range * entry.moves.length);
+    // Verified by fetchTableBuffer with the SAME checks as node-loader.ts:
+    // int32 wire length + FNV-1a over the decoded coordinate values (element
+    // size 4 reproduces node's hash over the uint16 values — same numbers).
+    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedBytes: entry.range * entry.moves.length * 4,
+        expectedFnv1a: { value: entry.checksum, elementSize: 4 }
+    });
+    const values = new Uint16Array(entry.range * entry.moves.length);
     const view = new DataView(buffer);
     for (let index = 0; index < values.length; index += 1) {
-        values[index] = view.getInt32(index * 4, true);
+        const value = view.getInt32(index * 4, true);
+        if (value < 0 || value > 0xffff) {
+            throw new Error(`Move table value out of range for ${entry.coordinate}: ${value}.`);
+        }
+        values[index] = value;
     }
     return {
         coordinate: entry.coordinate,
@@ -115,11 +137,15 @@ async function fetchMoveTable(baseUrl, entry) {
     };
 }
 async function fetchPruningTable(baseUrl, entry) {
-    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, { cacheName: CACHE_NAME, compressed: entry.compressed !== false });
-    const expectedBytes = Math.ceil(entry.range / 2);
-    if (buffer.byteLength !== expectedBytes) {
-        throw new Error(`Invalid byte size for ${entry.coordinate} pruning table.`);
-    }
+    // Verified by fetchTableBuffer with the SAME checks as node-loader.ts:
+    // nibble-packed byte length + FNV-1a over the packed bytes (this browser
+    // path did NOT compare the pruning checksum before — only the length).
+    const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedBytes: Math.ceil(entry.range / 2),
+        expectedFnv1a: { value: entry.checksum, elementSize: 1 }
+    });
     const values = new Uint8Array(buffer);
     return {
         coordinate: entry.coordinate,

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

@@ -37,10 +37,17 @@ exports.loadGeneratedCube3SolverTables = loadGeneratedCube3SolverTables;
 exports.loadGeneratedCube3Phase1Tables = loadGeneratedCube3Phase1Tables;
 exports.loadGeneratedCube3Phase2Tables = loadGeneratedCube3Phase2Tables;
 const browser_loader_js_1 = require("./browser-loader.js");
-let cachedGeneratedTables;
+const load_once_js_1 = require("../../shared/load-once.js");
 function isBrowser() {
     return typeof self !== "undefined";
 }
+// One shared in-flight promise for the node fs load: mixed concurrent
+// phase-1 + phase-2 loads (separate slots in tables.ts) converge on ONE
+// `readGeneratedCube3SolverTables()` call. The previous `cached ??= await …`
+// raced — two callers interleaving on the await both ran `loadNodeTables()`
+// (two filesystem reads, two table sets, last assignment wins). On
+// rejection the slot is purged so the next call can retry.
+const nodeTablesSlot = { promise: undefined };
 async function loadGeneratedCube3SolverTables() {
     if (isBrowser()) {
         const browserTables = (0, browser_loader_js_1.getCachedBrowserTables)();
@@ -51,8 +58,7 @@ async function loadGeneratedCube3SolverTables() {
             "In browser environments, call `initializeScrambler(baseUrl)` " +
             "before generating scrambles.");
     }
-    cachedGeneratedTables ??= await loadNodeTables();
-    return cachedGeneratedTables;
+    return (0, load_once_js_1.loadOnce)(nodeTablesSlot, loadNodeTables);
 }
 async function loadNodeTables() {
     const loader = await Promise.resolve().then(() => __importStar(require(