@cubingcenter/scrambler 0.6.3 → 0.8.0

package/README.md

@@ -16,7 +16,7 @@ The package currently ships random-state scramblers for `222` (2x2x2), `333` (3x
 - 3x3 quality: random-state target + two-phase solver + verified scramble inversion
 - Pyraminx quality: random-state target + optimal policy-table solver (all 933,120 core states verified)
 - Skewb quality: random-state target + optimal policy-table solver (all 3,149,280 states; exact uniform sampling)
-- 4x4 quality: random-state target (uniform sampler) + reduction solver (4 phases) + verified scramble inversion
+- 4x4 quality: random-state target (uniform sampler) + reduction solver (4 phases) + exact target reproduction, validated against the sampled state on every generation
 
 This library is intended for practice, training, and internal CubingCenter use. Do not present it as an official WCA competition scrambler; sanctioned competitions must use the official program required by the delegate/organization.
 
@@ -59,7 +59,7 @@ console.log(batch.map((item) => item.scramble));
 
 `generateScramble("333")` returns a legal random-state 3x3 scramble. Its metadata includes the target cubie state, timer-ready facelets, a 54-character facelet string, and solver diagnostics.
 
-`generateScramble("pymx")` returns a legal random-state Pyraminx scramble. Its metadata includes the target state, facelets, solution moves and depth. Pyraminx/2x2/3x3 accept `{ skipValidation: true }` to skip the per-call verification for maximum throughput (the scramble correctness is covered by exhaustive tests).
+`generateScramble("pymx")` returns a legal random-state Pyraminx scramble. Its metadata includes the target state, facelets, solution moves and depth. Pyraminx/2x2/3x3/444 accept `{ skipValidation: true }` to skip the per-call verification for maximum throughput (correctness is covered by the test suite, and independently by `pnpm verify:scrambles`, which re-samples each target from its seed).
 
 ## Scoped imports (web / smaller bundles)
 
@@ -194,7 +194,17 @@ const paired = cube4.areWingsPaired(state);
 
 Supported moves: `U D R L F B` (outer) and `Uw Dw Rw Lw Fw Bw` (wide), each with `'` and `2` suffixes.
 
-The public `generateScramble("444")` path is: sample a uniform random state (`generateRandomCube4State` — corners `8! × 3^7`, wings `24!`, centers as a color multiset `24!/(4!)^6`), solve it with the reduction solver (phases: axis-color face-pairs → ct/rl phase-2 goal → joint center3+pairing → 3x3 finish), and invert the solution — so the scramble always reproduces the sampled target. The pairing pruning table is generated by a C++ tool (`tools/edge3-gen/`).
+The public `generateScramble("444")` path is: sample a uniform random state (`generateRandomCube4State` — corners `8! × 3^7`, wings `24!`, centers as a color multiset `24!/(4!)^6`), solve it with the reduction solver (phases: axis-color face-pairs → ct/rl phase-2 goal → joint center3+pairing → 3x3 finish), and invert the solution — so the scramble always reproduces the sampled target. The production path enforces this on every generation (`assertCube4ScrambleReproducesTarget` re-applies the emitted moves and compares against the state sampled for the seed; a mismatch retries the SAME target — never re-samples, never falls back to random-move). The pairing pruning table is generated by a C++ tool (`tools/edge3-gen/`).
+
+How to verify 444, from cheap to heavy:
+
+- `pnpm test` — model/round-trip tests, the rotation-sensitive invariant (`test/cube4-solve-invariant.test.ts`), and the uniformity net (`test/cube4-uniformity.test.ts`: χ² over a fixed corpus at two layers — direct sampler N=20,000 and full pipeline N=40 with structural checks on parity quadrants and per-slot diversity).
+- `pnpm verify:scrambles 444` — independent replay: the target is re-sampled from the seed and the solution must genuinely solve it.
+- `node --import tsx scripts/uniformity-444.ts --n=500` — heavy χ² bench over the state **reached** by the pipeline (centers/wings/corners per slot, twist, parity quadrants, joint bins); exits 1 below threshold. The corpora are fixed seeds, so the numbers are deterministic; p-values are reference values, not classical significance.
+
+Measured baseline (i5-13420H, warm): 46–53 moves per scramble (avg ≈ 48), latency p50 ≈ 2–3 s / p95 ≈ 9 s, ~37 MB of reduction tables loaded once. Seeded 444 generation is a pure function of `(seed, options)` — search budgets are node counters, not wall deadlines; the only wall-clock code is a pair of hang guards that never bound an observed solve.
+
+Shorter 444 scrambles, two mechanisms: `bestOf: N` solves N independently sampled states and keeps the shortest (trades CPU time, biases toward short-solution states), while `restarts: R` re-runs the full pipeline R times over the SAME state with a deterministically reshuffled search order and keeps the shortest total (uniformity-preserving; measured ~-0.45 moves at R=3, ~-0.85 at R=6 on a 24-state corpus, single-attempt mean ~46.1).
 
 `validateCube4State` checks the reachability constraints of a normal (non-super) 4x4: corner permutation + orientation sum divisible by 3, wing permutation (wings have no orientation), and 4-of-each-color centers. There is no visible corner/wing parity constraint on a normal 4x4 (all four parity combinations are reachable).
 
@@ -240,9 +250,12 @@ pnpm package:check
 pnpm verify
 ```
 
-Solver tables are versioned as generated binary assets. If cube coordinates, moves, or pruning logic change, regenerate and check them:
+Solver tables are versioned as generated binary assets. If cube coordinates, moves, or pruning logic change, regenerate and check them (the 4x4 reduction tables follow the same pattern, one script per phase):
 
 ```sh
 pnpm cube3:tables
 pnpm cube3:tables:check
+pnpm cube4:center1:tables:check   # likewise center2, center3, edge3, hc
 ```
+
+`pnpm verify` runs lint, the full test suite, the build, every table checksum check (including all five `cube4:*:tables:check`), and the package checks. `pnpm verify:scrambles [--count N] [events…]` additionally replays generated scrambles against independently re-sampled targets and exits 1 on any mismatch.

package/dist/core/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/core/api.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCrG;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,iBAAmC,GAC5C,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,GAAE,iBAAmC,GAAG,SAAS,EAAE,CAE7F;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,iBAAmC,GAC5C,SAAS,CAQX;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,EAAE,CAAC,CAU3B"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/core/api.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CrG;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,iBAAmC,GAC5C,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,GAAE,iBAAmC,GAAG,SAAS,EAAE,CAE7F;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,iBAAmC,GAC5C,SAAS,CAQX;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,EAAE,CAAC,CAU3B"}

package/dist/core/api.js

@@ -39,8 +39,16 @@ export async function initializeScrambler(baseUrl, eventId) {
         await loadBrowserTables(baseUrl);
     }
     else if (eventId === "444") {
-        const { loadCube4ReductionTablesBrowser } = await import("../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([
+            import("../puzzles/cube4/reduction/browser-loader.js"),
+            import("../puzzles/cube3/solver/browser-loader.js")
+        ]);
+        await Promise.all([
+            cube4.loadCube4ReductionTablesBrowser(baseUrl),
+            cube3.loadBrowserTables(baseUrl)
+        ]);
     }
     else if (!eventId) {
         await Promise.all([

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/browser-loader.ts"],"names":[],"mappings":"AAWA,wBAAgB,sBAAsB;sBALlB,WAAW;sBACX,WAAW;iBAChB,UAAU;cAKxB;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,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAqBD"}
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/browser-loader.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,kBAAkB;IACjC,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB;AAKD,wBAAgB,sBAAsB,IAAI,kBAAkB,GAAG,SAAS,CAEvE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAoBrF"}

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

@@ -1,23 +1,42 @@
 import { CUBE2_SOLVER_TABLE_METADATA } from "./table-metadata.js";
 import { fetchTableBuffer } from "../../shared/compressed-fetch.js";
 const TABLES_DIR = "puzzles/cube2/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 [permTable, orientTable, dist] = await Promise.all([
-        fetchUint16Table(resolved, manifest.files.permutationTable, CUBE2_SOLVER_TABLE_METADATA.permutationTable.entries),
-        fetchUint16Table(resolved, manifest.files.orientationTable, CUBE2_SOLVER_TABLE_METADATA.orientationTable.entries),
-        fetchUint8Table(resolved, manifest.files.policy, CUBE2_SOLVER_TABLE_METADATA.policy.entries)
+        fetchUint16Table(resolved, manifest.files.permutationTable, CUBE2_SOLVER_TABLE_METADATA.permutationTable),
+        fetchUint16Table(resolved, manifest.files.orientationTable, CUBE2_SOLVER_TABLE_METADATA.orientationTable),
+        fetchUint8Table(resolved, manifest.files.policy, CUBE2_SOLVER_TABLE_METADATA.policy)
     ]);
     cachedBrowserTables = {
         permutationTable: permTable,
@@ -51,22 +70,31 @@ async function fetchManifest(baseUrl) {
     }
     return manifest;
 }
-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);
+/**
+ * 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 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 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 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/puzzles/cube2/solver/generated-assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/generated-assets.ts"],"names":[],"mappings":"AAYA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAeD"}
+{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/generated-assets.ts"],"names":[],"mappings":"AAkBA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAcD"}

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

@@ -1,5 +1,11 @@
 import { getCachedBrowserTables } from "./browser-loader.js";
-let cachedTables;
+import { loadOnce } from "../../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";
 }
@@ -13,8 +19,7 @@ export async function loadGeneratedCube2SolverTables() {
             "In browser environments, call `initializeScrambler(baseUrl)` " +
             "before generating scrambles.");
     }
-    cachedTables ??= await loadNodeTables();
-    return cachedTables;
+    return loadOnce(nodeTablesSlot, loadNodeTables);
 }
 async function loadNodeTables() {
     const loader = await import(

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

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAQ/E;AAKD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKtE;AAoDD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAMD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAclG"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAezD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAQ/E;AAKD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKtE;AAoDD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAMD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAclG"}

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

@@ -1,5 +1,5 @@
 import { createSolvedCube2State } from "../state.js";
-import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, POLICY_TABLE, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
+import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, POLICY_TABLE, POLICY_TABLE_EXPANDED, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
 export async function solveCube2State(state) {
     await ensureTablesLoaded();
     const indices = solveWithTablesIndices(state);
@@ -29,7 +29,7 @@ function solveWithTablesIndices(state) {
     }
     const permTable = PERMUTATION_TABLE;
     const orientTable = ORIENTATION_TABLE;
-    const policy = POLICY_TABLE;
+    const policy = POLICY_TABLE_EXPANDED;
     let permIndex = encodePermutation(state.corners.permutation);
     let orientIndex = encodeOrientation(state.corners.orientation);
     const moves = [];
@@ -37,7 +37,7 @@ function solveWithTablesIndices(state) {
     // candidate scanning (the old BFS-distance gradient walk) is needed.
     let combined = permIndex * 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 * MOVE_COUNT + m];
         orientIndex = orientTable[orientIndex * MOVE_COUNT + m];

package/dist/puzzles/cube2/solver/tables.d.ts

@@ -6,6 +6,12 @@ export declare function encodeOrientation(orientation: readonly number[]): numbe
 export declare let PERMUTATION_TABLE: Uint16Array | null;
 export declare let ORIENTATION_TABLE: Uint16Array | null;
 export declare let POLICY_TABLE: Uint8Array | 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.
+ */
+export declare let POLICY_TABLE_EXPANDED: Uint8Array | null;
 export declare function ensureTablesLoaded(): Promise<void>;
 export declare function areCube2TablesLoaded(): boolean;
 export declare function getDistance(permIndex: number, orientIndex: number): number;

package/dist/puzzles/cube2/solver/tables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAW5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYxE;AAWD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAElD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAkB1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAW5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYxE;AAWD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAClD;;;;GAIG;AACH,eAAO,IAAI,qBAAqB,EAAE,UAAU,GAAG,IAAW,CAAC;AAE3D,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAcxD;AAUD,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAkB1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}

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

@@ -54,6 +54,12 @@ let tablesLoaded = false;
 export let PERMUTATION_TABLE = null;
 export let ORIENTATION_TABLE = null;
 export let 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.
+ */
+export let POLICY_TABLE_EXPANDED = null;
 export async function ensureTablesLoaded() {
     if (tablesLoaded) {
         return;
@@ -62,8 +68,16 @@ export async function ensureTablesLoaded() {
     PERMUTATION_TABLE = tables.permutationTable;
     ORIENTATION_TABLE = tables.orientationTable;
     POLICY_TABLE = tables.policyTable;
+    POLICY_TABLE_EXPANDED = expandNibblePolicy(tables.policyTable, PERMUTATION_COUNT * 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;
+}
 export function areCube2TablesLoaded() {
     return tablesLoaded;
 }
@@ -71,7 +85,7 @@ export function areCube2TablesLoaded() {
 // Public API
 // ---------------------------------------------------------------------------
 export function getDistance(permIndex, orientIndex) {
-    if (!POLICY_TABLE) {
+    if (!POLICY_TABLE_EXPANDED) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
     const permTable = PERMUTATION_TABLE;
@@ -81,7 +95,7 @@ export function getDistance(permIndex, orientIndex) {
     let combined = p * ORIENTATION_COUNT + o;
     let distance = 0;
     while (combined !== 0) {
-        const m = (POLICY_TABLE[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        const m = POLICY_TABLE_EXPANDED[combined];
         p = permTable[p * MOVE_COUNT + m];
         o = orientTable[o * MOVE_COUNT + m];
         combined = p * ORIENTATION_COUNT + o;

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

@@ -4,6 +4,7 @@ export { cloneCube3State, createSolvedCube3State, cube3StatesEqual, isSolvedCube
 export { isAllowedRandomCube3State, isOneMoveFromSolvedCube3State, permutationParity, validateCube3State } from "./validation.js";
 export { generateRandomCube3State } from "./random-state.js";
 export { cube3ScrambleGenerator, generateCube3Scramble } from "./scrambler.js";
+export type { Cube3ScrambleOptions } from "./scrambler.js";
 export { formatCube3Facelets, getCube3FaceOrder, toCube3Facelets } from "./facelets.js";
 export * as solver from "./solver/index.js";
 export type { Cube3Face, Cube3Facelets, Cube3Move, Cube3FaceMove, Cube3MoveSuffix, Cube3RandomStateOptions, Cube3Sticker, Cube3State, Cube3ValidationResult } from "./types.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACX,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,yBAAyB,EACzB,6BAA6B,EAC7B,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EAChB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,aAAa,EACb,eAAe,EACf,uBAAuB,EACvB,YAAY,EACZ,UAAU,EACV,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,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/cube3/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACX,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,yBAAyB,EACzB,6BAA6B,EAC7B,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EAChB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,aAAa,EACb,eAAe,EACf,uBAAuB,EACvB,YAAY,EACZ,UAAU,EACV,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/cube3/moves.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/moves.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiB,SAAS,EAAmB,UAAU,EAAE,MAAM,YAAY,CAAC;AAyCxF,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAS7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CAE9F;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAoFlE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAMvD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAQ1D"}
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/moves.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiB,SAAS,EAAmB,UAAU,EAAE,MAAM,YAAY,CAAC;AAyGxF,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAsB7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CA+B9F;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAoFlE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAMvD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAQ1D"}

package/dist/puzzles/cube3/moves.js

@@ -26,16 +26,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] }
     }
 };
-export 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(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 = cloneCube3State(state);
-    for (let index = 0; index < turns; index += 1) {
-        next = applyFaceMove(next, FACE_MOVE_TABLES[face]);
+    return powerEffect(face, turns);
+}
+export 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 }
+    };
 }
 export function applyCube3Algorithm(state, moves) {
-    return moves.reduce((current, move) => applyCube3Move(current, move), state);
+    if (moves.length === 0)
+        return 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 }
+    };
 }
 export function invertCube3Algorithm(moves) {
     return [...moves].reverse().map(invertCube3Move);
@@ -190,18 +288,6 @@ export 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/puzzles/cube3/scrambler.d.ts

@@ -1,6 +1,21 @@
 import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
+import type { Cube3SolveOptions } from "./solver/index.js";
+/**
+ * 333-specific scramble options (pass-through; extra keys are ignored by
+ * the generic `generateScramble` API surface).
+ */
+export interface Cube3ScrambleOptions {
+    /**
+     * Solver tuning. Tiers (browser tables): `fast` (~14 ms, ~23.1 moves),
+     * `short` default (~36 ms, ~21.9 moves), `best` (~116 ms, ~20.8 moves,
+     * max 22). Granular overrides: `phase1ExtraDepth`,
+     * `phase1SolutionLimit`, `improvePhase2TimeoutMs`, `orientations`
+     * (1-24), `targetLength`, `timeoutMs`.
+     */
+    solver?: Cube3SolveOptions;
+}
 export declare const cube3ScrambleGenerator: ScrambleGenerator;
-export declare function generateCube3Scramble(options?: ScrambleOptions & {
+export declare function generateCube3Scramble(options?: ScrambleOptions & Cube3ScrambleOptions & {
     skipValidation?: boolean;
 }): Promise<ScrambleResult>;
 //# sourceMappingURL=scrambler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAW9F,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"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAU9F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC5B;AAED,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG,oBAAoB,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAClF,OAAO,CAAC,cAAc,CAAC,CAgDzB"}

package/dist/puzzles/cube3/scrambler.js

@@ -18,7 +18,7 @@ export const cube3ScrambleGenerator = {
 };
 export async function generateCube3Scramble(options = {}) {
     const state = generateRandomCube3State(options);
-    const solution = await solveCube3State(state);
+    const solution = await solveCube3State(state, options.solver ?? {});
     const scrambleMoves = invertCube3Algorithm(solution.moves);
     if (!options.skipValidation) {
         const scrambledState = applyCube3Algorithm(createSolvedCube3State(), scrambleMoves);

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

@@ -1 +1 @@
-{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/browser-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAMV,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAsDrB,wBAAgB,sBAAsB,IAAI,iBAAiB,GAAG,SAAS,CAEtE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA2CpF"}
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/browser-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAMV,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAuDrB,wBAAgB,sBAAsB,IAAI,iBAAiB,GAAG,SAAS,CAEtE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAoBpF"}