@cubingcenter/scrambler 0.6.0 → 0.6.2

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

@@ -75,7 +75,8 @@ async function loadGeneratedCube3Phase1Tables() {
             edgeOrientation: tables.pruningTables.edgeOrientation,
             udSlice: tables.pruningTables.udSlice,
             cornerOrientationEdgeOrientation: tables.pruningTables.cornerOrientationEdgeOrientation
-        }
+        },
+        jointTables: tables.jointTables
     };
 }
 async function loadGeneratedCube3Phase2Tables() {

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

@@ -32,7 +32,29 @@ function readGeneratedCube3SolverTables() {
             slicePermutation: readPruningTable(assetDirectory, manifest.pruningTables.slicePermutation),
             cornerPermutationSlicePermutation: readPruningTable(assetDirectory, manifest.pruningTables.cornerPermutationSlicePermutation),
             udEdgePermutationSlicePermutation: readPruningTable(assetDirectory, manifest.pruningTables.udEdgePermutationSlicePermutation)
+        },
+        jointTables: readJointTables(assetDirectory, manifest.jointTables)
+    };
+}
+function readJointTables(assetDirectory, entries) {
+    if (!entries?.udCo || !entries.udEo) {
+        return undefined;
+    }
+    const readJoint = (entry) => {
+        const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+        const expectedBytes = Math.ceil((entry.rangeA * entry.rangeB) / 2);
+        if (buffer.length !== 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 {
+        jointUdCo: readJoint(entries.udCo),
+        jointUdEo: readJoint(entries.udEo)
     };
 }
 function readManifest(assetDirectory) {

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

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Browser loader for the combined (cp x uep) pair pruning tables.
+ *
+ * Fetches the plain .bin files from the web assets base URL (the web sync
+ * script copies `generated/pair/` wholesale; compression variants are not
+ * used for the pair tables yet — the 55 MB dist table is the dominant
+ * download either way).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBrowserPairTables = loadBrowserPairTables;
+const pair_tables_types_js_1 = require("./pair-tables-types.js");
+const PAIR_DIR = "puzzles/cube3/solver/generated/pair";
+function resolveBaseUrl(provided) {
+    if (provided) {
+        return provided.replace(/\/$/, "");
+    }
+    if (typeof document !== "undefined") {
+        const script = document.currentScript;
+        if (script?.src) {
+            const base = new URL(".", script.src).href;
+            return base.replace(/\/$/, "");
+        }
+    }
+    return ".";
+}
+async function loadBrowserPairTables(baseUrl) {
+    const resolvedBase = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolvedBase);
+    if (manifest === undefined) {
+        return undefined;
+    }
+    const fetchBin = async (file, expectedBytes, expectedChecksum) => {
+        const url = `${resolvedBase}/${PAIR_DIR}/${file}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to load pair table ${url}: ${response.status} ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        if (buffer.byteLength !== expectedBytes) {
+            throw new Error(`Invalid byte size for ${file}.`);
+        }
+        const values = new Uint8Array(buffer);
+        const actual = (0, pair_tables_types_js_1.checksumBytes)(values);
+        if (actual !== expectedChecksum) {
+            throw new Error(`Checksum mismatch for ${file}: expected ${expectedChecksum}, received ${actual}.`);
+        }
+        return values;
+    };
+    const fetchU16 = async (file, count, expectedChecksum) => {
+        const values = new Uint16Array(count);
+        const buffer = await fetchBin(file, count * 2, expectedChecksum);
+        for (let index = 0; index < count; index += 1) {
+            values[index] = buffer[index * 2] | (buffer[index * 2 + 1] << 8);
+        }
+        return values;
+    };
+    const fetchU32 = async (file, count, expectedChecksum) => {
+        const values = new Uint32Array(count);
+        const buffer = await fetchBin(file, count * 4, expectedChecksum);
+        for (let index = 0; index < count; index += 1) {
+            values[index] =
+                buffer[index * 4] |
+                    (buffer[index * 4 + 1] << 8) |
+                    (buffer[index * 4 + 2] << 16) |
+                    (buffer[index * 4 + 3] << 24);
+        }
+        return values;
+    };
+    const canonCpMin = await fetchU16("phase2-pair-canoncpmin.bin", 40320, manifest.checksums.canonCpMin);
+    const canonTauStart = await fetchU32("phase2-pair-canonctaustart.bin", 40321, manifest.checksums.canonTauStart);
+    const canonTaus = await fetchBin("phase2-pair-canonctaus.bin", canonTauStart[40320], manifest.checksums.canonTaus);
+    const conjEp = await fetchU16("phase2-pair-conjep.bin", 16 * 40320, manifest.checksums.conjEp);
+    const dist = await fetchBin("phase2-pair-dist.bin", manifest.tableBytes, manifest.checksums.dist);
+    return {
+        denseMin: (0, pair_tables_types_js_1.buildDenseMin)(canonCpMin, manifest.nMinima),
+        canonCpMin,
+        canonTauStart,
+        canonTaus,
+        conjEp,
+        dist,
+        nMinima: manifest.nMinima,
+        maxDepth: manifest.maxDepth
+    };
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/${PAIR_DIR}/phase2-pair-manifest.json`;
+    const response = await fetch(url);
+    if (response.status === 404) {
+        return undefined;
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to load pair table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Node loader for the combined (cp x uep) pair pruning tables.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNodePairTables = loadNodePairTables;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const pair_tables_types_js_1 = require("./pair-tables-types.js");
+const PAIR_DIR = "puzzles/cube3/solver/generated/pair";
+function loadNodePairTables() {
+    const dir = resolvePairDirectory();
+    if (dir === undefined) {
+        return undefined;
+    }
+    const manifest = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(dir, "phase2-pair-manifest.json"), "utf8"));
+    const readBin = (file, expectedBytes, expectedChecksum) => {
+        const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(dir, file));
+        if (buffer.length !== expectedBytes) {
+            throw new Error(`Invalid byte size for ${file}.`);
+        }
+        const values = new Uint8Array(buffer);
+        const actual = (0, pair_tables_types_js_1.checksumBytes)(values);
+        if (actual !== expectedChecksum) {
+            throw new Error(`Checksum mismatch for ${file}: expected ${expectedChecksum}, received ${actual}.`);
+        }
+        return values;
+    };
+    const readU16 = (file, count, expectedChecksum) => {
+        const values = new Uint16Array(count);
+        const buffer = readBin(file, count * 2, expectedChecksum);
+        for (let index = 0; index < count; index += 1) {
+            values[index] = buffer[index * 2] | (buffer[index * 2 + 1] << 8);
+        }
+        return values;
+    };
+    const readU32 = (file, count, expectedChecksum) => {
+        const values = new Uint32Array(count);
+        const buffer = readBin(file, count * 4, expectedChecksum);
+        for (let index = 0; index < count; index += 1) {
+            values[index] =
+                buffer[index * 4] |
+                    (buffer[index * 4 + 1] << 8) |
+                    (buffer[index * 4 + 2] << 16) |
+                    (buffer[index * 4 + 3] << 24);
+        }
+        return values;
+    };
+    const canonCpMin = readU16("phase2-pair-canoncpmin.bin", 40320, manifest.checksums.canonCpMin);
+    const canonTauStart = readU32("phase2-pair-canonctaustart.bin", 40321, manifest.checksums.canonTauStart);
+    const canonTaus = readBin("phase2-pair-canonctaus.bin", canonTauStart[40320], manifest.checksums.canonTaus);
+    const conjEp = readU16("phase2-pair-conjep.bin", 16 * 40320, manifest.checksums.conjEp);
+    const dist = readBin("phase2-pair-dist.bin", manifest.tableBytes, manifest.checksums.dist);
+    return {
+        denseMin: (0, pair_tables_types_js_1.buildDenseMin)(canonCpMin, manifest.nMinima),
+        canonCpMin,
+        canonTauStart,
+        canonTaus,
+        conjEp,
+        dist,
+        nMinima: manifest.nMinima,
+        maxDepth: manifest.maxDepth
+    };
+}
+function resolvePairDirectory() {
+    const envDirectory = process.env.CUBINGCENTER_SCRAMBLER_TABLES_DIR;
+    if (envDirectory && (0, node_fs_1.existsSync)(node_path_1.default.join(envDirectory, "pair", "phase2-pair-manifest.json"))) {
+        return node_path_1.default.join(envDirectory, "pair");
+    }
+    const cwd = process.cwd();
+    const candidates = [
+        node_path_1.default.join(cwd, "src", PAIR_DIR),
+        node_path_1.default.join(cwd, "dist", PAIR_DIR),
+        node_path_1.default.join(cwd, "dist-cjs", PAIR_DIR)
+    ];
+    for (const candidate of candidates) {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(candidate, "phase2-pair-manifest.json"))) {
+            return candidate;
+        }
+    }
+    return undefined;
+}

