@cubingcenter/scrambler 0.6.3 → 0.7.0

package/README.md

@@ -196,6 +196,8 @@ Supported moves: `U D R L F B` (outer) and `Uw Dw Rw Lw Fw Bw` (wide), each with
 
 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/`).
 
+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).
 
 ## CLI

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.js

@@ -95,10 +95,14 @@ async function fetchMoveTable(baseUrl, entry) {
     if (buffer.byteLength !== expectedBytes) {
         throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
     }
-    const values = new Int32Array(entry.range * entry.moves.length);
+    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,

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

@@ -1,10 +1,12 @@
 export { applyCube3Phase2Moves, encodeCube3Phase2Coordinates, isCube3Phase2Solved, solveCube3Phase2, solveCube3State, Cube3Phase2SearchError } from "./phase2.js";
-export { applyCube3Phase1Moves, encodeCube3Phase1Coordinates, isCube3Phase1Solved, solveCube3Phase1, Cube3Phase1SearchError } from "./phase1.js";
+export { applyCube3Phase1Moves, collectCube3Phase1Solutions, encodeCube3Phase1Coordinates, isCube3Phase1Solved, solveCube3Phase1, Cube3Phase1SearchError } from "./phase1.js";
+export { CUBE3_ORIENTATIONS_24, CUBE3_ROTATION_INVERSE, invertCube3RotationSequence, rotateCube3Algorithm, rotateCube3AlgorithmBySequence } from "./symmetry.js";
+export type { Cube3Rotation, Cube3RotationSequence } from "./symmetry.js";
 export { CUBE3_COORDINATE_RANGES, createRepresentativeStateForCoordinate, decodeCornerOrientation, decodeEdgeOrientation, decodePermutation, decodeSlicePermutation, decodeUdEdgePermutation, decodeUdSlice, encodeCube3Coordinate, encodeCornerOrientation, encodeCube3Coordinates, encodeEdgeOrientation, encodePermutation, encodeSlicePermutation, encodeUdEdgePermutation, encodeUdSlice, moveCoordinate } from "./coordinates.js";
 export { CUBE3_SOLVER_TABLE_METADATA } from "./table-metadata.js";
 export { CUBE3_PHASE1_MOVES, CUBE3_PHASE2_MOVES, checksum, generateCube3Phase1Tables, generateCube3Phase2Tables, generateCube3MoveTable, generateCube3PruningTable, generateCube3SolverTables, loadCube3Phase1Tables, loadCube3Phase2Tables, loadCube3SolverTables, lookupCube3MoveTable } from "./tables.js";
-export type { Cube3Phase2Coordinates, Cube3Phase2Options, Cube3Phase2Result, Cube3SolveOptions, Cube3SolveResult } from "./phase2.js";
-export type { Cube3Phase1Coordinates, Cube3Phase1Options, Cube3Phase1Result } from "./phase1.js";
+export type { Cube3Phase2Coordinates, Cube3Phase2Options, Cube3Phase2Result, Cube3SolveOptions, Cube3SolveQuality, Cube3SolveResult } from "./phase2.js";
+export type { Cube3Phase1CollectOptions, Cube3Phase1Coordinates, Cube3Phase1Options, Cube3Phase1Result } from "./phase1.js";
 export type { Cube3CoordinateState } from "./coordinates.js";
 export type { Cube3CoordinateName, Cube3Phase1Tables, Cube3Phase2Tables, Cube3MoveTable, Cube3PruningTable, Cube3SolverTables } from "./tables.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,uBAAuB,EACvB,sCAAsC,EACtC,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,cAAc,EACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,2BAA2B,EAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,yBAAyB,EACzB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,qBAAqB,EACrB,2BAA2B,EAC3B,4BAA4B,EAC5B,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,2BAA2B,EAC3B,oBAAoB,EACpB,8BAA8B,EAC/B,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EACL,uBAAuB,EACvB,sCAAsC,EACtC,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,cAAc,EACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,2BAA2B,EAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,yBAAyB,EACzB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,yBAAyB,EACzB,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC"}

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

@@ -1,5 +1,6 @@
 export { applyCube3Phase2Moves, encodeCube3Phase2Coordinates, isCube3Phase2Solved, solveCube3Phase2, solveCube3State, Cube3Phase2SearchError } from "./phase2.js";
-export { applyCube3Phase1Moves, encodeCube3Phase1Coordinates, isCube3Phase1Solved, solveCube3Phase1, Cube3Phase1SearchError } from "./phase1.js";
+export { applyCube3Phase1Moves, collectCube3Phase1Solutions, encodeCube3Phase1Coordinates, isCube3Phase1Solved, solveCube3Phase1, Cube3Phase1SearchError } from "./phase1.js";
+export { CUBE3_ORIENTATIONS_24, CUBE3_ROTATION_INVERSE, invertCube3RotationSequence, rotateCube3Algorithm, rotateCube3AlgorithmBySequence } from "./symmetry.js";
 export { CUBE3_COORDINATE_RANGES, createRepresentativeStateForCoordinate, decodeCornerOrientation, decodeEdgeOrientation, decodePermutation, decodeSlicePermutation, decodeUdEdgePermutation, decodeUdSlice, encodeCube3Coordinate, encodeCornerOrientation, encodeCube3Coordinates, encodeEdgeOrientation, encodePermutation, encodeSlicePermutation, encodeUdEdgePermutation, encodeUdSlice, moveCoordinate } from "./coordinates.js";
 export { CUBE3_SOLVER_TABLE_METADATA } from "./table-metadata.js";
 export { CUBE3_PHASE1_MOVES, CUBE3_PHASE2_MOVES, checksum, generateCube3Phase1Tables, generateCube3Phase2Tables, generateCube3MoveTable, generateCube3PruningTable, generateCube3SolverTables, loadCube3Phase1Tables, loadCube3Phase2Tables, loadCube3SolverTables, lookupCube3MoveTable } from "./tables.js";

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

@@ -65,9 +65,16 @@ function readMoveTable(assetDirectory, entry) {
     if (buffer.length !== expectedBytes) {
         throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
     }
-    const values = new Int32Array(entry.range * entry.moves.length);
+    // Every coordinate fits in 16 bits (max range 40320): store half the
+    // bytes the int32 wire format uses. Checksums are order-sensitive FNV
+    // over the same numeric sequence, so they still match the manifest.
+    const values = new Uint16Array(entry.range * entry.moves.length);
     for (let index = 0; index < values.length; index += 1) {
-        values[index] = buffer.readInt32LE(index * 4);
+        const value = buffer.readInt32LE(index * 4);
+        if (value < 0 || value > 0xffff) {
+            throw new Error(`Move table value out of range for ${entry.coordinate}: ${value}.`);
+        }
+        values[index] = value;
     }
     const table = {
         coordinate: entry.coordinate,

package/dist/puzzles/cube3/solver/phase1.d.ts

@@ -27,4 +27,22 @@ export declare function solveCube3Phase1(state: Cube3State, options?: Cube3Phase
 export declare function encodeCube3Phase1Coordinates(state: Cube3State): Cube3Phase1Coordinates;
 export declare function isCube3Phase1Solved(input: Cube3State | Cube3Phase1Coordinates, tables: Cube3Phase1Tables): boolean;
 export declare function applyCube3Phase1Moves(state: Cube3State, moves: readonly Cube3Move[]): Cube3State;
+export interface Cube3Phase1CollectOptions {
+    tables?: Cube3Phase1Tables;
+    /** Phase-1 joint tables (ud x co / ud x eo), experimental. */
+    jointTables?: Cube3JointTables | undefined;
+    timeoutMs?: number;
+    /** Stop after collecting this many solutions. Defaults to 32. */
+    limit?: number;
+}
+/**
+ * Enumerates up to `limit` phase-1 solutions of exactly `depth` moves for
+ * the given state, most promising first (same ordered DFS as the search).
+ * Used to try several G1 landing states and keep the best phase-1+phase-2
+ * total — a slightly longer phase 1 often collapses phase 2.
+ */
+export declare function collectCube3Phase1Solutions(state: Cube3State, depth: number, options?: Cube3Phase1CollectOptions): Promise<{
+    solutions: Cube3Move[][];
+    visitedNodes: number;
+}>;
 //# sourceMappingURL=phase1.d.ts.map

package/dist/puzzles/cube3/solver/phase1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phase1.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/phase1.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAMzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOvE,MAAM,WAAW,sBAAsB;IACrC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,8DAA8D;IAC9D,WAAW,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC5C;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;IAClB,WAAW,EAAE,sBAAsB,CAAC;IACpC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;CAKlD;AA+BD,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAkF5B;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,UAAU,GAAG,sBAAsB,CAMtF;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,UAAU,GAAG,sBAAsB,EAC1C,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAQT;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,SAAS,SAAS,EAAE,GAC1B,UAAU,CAEZ"}
+{"version":3,"file":"phase1.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/phase1.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAMzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOvE,MAAM,WAAW,sBAAsB;IACrC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,8DAA8D;IAC9D,WAAW,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC5C;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;IAClB,WAAW,EAAE,sBAAsB,CAAC;IACpC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;CAKlD;AAyCD,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CA2E5B;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,UAAU,GAAG,sBAAsB,CAMtF;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,UAAU,GAAG,sBAAsB,EAC1C,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAQT;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,SAAS,SAAS,EAAE,GAC1B,UAAU,CAEZ;AA0ED,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,8DAA8D;IAC9D,WAAW,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC;IAAE,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAqB7D"}

package/dist/puzzles/cube3/solver/phase1.js

@@ -28,14 +28,7 @@ export async function solveCube3Phase1(state, options = {}) {
     const maxDepth = options.maxDepth ?? 12;
     const start = encodeCube3Phase1Coordinates(state);
     const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
-    const context = {
-        tables,
-        jointTables,
-        maxDepth,
-        deadline,
-        visitedNodes: 0,
-        timedOut: false
-    };
+    const context = createPhase1SearchContext(tables, jointTables, maxDepth, deadline);
     if (await isCube3Phase1Solved(start, tables)) {
         return {
             moves: [],
@@ -116,6 +109,66 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
             edgeOrientation === 0 &&
             udSlice === context.tables.moveTables.udSlice.solvedCoordinate;
     }
+    const moveCount = context.tables.phase1Moves.length;
+    const childCount = collectPhase1Children(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, context);
+    const slot = remainingDepth * moveCount;
+    const scratchMove = context.scratchMove;
+    const scratchCo = context.scratchCo;
+    const scratchEo = context.scratchEo;
+    const scratchUd = context.scratchUd;
+    for (let i = 0; i < childCount; i += 1) {
+        const moveIndex = scratchMove[slot + i];
+        const face = PHASE1_MOVE_FACES[moveIndex];
+        path.push(context.tables.phase1Moves[moveIndex]);
+        if (searchPhase1(scratchCo[slot + i], scratchEo[slot + i], scratchUd[slot + i], face, previousFace, remainingDepth - 1, path, context)) {
+            return true;
+        }
+        path.pop();
+        if (context.timedOut) {
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Enumerates up to `limit` phase-1 solutions of exactly `depth` moves for
+ * the given state, most promising first (same ordered DFS as the search).
+ * Used to try several G1 landing states and keep the best phase-1+phase-2
+ * total — a slightly longer phase 1 often collapses phase 2.
+ */
+export async function collectCube3Phase1Solutions(state, depth, options = {}) {
+    const tables = options.tables ?? await loadCube3Phase1Tables();
+    const jointTables = options.jointTables ?? tables.jointTables;
+    const limit = options.limit ?? 32;
+    const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
+    const context = createPhase1SearchContext(tables, jointTables, depth, deadline);
+    const start = encodeCube3Phase1Coordinates(state);
+    const solutions = [];
+    searchPhase1Collect(start.cornerOrientation, start.edgeOrientation, start.udSlice, -1, -1, depth, [], solutions, limit, context);
+    return { solutions, visitedNodes: context.visitedNodes };
+}
+function createPhase1SearchContext(tables, jointTables, maxDepth, deadline) {
+    const scratchLevels = maxDepth + 1;
+    const scratchSize = scratchLevels * CUBE3_PHASE1_MOVES.length;
+    return {
+        tables,
+        jointTables,
+        maxDepth,
+        deadline,
+        visitedNodes: 0,
+        timedOut: false,
+        scratchMove: new Int32Array(scratchSize),
+        scratchBound: new Int32Array(scratchSize),
+        scratchCo: new Int32Array(scratchSize),
+        scratchEo: new Int32Array(scratchSize),
+        scratchUd: new Int32Array(scratchSize)
+    };
+}
+/**
+ * Fills the scratch slot for `remainingDepth` with the surviving children
+ * in ascending lower-bound order (stable). Returns the child count.
+ */
+function collectPhase1Children(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, context) {
     const moveCount = context.tables.phase1Moves.length;
     const validMoves = PHASE1_VALID_MOVES[previousFace + 1][previousPreviousFace + 1];
     const coTable = context.tables.moveTables.cornerOrientation.values;
@@ -123,9 +176,17 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
     const udTable = context.tables.moveTables.udSlice.values;
     const coeoTable = context.tables.pruningTables.cornerOrientationEdgeOrientation.values;
     const udPruningTable = context.tables.pruningTables.udSlice.values;
+    const jointTables = context.jointTables;
     const coOffset = cornerOrientation * moveCount;
     const eoOffset = edgeOrientation * moveCount;
     const udOffset = udSlice * moveCount;
+    const slot = remainingDepth * moveCount;
+    const scratchMove = context.scratchMove;
+    const scratchBound = context.scratchBound;
+    const scratchCo = context.scratchCo;
+    const scratchEo = context.scratchEo;
+    const scratchUd = context.scratchUd;
+    let childCount = 0;
     for (let i = 0; i < validMoves.length; i += 1) {
         const moveIndex = validMoves[i];
         const nextCornerOrientation = coTable[coOffset + moveIndex];
@@ -138,7 +199,6 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
         if (nextLowerBound > remainingDepth - 1) {
             continue;
         }
-        const jointTables = context.jointTables;
         if (jointTables) {
             const udCoIndex = nextUdSlice * 2187 + nextCornerOrientation;
             const jc = (jointTables.jointUdCo[udCoIndex >> 1] >> ((udCoIndex & 1) << 2)) & 0x0f;
@@ -154,14 +214,72 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
                 continue;
             }
         }
+        scratchMove[slot + childCount] = moveIndex;
+        scratchBound[slot + childCount] = nextLowerBound;
+        scratchCo[slot + childCount] = nextCornerOrientation;
+        scratchEo[slot + childCount] = nextEdgeOrientation;
+        scratchUd[slot + childCount] = nextUdSlice;
+        childCount += 1;
+    }
+    // Stable insertion sort by bound (n <= 18; ties keep reference order).
+    for (let i = 1; i < childCount; i += 1) {
+        const move = scratchMove[slot + i];
+        const bound = scratchBound[slot + i];
+        const co = scratchCo[slot + i];
+        const eo = scratchEo[slot + i];
+        const ud = scratchUd[slot + i];
+        let j = i - 1;
+        while (j >= 0 && scratchBound[slot + j] > bound) {
+            scratchMove[slot + j + 1] = scratchMove[slot + j];
+            scratchBound[slot + j + 1] = scratchBound[slot + j];
+            scratchCo[slot + j + 1] = scratchCo[slot + j];
+            scratchEo[slot + j + 1] = scratchEo[slot + j];
+            scratchUd[slot + j + 1] = scratchUd[slot + j];
+            j -= 1;
+        }
+        scratchMove[slot + j + 1] = move;
+        scratchBound[slot + j + 1] = bound;
+        scratchCo[slot + j + 1] = co;
+        scratchEo[slot + j + 1] = eo;
+        scratchUd[slot + j + 1] = ud;
+    }
+    return childCount;
+}
+/**
+ * Ordered exact-depth DFS that collects solutions instead of stopping at
+ * the first one. Returns true when collection should stop (limit reached
+ * or timed out).
+ */
+function searchPhase1Collect(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, path, solutions, limit, context) {
+    context.visitedNodes += 1;
+    if (context.deadline !== undefined && (context.visitedNodes & 1023) === 0 && performance.now() > context.deadline) {
+        context.timedOut = true;
+        return true;
+    }
+    if (remainingDepth === 0) {
+        if (cornerOrientation === 0 &&
+            edgeOrientation === 0 &&
+            udSlice === context.tables.moveTables.udSlice.solvedCoordinate) {
+            solutions.push([...path]);
+            return solutions.length >= limit;
+        }
+        return false;
+    }
+    const moveCount = context.tables.phase1Moves.length;
+    const childCount = collectPhase1Children(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, context);
+    const slot = remainingDepth * moveCount;
+    const scratchMove = context.scratchMove;
+    const scratchCo = context.scratchCo;
+    const scratchEo = context.scratchEo;
+    const scratchUd = context.scratchUd;
+    for (let i = 0; i < childCount; i += 1) {
+        const moveIndex = scratchMove[slot + i];
         const face = PHASE1_MOVE_FACES[moveIndex];
         path.push(context.tables.phase1Moves[moveIndex]);
-        if (searchPhase1(nextCornerOrientation, nextEdgeOrientation, nextUdSlice, face, previousFace, remainingDepth - 1, path, context)) {
-            return true;
-        }
+        const stop = searchPhase1Collect(scratchCo[slot + i], scratchEo[slot + i], scratchUd[slot + i], face, previousFace, remainingDepth - 1, path, solutions, limit, context);
         path.pop();
-        if (context.timedOut) {
-            return false;
+        if (stop) {
+            return true;
         }
     }
     return false;