@cubingcenter/scrambler 0.1.0

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

@@ -0,0 +1,98 @@
+"use strict";
+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.loadGeneratedCube3SolverTables = loadGeneratedCube3SolverTables;
+exports.loadGeneratedCube3Phase1Tables = loadGeneratedCube3Phase1Tables;
+exports.loadGeneratedCube3Phase2Tables = loadGeneratedCube3Phase2Tables;
+const browser_loader_js_1 = require("./browser-loader.js");
+let cachedGeneratedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+async function loadGeneratedCube3SolverTables() {
+    if (isBrowser()) {
+        const browserTables = (0, browser_loader_js_1.getCachedBrowserTables)();
+        if (browserTables) {
+            return browserTables;
+        }
+        throw new Error("3x3 solver tables are not loaded. " +
+            "In browser environments, call `initializeScrambler(baseUrl)` " +
+            "before generating scrambles.");
+    }
+    cachedGeneratedTables ??= await loadNodeTables();
+    return cachedGeneratedTables;
+}
+async function loadNodeTables() {
+    const loader = await Promise.resolve().then(() => __importStar(require(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./node-loader.js")));
+    return loader.readGeneratedCube3SolverTables();
+}
+async function loadGeneratedCube3Phase1Tables() {
+    const tables = await loadGeneratedCube3SolverTables();
+    return {
+        phase1Moves: tables.phase1Moves,
+        moveTables: {
+            cornerOrientation: tables.moveTables.cornerOrientation,
+            edgeOrientation: tables.moveTables.edgeOrientation,
+            udSlice: tables.moveTables.udSlice
+        },
+        pruningTables: {
+            cornerOrientation: tables.pruningTables.cornerOrientation,
+            edgeOrientation: tables.pruningTables.edgeOrientation,
+            udSlice: tables.pruningTables.udSlice,
+            cornerOrientationEdgeOrientation: tables.pruningTables.cornerOrientationEdgeOrientation
+        }
+    };
+}
+async function loadGeneratedCube3Phase2Tables() {
+    const tables = await loadGeneratedCube3SolverTables();
+    return {
+        phase2Moves: tables.phase2Moves,
+        moveTables: {
+            cornerPermutation: tables.moveTables.cornerPermutation,
+            udEdgePermutation: tables.moveTables.udEdgePermutation,
+            slicePermutation: tables.moveTables.slicePermutation
+        },
+        pruningTables: {
+            cornerPermutation: tables.pruningTables.cornerPermutation,
+            udEdgePermutation: tables.pruningTables.udEdgePermutation,
+            slicePermutation: tables.pruningTables.slicePermutation,
+            cornerPermutationSlicePermutation: tables.pruningTables.cornerPermutationSlicePermutation,
+            udEdgePermutationSlicePermutation: tables.pruningTables.udEdgePermutationSlicePermutation
+        }
+    };
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupCube3MoveTable = exports.loadCube3SolverTables = exports.loadCube3Phase2Tables = exports.loadCube3Phase1Tables = exports.generateCube3SolverTables = exports.generateCube3PruningTable = exports.generateCube3MoveTable = exports.generateCube3Phase2Tables = exports.generateCube3Phase1Tables = exports.checksum = exports.CUBE3_PHASE2_MOVES = exports.CUBE3_PHASE1_MOVES = exports.CUBE3_SOLVER_TABLE_METADATA = exports.moveCoordinate = exports.encodeUdSlice = exports.encodeUdEdgePermutation = exports.encodeSlicePermutation = exports.encodePermutation = exports.encodeEdgeOrientation = exports.encodeCube3Coordinates = exports.encodeCornerOrientation = exports.encodeCube3Coordinate = exports.decodeUdSlice = exports.decodeUdEdgePermutation = exports.decodeSlicePermutation = exports.decodePermutation = exports.decodeEdgeOrientation = exports.decodeCornerOrientation = exports.createRepresentativeStateForCoordinate = exports.CUBE3_COORDINATE_RANGES = exports.Cube3Phase1SearchError = exports.solveCube3Phase1 = exports.isCube3Phase1Solved = exports.encodeCube3Phase1Coordinates = exports.applyCube3Phase1Moves = exports.Cube3Phase2SearchError = exports.solveCube3State = exports.solveCube3Phase2 = exports.isCube3Phase2Solved = exports.encodeCube3Phase2Coordinates = exports.applyCube3Phase2Moves = void 0;
+var phase2_js_1 = require("./phase2.js");
+Object.defineProperty(exports, "applyCube3Phase2Moves", { enumerable: true, get: function () { return phase2_js_1.applyCube3Phase2Moves; } });
+Object.defineProperty(exports, "encodeCube3Phase2Coordinates", { enumerable: true, get: function () { return phase2_js_1.encodeCube3Phase2Coordinates; } });
+Object.defineProperty(exports, "isCube3Phase2Solved", { enumerable: true, get: function () { return phase2_js_1.isCube3Phase2Solved; } });
+Object.defineProperty(exports, "solveCube3Phase2", { enumerable: true, get: function () { return phase2_js_1.solveCube3Phase2; } });
+Object.defineProperty(exports, "solveCube3State", { enumerable: true, get: function () { return phase2_js_1.solveCube3State; } });
+Object.defineProperty(exports, "Cube3Phase2SearchError", { enumerable: true, get: function () { return phase2_js_1.Cube3Phase2SearchError; } });
+var phase1_js_1 = require("./phase1.js");
+Object.defineProperty(exports, "applyCube3Phase1Moves", { enumerable: true, get: function () { return phase1_js_1.applyCube3Phase1Moves; } });
+Object.defineProperty(exports, "encodeCube3Phase1Coordinates", { enumerable: true, get: function () { return phase1_js_1.encodeCube3Phase1Coordinates; } });
+Object.defineProperty(exports, "isCube3Phase1Solved", { enumerable: true, get: function () { return phase1_js_1.isCube3Phase1Solved; } });
+Object.defineProperty(exports, "solveCube3Phase1", { enumerable: true, get: function () { return phase1_js_1.solveCube3Phase1; } });
+Object.defineProperty(exports, "Cube3Phase1SearchError", { enumerable: true, get: function () { return phase1_js_1.Cube3Phase1SearchError; } });
+var coordinates_js_1 = require("./coordinates.js");
+Object.defineProperty(exports, "CUBE3_COORDINATE_RANGES", { enumerable: true, get: function () { return coordinates_js_1.CUBE3_COORDINATE_RANGES; } });
+Object.defineProperty(exports, "createRepresentativeStateForCoordinate", { enumerable: true, get: function () { return coordinates_js_1.createRepresentativeStateForCoordinate; } });
+Object.defineProperty(exports, "decodeCornerOrientation", { enumerable: true, get: function () { return coordinates_js_1.decodeCornerOrientation; } });
+Object.defineProperty(exports, "decodeEdgeOrientation", { enumerable: true, get: function () { return coordinates_js_1.decodeEdgeOrientation; } });
+Object.defineProperty(exports, "decodePermutation", { enumerable: true, get: function () { return coordinates_js_1.decodePermutation; } });
+Object.defineProperty(exports, "decodeSlicePermutation", { enumerable: true, get: function () { return coordinates_js_1.decodeSlicePermutation; } });
+Object.defineProperty(exports, "decodeUdEdgePermutation", { enumerable: true, get: function () { return coordinates_js_1.decodeUdEdgePermutation; } });
+Object.defineProperty(exports, "decodeUdSlice", { enumerable: true, get: function () { return coordinates_js_1.decodeUdSlice; } });
+Object.defineProperty(exports, "encodeCube3Coordinate", { enumerable: true, get: function () { return coordinates_js_1.encodeCube3Coordinate; } });
+Object.defineProperty(exports, "encodeCornerOrientation", { enumerable: true, get: function () { return coordinates_js_1.encodeCornerOrientation; } });
+Object.defineProperty(exports, "encodeCube3Coordinates", { enumerable: true, get: function () { return coordinates_js_1.encodeCube3Coordinates; } });
+Object.defineProperty(exports, "encodeEdgeOrientation", { enumerable: true, get: function () { return coordinates_js_1.encodeEdgeOrientation; } });
+Object.defineProperty(exports, "encodePermutation", { enumerable: true, get: function () { return coordinates_js_1.encodePermutation; } });
+Object.defineProperty(exports, "encodeSlicePermutation", { enumerable: true, get: function () { return coordinates_js_1.encodeSlicePermutation; } });
+Object.defineProperty(exports, "encodeUdEdgePermutation", { enumerable: true, get: function () { return coordinates_js_1.encodeUdEdgePermutation; } });
+Object.defineProperty(exports, "encodeUdSlice", { enumerable: true, get: function () { return coordinates_js_1.encodeUdSlice; } });
+Object.defineProperty(exports, "moveCoordinate", { enumerable: true, get: function () { return coordinates_js_1.moveCoordinate; } });
+var table_metadata_js_1 = require("./table-metadata.js");
+Object.defineProperty(exports, "CUBE3_SOLVER_TABLE_METADATA", { enumerable: true, get: function () { return table_metadata_js_1.CUBE3_SOLVER_TABLE_METADATA; } });
+var tables_js_1 = require("./tables.js");
+Object.defineProperty(exports, "CUBE3_PHASE1_MOVES", { enumerable: true, get: function () { return tables_js_1.CUBE3_PHASE1_MOVES; } });
+Object.defineProperty(exports, "CUBE3_PHASE2_MOVES", { enumerable: true, get: function () { return tables_js_1.CUBE3_PHASE2_MOVES; } });
+Object.defineProperty(exports, "checksum", { enumerable: true, get: function () { return tables_js_1.checksum; } });
+Object.defineProperty(exports, "generateCube3Phase1Tables", { enumerable: true, get: function () { return tables_js_1.generateCube3Phase1Tables; } });
+Object.defineProperty(exports, "generateCube3Phase2Tables", { enumerable: true, get: function () { return tables_js_1.generateCube3Phase2Tables; } });
+Object.defineProperty(exports, "generateCube3MoveTable", { enumerable: true, get: function () { return tables_js_1.generateCube3MoveTable; } });
+Object.defineProperty(exports, "generateCube3PruningTable", { enumerable: true, get: function () { return tables_js_1.generateCube3PruningTable; } });
+Object.defineProperty(exports, "generateCube3SolverTables", { enumerable: true, get: function () { return tables_js_1.generateCube3SolverTables; } });
+Object.defineProperty(exports, "loadCube3Phase1Tables", { enumerable: true, get: function () { return tables_js_1.loadCube3Phase1Tables; } });
+Object.defineProperty(exports, "loadCube3Phase2Tables", { enumerable: true, get: function () { return tables_js_1.loadCube3Phase2Tables; } });
+Object.defineProperty(exports, "loadCube3SolverTables", { enumerable: true, get: function () { return tables_js_1.loadCube3SolverTables; } });
+Object.defineProperty(exports, "lookupCube3MoveTable", { enumerable: true, get: function () { return tables_js_1.lookupCube3MoveTable; } });

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

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGeneratedCube3SolverTables = readGeneratedCube3SolverTables;
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const GENERATED_DIRECTORY = "puzzles/cube3/solver/generated";
+function readGeneratedCube3SolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = readManifest(assetDirectory);
+    return {
+        phase1Moves: manifest.phase1Moves,
+        phase2Moves: manifest.phase2Moves,
+        moveTables: {
+            cornerOrientation: readMoveTable(assetDirectory, manifest.moveTables.cornerOrientation),
+            edgeOrientation: readMoveTable(assetDirectory, manifest.moveTables.edgeOrientation),
+            udSlice: readMoveTable(assetDirectory, manifest.moveTables.udSlice),
+            cornerPermutation: readMoveTable(assetDirectory, manifest.moveTables.cornerPermutation),
+            udEdgePermutation: readMoveTable(assetDirectory, manifest.moveTables.udEdgePermutation),
+            slicePermutation: readMoveTable(assetDirectory, manifest.moveTables.slicePermutation)
+        },
+        pruningTables: {
+            cornerOrientation: readPruningTable(assetDirectory, manifest.pruningTables.cornerOrientation),
+            edgeOrientation: readPruningTable(assetDirectory, manifest.pruningTables.edgeOrientation),
+            udSlice: readPruningTable(assetDirectory, manifest.pruningTables.udSlice),
+            cornerOrientationEdgeOrientation: readPruningTable(assetDirectory, manifest.pruningTables.cornerOrientationEdgeOrientation),
+            cornerPermutation: readPruningTable(assetDirectory, manifest.pruningTables.cornerPermutation),
+            udEdgePermutation: readPruningTable(assetDirectory, manifest.pruningTables.udEdgePermutation),
+            slicePermutation: readPruningTable(assetDirectory, manifest.pruningTables.slicePermutation),
+            cornerPermutationSlicePermutation: readPruningTable(assetDirectory, manifest.pruningTables.cornerPermutationSlicePermutation),
+            udEdgePermutationSlicePermutation: readPruningTable(assetDirectory, manifest.pruningTables.udEdgePermutationSlicePermutation)
+        }
+    };
+}
+function readManifest(assetDirectory) {
+    const manifestPath = node_path_1.default.join(assetDirectory, "manifest.json");
+    const manifest = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, "utf8"));
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported 3x3 solver table manifest version: ${manifest.version}`);
+    }
+    return manifest;
+}
+function readMoveTable(assetDirectory, entry) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    const expectedBytes = entry.range * entry.moves.length * 4;
+    if (buffer.length !== expectedBytes) {
+        throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
+    }
+    const values = new Int32Array(entry.range * entry.moves.length);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = buffer.readInt32LE(index * 4);
+    }
+    const table = {
+        coordinate: entry.coordinate,
+        moves: entry.moves,
+        range: entry.range,
+        solvedCoordinate: entry.solvedCoordinate,
+        values,
+        checksum: checksum(values)
+    };
+    assertChecksum(table.coordinate, table.checksum, entry.checksum);
+    return table;
+}
+function readPruningTable(assetDirectory, entry) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    const expectedBytes = Math.ceil(entry.range / 2);
+    if (buffer.length !== expectedBytes) {
+        throw new Error(`Invalid byte size for ${entry.coordinate} pruning table.`);
+    }
+    const values = new Uint8Array(buffer);
+    const table = {
+        coordinate: entry.coordinate,
+        moves: entry.moves,
+        range: entry.range,
+        values,
+        checksum: checksum(values),
+        maxDepth: entry.maxDepth ?? 0
+    };
+    assertChecksum(table.coordinate, table.checksum, entry.checksum);
+    return table;
+}
+function resolveGeneratedAssetDirectory() {
+    const envDirectory = process.env.CUBINGCENTER_SCRAMBLER_TABLES_DIR;
+    if (envDirectory && (0, node_fs_1.existsSync)(node_path_1.default.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(candidate, "manifest.json"))) {
+            return candidate;
+        }
+    }
+    throw new Error("Unable to find generated 3x3 solver tables. Run pnpm cube3:tables.");
+}
+function getAssetDirectoryCandidates() {
+    const cwd = process.cwd();
+    const candidates = [
+        node_path_1.default.join(cwd, "src", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = (0, node_module_1.createRequire)(node_path_1.default.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(node_path_1.default.join(node_path_1.default.dirname(packageEntry), GENERATED_DIRECTORY));
+    }
+    catch {
+        // Source-tree usage is covered by the cwd candidates.
+    }
+    return candidates;
+}
+function assertChecksum(coordinate, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Checksum mismatch for ${coordinate}: expected ${expected}, received ${actual}.`);
+    }
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < values.length; index += 1) {
+        hash ^= values[index];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

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

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cube3Phase1SearchError = void 0;
+exports.solveCube3Phase1 = solveCube3Phase1;
+exports.encodeCube3Phase1Coordinates = encodeCube3Phase1Coordinates;
+exports.isCube3Phase1Solved = isCube3Phase1Solved;
+exports.applyCube3Phase1Moves = applyCube3Phase1Moves;
+const moves_js_1 = require("../moves.js");
+const coordinates_js_1 = require("./coordinates.js");
+const tables_js_1 = require("./tables.js");
+const search_utils_js_1 = require("./search-utils.js");
+class Cube3Phase1SearchError extends Error {
+    visitedNodes;
+    constructor(message, visitedNodes) {
+        super(message);
+        this.name = "Cube3Phase1SearchError";
+        this.visitedNodes = visitedNodes;
+    }
+}
+exports.Cube3Phase1SearchError = Cube3Phase1SearchError;
+const PHASE1_VALID_MOVES = Array.from({ length: 7 }, (_, prevPlusOne) => Array.from({ length: 7 }, (_, prevPrevPlusOne) => {
+    const valid = [];
+    const prevFace = prevPlusOne - 1;
+    const prevPrevFace = prevPrevPlusOne - 1;
+    for (let moveIndex = 0; moveIndex < tables_js_1.CUBE3_PHASE1_MOVES.length; moveIndex += 1) {
+        const face = (0, search_utils_js_1.getMoveFaceByIndex)(moveIndex, tables_js_1.CUBE3_PHASE1_MOVES);
+        if (!(0, search_utils_js_1.shouldSkipCube3SearchMove)(face, prevFace, prevPrevFace)) {
+            valid.push(moveIndex);
+        }
+    }
+    return valid;
+}));
+async function solveCube3Phase1(state, options = {}) {
+    const tables = options.tables ?? await (0, tables_js_1.loadCube3Phase1Tables)();
+    const maxDepth = options.maxDepth ?? 12;
+    const start = encodeCube3Phase1Coordinates(state);
+    const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
+    const context = {
+        tables,
+        maxDepth,
+        deadline,
+        visitedNodes: 0,
+        timedOut: false
+    };
+    if (await isCube3Phase1Solved(start, tables)) {
+        return {
+            moves: [],
+            depth: 0,
+            state,
+            coordinates: start,
+            visitedNodes: 0
+        };
+    }
+    const coeoTable = tables.pruningTables.cornerOrientationEdgeOrientation.values;
+    const udPruningTable = tables.pruningTables.udSlice.values;
+    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;
+    for (let depth = minDepth; depth <= maxDepth; depth += 1) {
+        const path = [];
+        const solved = searchPhase1(start.cornerOrientation, start.edgeOrientation, start.udSlice, -1, -1, depth, path, context);
+        if (solved) {
+            const nextState = applyCube3Phase1Moves(state, path);
+            const coordinates = encodeCube3Phase1Coordinates(nextState);
+            return {
+                moves: path,
+                depth: path.length,
+                state: nextState,
+                coordinates,
+                visitedNodes: context.visitedNodes
+            };
+        }
+        if (context.timedOut) {
+            throw new Cube3Phase1SearchError(`3x3 Phase 1 search timed out after ${options.timeoutMs}ms.`, context.visitedNodes);
+        }
+    }
+    throw new Cube3Phase1SearchError(`3x3 Phase 1 solution not found within depth ${maxDepth}.`, context.visitedNodes);
+}
+function encodeCube3Phase1Coordinates(state) {
+    return {
+        cornerOrientation: (0, coordinates_js_1.encodeCornerOrientation)(state),
+        edgeOrientation: (0, coordinates_js_1.encodeEdgeOrientation)(state),
+        udSlice: (0, coordinates_js_1.encodeUdSlice)(state)
+    };
+}
+function isCube3Phase1Solved(input, tables) {
+    const coordinates = isCube3StateLike(input)
+        ? encodeCube3Phase1Coordinates(input)
+        : input;
+    return coordinates.cornerOrientation === 0 &&
+        coordinates.edgeOrientation === 0 &&
+        coordinates.udSlice === tables.moveTables.udSlice.solvedCoordinate;
+}
+function applyCube3Phase1Moves(state, moves) {
+    return (0, moves_js_1.applyCube3Algorithm)(state, moves);
+}
+const PHASE1_MOVE_FACES = tables_js_1.CUBE3_PHASE1_MOVES.map((move) => {
+    const char = move[0];
+    return char === "U" ? 0 : char === "D" ? 1 : char === "R" ? 2 : char === "L" ? 3 : char === "F" ? 4 : 5;
+});
+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) {
+        context.timedOut = true;
+        return false;
+    }
+    if (remainingDepth === 0) {
+        return cornerOrientation === 0 &&
+            edgeOrientation === 0 &&
+            udSlice === context.tables.moveTables.udSlice.solvedCoordinate;
+    }
+    const moveCount = context.tables.phase1Moves.length;
+    const validMoves = PHASE1_VALID_MOVES[previousFace + 1][previousPreviousFace + 1];
+    const coTable = context.tables.moveTables.cornerOrientation.values;
+    const eoTable = context.tables.moveTables.edgeOrientation.values;
+    const udTable = context.tables.moveTables.udSlice.values;
+    const coeoTable = context.tables.pruningTables.cornerOrientationEdgeOrientation.values;
+    const udPruningTable = context.tables.pruningTables.udSlice.values;
+    const coOffset = cornerOrientation * moveCount;
+    const eoOffset = edgeOrientation * moveCount;
+    const udOffset = udSlice * moveCount;
+    for (let i = 0; i < validMoves.length; i += 1) {
+        const moveIndex = validMoves[i];
+        const nextCornerOrientation = coTable[coOffset + moveIndex];
+        const nextEdgeOrientation = eoTable[eoOffset + moveIndex];
+        const nextUdSlice = udTable[udOffset + moveIndex];
+        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;
+        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)) {
+            return true;
+        }
+        path.pop();
+        if (context.timedOut) {
+            return false;
+        }
+    }
+    return false;
+}
+function phase1LowerBound(coordinates, tables) {
+    const combinedIndex = coordinates.cornerOrientation * tables.moveTables.edgeOrientation.range +
+        coordinates.edgeOrientation;
+    const coeoTable = tables.pruningTables.cornerOrientationEdgeOrientation.values;
+    const udPruningTable = tables.pruningTables.udSlice.values;
+    const coeo = (coeoTable[combinedIndex >> 1] >> ((combinedIndex & 1) << 2)) & 0x0f;
+    const udSlice = (udPruningTable[coordinates.udSlice >> 1] >> ((coordinates.udSlice & 1) << 2)) & 0x0f;
+    return coeo > udSlice ? coeo : udSlice;
+}
+function isCube3StateLike(input) {
+    return "corners" in input && "edges" in input;
+}