package/dist-cjs/puzzles/cube3/solver/pair-tables-types.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Pair-table types shared by the node and browser loaders.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checksumBytes = checksumBytes;
+exports.buildDenseMin = buildDenseMin;
+function checksumBytes(values) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < values.length; index += 1) {
+        hash ^= values[index];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+/**
+ * Builds the dense class map (first-appearance order, matching exp3-gen).
+ */
+function buildDenseMin(canonCpMin, expectedCount) {
+    const denseMin = new Uint16Array(40320).fill(0xffff);
+    let next = 0;
+    for (let cp = 0; cp < 40320; cp += 1) {
+        const minCp = canonCpMin[cp];
+        if (denseMin[minCp] === 0xffff) {
+            denseMin[minCp] = next;
+            next += 1;
+        }
+    }
+    if (next !== expectedCount) {
+        throw new Error(`Dense class count mismatch: ${next} != ${expectedCount}.`);
+    }
+    return denseMin;
+}

package/dist-cjs/puzzles/cube3/solver/pair-tables.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Combined (cp x uep) phase-2 pruning table (experiment:
+ * experiment/cube3-pair-pruning). The exact distance to (cp==0 && uep==0)
+ * with the slice permutation free, canonicalized under the slice-16
+ * conjugation group:
+ *
+ *   index = denseMin[canonCpMin[cp]] * 40320 + uep*
+ *   uep*  = min over the cp-minimizer set (canonTaus) of conjEp[g][uep]
+ *
+ * The distance is ~3.5-4 moves tighter than max(cpsp, uepsp) (the plain
+ * phase-2 bound) and admissible for the joint phase-2 problem
+ * (d_pair <= d_joint), so it prunes the deep phase-2 searches
+ * exponentially. Measured in the native C++ repo (exp3): phase-2 drops
+ * from ~34k nodes to ~37 (990x) and the full scramble from ~5.7 ms to
+ * ~1.2 ms. Generated by the C++ tool `tools/exp3-gen`, ~1 min,
+ * deterministic, FNV-1a checksummed.
+ *
+ * The tables live in `puzzles/cube3/solver/generated/pair/` next to the
+ * standard solver tables.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedPairTables = getCachedPairTables;
+exports.loadCube3PairTables = loadCube3PairTables;
+exports.pairBound = pairBound;
+let cached;
+function getCachedPairTables() {
+    return cached;
+}
+async function loadCube3PairTables() {
+    if (cached === undefined) {
+        cached = await loadPairTables();
+    }
+    return cached;
+}
+async function loadPairTables() {
+    try {
+        if (typeof self !== "undefined") {
+            const loader = await Promise.resolve().then(() => __importStar(require(
+            /* webpackIgnore: true */
+            /* @vite-ignore */
+            "./pair-browser-loader.js")));
+            return await loader.loadBrowserPairTables();
+        }
+        const loader = await Promise.resolve().then(() => __importStar(require(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        "./pair-node-loader.js")));
+        return loader.loadNodePairTables();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The pair distance of (cp, uep) — the exact distance to (cp==0 && uep==0)
+ * with the slice free. Admissible as a phase-2 lower bound.
+ */
+function pairBound(tables, cp, uep) {
+    const minCp = tables.canonCpMin[cp];
+    const start = tables.canonTauStart[cp];
+    const end = tables.canonTauStart[cp + 1];
+    let bestUep = 0x7fffffff;
+    for (let index = start; index < end; index += 1) {
+        const g = tables.canonTaus[index];
+        const e = tables.conjEp[g * 40320 + uep];
+        if (e < bestUep) {
+            bestUep = e;
+        }
+    }
+    const pairIndex = tables.denseMin[minCp] * 40320 + bestUep;
+    const nibble = tables.dist[pairIndex >> 1];
+    return (nibble >> ((pairIndex & 1) << 2)) & 0x0f;
+}

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

@@ -32,11 +32,13 @@ const PHASE1_VALID_MOVES = Array.from({ length: 7 }, (_, prevPlusOne) => Array.f
 }));
 async function solveCube3Phase1(state, options = {}) {
     const tables = options.tables ?? await (0, tables_js_1.loadCube3Phase1Tables)();
+    const jointTables = options.jointTables ?? tables.jointTables;
     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,
@@ -56,7 +58,19 @@ async function solveCube3Phase1(state, options = {}) {
     const combinedIndex = (start.cornerOrientation << 11) + start.edgeOrientation;
     const coeo = (coeoTable[combinedIndex >> 1] >> ((combinedIndex & 1) << 2)) & 0x0f;
     const udSliceDist = (udPruningTable[start.udSlice >> 1] >> ((start.udSlice & 1) << 2)) & 0x0f;
-    const minDepth = coeo > udSliceDist ? coeo : udSliceDist;
+    let minDepth = coeo > udSliceDist ? coeo : udSliceDist;
+    if (jointTables) {
+        const jc = (jointTables.jointUdCo[(start.udSlice * 2187 + start.cornerOrientation) >> 1] >>
+            (((start.udSlice * 2187 + start.cornerOrientation) & 1) << 2)) & 0x0f;
+        if (jc > minDepth) {
+            minDepth = jc;
+        }
+        const je = (jointTables.jointUdEo[(start.udSlice * 2048 + start.edgeOrientation) >> 1] >>
+            (((start.udSlice * 2048 + start.edgeOrientation) & 1) << 2)) & 0x0f;
+        if (je > minDepth) {
+            minDepth = je;
+        }
+    }
     for (let depth = minDepth; depth <= maxDepth; depth += 1) {
         const path = [];
         const solved = searchPhase1(start.cornerOrientation, start.edgeOrientation, start.udSlice, -1, -1, depth, path, context);
@@ -128,10 +142,26 @@ function searchPhase1(cornerOrientation, edgeOrientation, udSlice, previousFace,
         const combinedIndex = (nextCornerOrientation << 11) + nextEdgeOrientation;
         const coeo = (coeoTable[combinedIndex >> 1] >> ((combinedIndex & 1) << 2)) & 0x0f;
         const udSliceDist = (udPruningTable[nextUdSlice >> 1] >> ((nextUdSlice & 1) << 2)) & 0x0f;
-        const nextLowerBound = coeo > udSliceDist ? coeo : udSliceDist;
+        let nextLowerBound = coeo > udSliceDist ? coeo : udSliceDist;
         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;
+            if (jc > nextLowerBound) {
+                nextLowerBound = jc;
+            }
+            const udEoIndex = nextUdSlice * 2048 + nextEdgeOrientation;
+            const je = (jointTables.jointUdEo[udEoIndex >> 1] >> ((udEoIndex & 1) << 2)) & 0x0f;
+            if (je > nextLowerBound) {
+                nextLowerBound = je;
+            }
+            if (nextLowerBound > remainingDepth - 1) {
+                continue;
+            }
+        }
         const face = PHASE1_MOVE_FACES[moveIndex];
         path.push(context.tables.phase1Moves[moveIndex]);
         if (searchPhase1(nextCornerOrientation, nextEdgeOrientation, nextUdSlice, face, previousFace, remainingDepth - 1, path, context)) {

package/dist-cjs/puzzles/cube3/solver/phase2.js

@@ -12,6 +12,7 @@ const coordinates_js_1 = require("./coordinates.js");
 const phase1_js_1 = require("./phase1.js");
 const tables_js_1 = require("./tables.js");
 const search_utils_js_1 = require("./search-utils.js");
+const pair_tables_js_1 = require("./pair-tables.js");
 class Cube3Phase2SearchError extends Error {
     visitedNodes;
     constructor(message, visitedNodes) {
@@ -49,11 +50,13 @@ async function solveCube3Phase2(state, options = {}) {
         throw new Cube3Phase2SearchError("3x3 Phase 2 requires a state already in G1.", 0);
     }
     const tables = options.tables ?? await (0, tables_js_1.loadCube3Phase2Tables)();
+    const pairTables = options.pairTables ?? await (0, pair_tables_js_1.loadCube3PairTables)();
     const maxDepth = options.maxDepth ?? 18;
     const start = encodeCube3Phase2Coordinates(state);
     const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
     const context = {
         tables,
+        pairTables,
         deadline,
         visitedNodes: 0,
         timedOut: false
@@ -65,7 +68,13 @@ async function solveCube3Phase2(state, options = {}) {
     const combinedEPIndex = start.udEdgePermutation * spRange + start.slicePermutation;
     const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
     const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
-    const minDepth = cpDist > epDist ? cpDist : epDist;
+    let minDepth = cpDist > epDist ? cpDist : epDist;
+    if (pairTables) {
+        const pair = (0, pair_tables_js_1.pairBound)(pairTables, start.cornerPermutation, start.udEdgePermutation);
+        if (pair > minDepth) {
+            minDepth = pair;
+        }
+    }
     const initialPreviousFace = options.previousFace ?? -1;
     const initialPreviousPreviousFace = options.previousPreviousFace ?? -1;
     for (let depth = minDepth; depth <= maxDepth; depth += 1) {
@@ -160,6 +169,38 @@ function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, pr
     const cpOffset = cornerPermutation * moveCount;
     const epOffset = udEdgePermutation * moveCount;
     const spOffset = slicePermutation * moveCount;
+    // Without the pair tables (the default npm package), keep the exact
+    // reference traversal — zero overhead. With them (turbo tier), collect the
+    // children with the pair-distance bound and explore in ascending bound
+    // order (stable: ties keep the reference move order): same depth-minimal
+    // solutions, far fewer nodes.
+    if (context.pairTables === undefined) {
+        for (let i = 0; i < validMoves.length; i += 1) {
+            const moveIndex = validMoves[i];
+            const nextCornerPermutation = cpTable[cpOffset + moveIndex];
+            const nextUdEdgePermutation = epTable[epOffset + moveIndex];
+            const nextSlicePermutation = spTable[spOffset + moveIndex];
+            const combinedCPIndex = nextCornerPermutation * spRange + nextSlicePermutation;
+            const combinedEPIndex = nextUdEdgePermutation * spRange + nextSlicePermutation;
+            const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
+            const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
+            const nextLowerBound = cpDist > epDist ? cpDist : epDist;
+            if (nextLowerBound > remainingDepth - 1) {
+                continue;
+            }
+            path.push(context.tables.phase2Moves[moveIndex]);
+            if (searchPhase2(nextCornerPermutation, nextUdEdgePermutation, nextSlicePermutation, PHASE2_MOVE_FACES[moveIndex], previousFace, remainingDepth - 1, path, context)) {
+                return true;
+            }
+            path.pop();
+            if (context.timedOut) {
+                return false;
+            }
+        }
+        return false;
+    }
+    const pairTables = context.pairTables;
+    const children = [];
     for (let i = 0; i < validMoves.length; i += 1) {
         const moveIndex = validMoves[i];
         const nextCornerPermutation = cpTable[cpOffset + moveIndex];
@@ -169,13 +210,29 @@ function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, pr
         const combinedEPIndex = nextUdEdgePermutation * spRange + nextSlicePermutation;
         const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
         const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
-        const nextLowerBound = cpDist > epDist ? cpDist : epDist;
+        let nextLowerBound = cpDist > epDist ? cpDist : epDist;
         if (nextLowerBound > remainingDepth - 1) {
             continue;
         }
-        const face = PHASE2_MOVE_FACES[moveIndex];
-        path.push(context.tables.phase2Moves[moveIndex]);
-        if (searchPhase2(nextCornerPermutation, nextUdEdgePermutation, nextSlicePermutation, face, previousFace, remainingDepth - 1, path, context)) {
+        const pair = (0, pair_tables_js_1.pairBound)(pairTables, nextCornerPermutation, nextUdEdgePermutation);
+        if (pair > nextLowerBound) {
+            nextLowerBound = pair;
+        }
+        if (nextLowerBound > remainingDepth - 1) {
+            continue;
+        }
+        children.push({
+            moveIndex,
+            lowerBound: nextLowerBound,
+            cornerPermutation: nextCornerPermutation,
+            udEdgePermutation: nextUdEdgePermutation,
+            slicePermutation: nextSlicePermutation
+        });
+    }
+    children.sort((left, right) => left.lowerBound - right.lowerBound);
+    for (const child of children) {
+        path.push(context.tables.phase2Moves[child.moveIndex]);
+        if (searchPhase2(child.cornerPermutation, child.udEdgePermutation, child.slicePermutation, PHASE2_MOVE_FACES[child.moveIndex], previousFace, remainingDepth - 1, path, context)) {
             return true;
         }
         path.pop();
@@ -226,6 +283,7 @@ function searchPhase1Interleaved(cornerOrientation, edgeOrientation, udSlice, pr
         const maxPhase2Depth = 6;
         const phase2Context = {
             tables: context.phase2Tables,
+            pairTables: undefined,
             deadline: context.deadline,
             visitedNodes: 0,
             timedOut: false

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

@@ -60,7 +60,8 @@ function generateCube3Phase1Tables() {
             edgeOrientation: generateCube3PruningTable(edgeOrientation),
             udSlice: generateCube3PruningTable(udSlice),
             cornerOrientationEdgeOrientation: generateCube3CombinedPruningTable(cornerOrientation, edgeOrientation)
-        }
+        },
+        jointTables: undefined
     };
 }
 function generateCube3SolverTables() {
@@ -87,7 +88,8 @@ function generateCube3SolverTables() {
             slicePermutation: phase2Tables.pruningTables.slicePermutation,
             cornerPermutationSlicePermutation: phase2Tables.pruningTables.cornerPermutationSlicePermutation,
             udEdgePermutationSlicePermutation: phase2Tables.pruningTables.udEdgePermutationSlicePermutation
-        }
+        },
+        jointTables: undefined
     };
 }
 function generateCube3Phase2Tables() {