@cubingcenter/scrambler 0.6.3 → 0.8.0

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

@@ -2,6 +2,7 @@ import { fetchTableBuffer } from "../../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(/\/$/, "");
@@ -20,11 +21,28 @@ export function getCachedBrowserTables() {
 }
 export function clearCachedBrowserTables() {
     browserTables = undefined;
+    browserTablesPromise = undefined;
 }
 export 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 = {
@@ -58,19 +76,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 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),
@@ -90,15 +104,23 @@ async function fetchManifest(baseUrl) {
     return manifest;
 }
 async function fetchMoveTable(baseUrl, entry) {
-    const buffer = await 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 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,
@@ -110,11 +132,15 @@ async function fetchMoveTable(baseUrl, entry) {
     };
 }
 async function fetchPruningTable(baseUrl, entry) {
-    const buffer = await 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 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/puzzles/cube3/solver/generated-assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/generated-assets.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AASrB,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAejF;AAWD,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAkBjF;AAED,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAkBjF"}
+{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/generated-assets.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAgBrB,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAcjF;AAWD,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAkBjF;AAED,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAkBjF"}

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

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

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

@@ -7,7 +7,20 @@ export interface Cube3Phase1Coordinates {
 }
 export interface Cube3Phase1Options {
     maxDepth?: number;
+    /**
+     * Legacy wall-clock deadline (checked every 1024 nodes). The stopping
+     * point — and therefore the result — depends on machine speed and CPU
+     * load. Prefer `maxNodes` when the caller needs a reproducible outcome.
+     */
     timeoutMs?: number;
+    /**
+     * Deterministic work cap: stop after visiting this many nodes (checked on
+     * every node; overshoot ≤ 1). The result then depends only on
+     * (state, tables, budgets) — never on the clock — so the same input
+     * yields the same solution under any CPU load. Composes with `timeoutMs`
+     * when both are set (whichever trips first stops the search).
+     */
+    maxNodes?: number;
     tables?: Cube3Phase1Tables;
     /** Phase-1 joint tables (ud x co / ud x eo), experimental. */
     jointTables?: Cube3JointTables | undefined;
@@ -27,4 +40,28 @@ 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;
+    /**
+     * Deterministic node budget for this enumeration (see
+     * `Cube3Phase1Options.maxNodes`). Preferred over `timeoutMs` when the
+     * collected set must not depend on CPU load.
+     */
+    maxNodes?: 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;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,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;AA4CD,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAwF5B;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;AAyFD,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;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,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,CA2B7D"}

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, options.maxNodes);
     if (await isCube3Phase1Solved(start, tables)) {
         return {
             moves: [],
@@ -77,6 +70,9 @@ export async function solveCube3Phase1(state, options = {}) {
                 visitedNodes: context.visitedNodes
             };
         }
+        if (context.nodesExceeded) {
+            throw new Cube3Phase1SearchError(`3x3 Phase 1 node budget exceeded (${options.maxNodes} nodes).`, context.visitedNodes);
+        }
         if (context.timedOut) {
             throw new Cube3Phase1SearchError(`3x3 Phase 1 search timed out after ${options.timeoutMs}ms.`, context.visitedNodes);
         }
@@ -107,8 +103,17 @@ const PHASE1_MOVE_FACES = CUBE3_PHASE1_MOVES.map((move) => {
 });
 function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, path, context) {
     context.visitedNodes += 1;
-    if (context.deadline !== undefined && (context.visitedNodes & 1023) === 0 && performance.now() > context.deadline) {
+    if (context.nodeCap !== undefined &&
+        context.visitedNodes > context.nodeCap) {
+        context.nodesExceeded = true;
+    }
+    if (!context.nodesExceeded &&
+        context.deadline !== undefined &&
+        (context.visitedNodes & 1023) === 0 &&
+        performance.now() > context.deadline) {
         context.timedOut = true;
+    }
+    if (context.timedOut || context.nodesExceeded) {
         return false;
     }
     if (remainingDepth === 0) {
@@ -116,6 +121,68 @@ 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 || context.nodesExceeded) {
+            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, options.maxNodes);
+    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, nodeCap) {
+    const scratchLevels = maxDepth + 1;
+    const scratchSize = scratchLevels * CUBE3_PHASE1_MOVES.length;
+    return {
+        tables,
+        jointTables,
+        maxDepth,
+        deadline,
+        nodeCap,
+        visitedNodes: 0,
+        timedOut: false,
+        nodesExceeded: 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 +190,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 +213,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 +228,81 @@ 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.nodeCap !== undefined &&
+        context.visitedNodes > context.nodeCap) {
+        context.nodesExceeded = true;
+    }
+    if (!context.nodesExceeded &&
+        context.deadline !== undefined &&
+        (context.visitedNodes & 1023) === 0 &&
+        performance.now() > context.deadline) {
+        context.timedOut = true;
+    }
+    if (context.timedOut || context.nodesExceeded) {
+        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;

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

@@ -9,10 +9,29 @@ export interface Cube3Phase2Coordinates {
 }
 export interface Cube3Phase2Options {
     maxDepth?: number;
+    /**
+     * Legacy wall-clock deadline (checked every 1024 nodes): the stopping
+     * point — and the result — depends on machine speed and CPU load.
+     * Prefer `maxNodes` for reproducible outcomes.
+     */
     timeoutMs?: number;
+    /**
+     * Deterministic work cap: stop after visiting this many nodes (checked
+     * on every node; overshoot ≤ 1). Same input + same cap ⇒ same result
+     * regardless of load/clock. Composes with `timeoutMs` when both are set.
+     */
+    maxNodes?: number;
     tables?: Cube3Phase2Tables;
     /** Combined (cp x uep) pair-distance pruning tables (experimental). */
     pairTables?: Cube3PairTables | undefined;
+    /**
+     * Skip the pair tables entirely (no lazy load). All pair-bound uses are
+     * already guarded, so the search runs without pair pruning. Used by the
+     * 4x4 finish, where pair pruning was measured to change nothing (identical
+     * lengths on a 44-state corpus, zero extra retries) while costing a 54MB
+     * table load.
+     */
+    skipPairTables?: boolean;
     previousFace?: number;
     previousPreviousFace?: number;
 }
@@ -23,9 +42,65 @@ export interface Cube3Phase2Result {
     coordinates: Cube3Phase2Coordinates;
     visitedNodes: number;
 }
+export type Cube3SolveQuality = "fast" | "short" | "best";
 export interface Cube3SolveOptions {
     phase1?: Cube3Phase1Options;
     phase2?: Cube3Phase2Options;
+    targetLength?: number;
+    timeoutMs?: number;
+    /**
+     * Quality tier (defaults to `"short"`):
+     * - `"fast"`: legacy min-P1 + min-P2 (~14 ms, ~23.1 moves, browser tables).
+     * - `"short"`: best of several G1 landings (~36 ms, ~21.9 moves).
+     * - `"best"`: short x 3 orientations (~116 ms, ~20.8 moves, max 22).
+     * Explicit `phase1ExtraDepth` / `phase1SolutionLimit` / `orientations`
+     * always override the tier preset.
+     */
+    quality?: Cube3SolveQuality;
+    /**
+     * Extra phase-1 depths to explore beyond the minimal one, keeping the
+     * best phase-1+phase-2 total. A slightly longer phase 1 often collapses
+     * phase 2, shortening the total (and sometimes the search itself).
+     * Defaults to 0 (legacy min-P1 + min-P2 behavior). The `targetLength`
+     * path always explores up to 4 extra depths.
+     */
+    phase1ExtraDepth?: number;
+    /**
+     * Max phase-1 solutions enumerated per extra depth (most promising
+     * first). Defaults to 32.
+     */
+    phase1SolutionLimit?: number;
+    /**
+     * Per-candidate phase-2 budget (ms) inside the improvement loop.
+     * Defaults to `phase2.timeoutMs` when set, else 25. The initial solve
+     * always uses `phase2.timeoutMs` untouched, so this never starves it.
+     * Legacy wall-clock; superseded by `improvePhase2MaxNodes`.
+     */
+    improvePhase2TimeoutMs?: number;
+    /**
+     * Deterministic node budget for the improvement loop (phase-1 collection
+     * + candidate phase-2 searches), counted as visited search nodes across
+     * the whole loop of ONE solve call. When set, the wall deadline
+     * (`timeoutMs`, default 800 ms) is NOT armed: the returned solution
+     * depends only on (state, tables, budgets) and is reproducible under any
+     * CPU load — this is the mode the 4x4 finish uses.
+     */
+    improveMaxNodes?: number;
+    /**
+     * Deterministic per-candidate phase-2 node cap inside the improvement
+     * loop (counterpart of `improvePhase2TimeoutMs`). Defaults to
+     * `phase2.maxNodes` when set, else the shared `improveMaxNodes`
+     * remainder. Ignored unless `improveMaxNodes` is set.
+     */
+    improvePhase2MaxNodes?: number;
+    /**
+     * Solve rotated copies of the state and keep the shortest solution
+     * (1 = UD only, 3 = UD/x/z triple, up to 24 for the full rotation
+     * group). Each extra orientation buys roughly 0.3-0.5 moves for ~1x
+     * single-solve time. Composes with the other options (each orientation
+     * is solved with the same settings). Defaults to 1.
+     */
+    orientations?: number;
 }
 export interface Cube3SolveResult {
     phase1: Cube3Phase1Result;

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

@@ -1 +1 @@
-{"version":3,"file":"phase2.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/phase2.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAarD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,MAAM,WAAW,sBAAsB;IACrC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,uEAAuE;IACvE,UAAU,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;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,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,MAAM,CAAC,EAAE,kBAAkB,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;IAClB,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;AA8BD,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAuF5B;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CA+B3B;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,UAAU,GAAG,sBAAsB,CAMtF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,sBAAsB,GAAG,OAAO,CAQvF;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,SAAS,SAAS,EAAE,GAC1B,UAAU,CAEZ"}
+{"version":3,"file":"phase2.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/phase2.ts"],"names":[],"mappings":"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"}