@cubingcenter/scrambler 0.1.0

package/dist/puzzles/cube3/solver/generated-assets.d.ts

@@ -0,0 +1,5 @@
+import type { Cube3Phase1Tables, Cube3Phase2Tables, Cube3SolverTables } from "./tables.js";
+export declare function loadGeneratedCube3SolverTables(): Promise<Cube3SolverTables>;
+export declare function loadGeneratedCube3Phase1Tables(): Promise<Cube3Phase1Tables>;
+export declare function loadGeneratedCube3Phase2Tables(): Promise<Cube3Phase2Tables>;
+//# sourceMappingURL=generated-assets.d.ts.map

package/dist/puzzles/cube3/solver/generated-assets.d.ts.map

@@ -0,0 +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,CAiBjF;AAED,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAkBjF"}

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

@@ -0,0 +1,60 @@
+import { getCachedBrowserTables } from "./browser-loader.js";
+let cachedGeneratedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+export async function loadGeneratedCube3SolverTables() {
+    if (isBrowser()) {
+        const browserTables = 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 import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./node-loader.js");
+    return loader.readGeneratedCube3SolverTables();
+}
+export 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
+        }
+    };
+}
+export 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/puzzles/cube3/solver/index.d.ts

@@ -0,0 +1,10 @@
+export { applyCube3Phase2Moves, encodeCube3Phase2Coordinates, isCube3Phase2Solved, solveCube3Phase2, solveCube3State, Cube3Phase2SearchError } from "./phase2.js";
+export { applyCube3Phase1Moves, encodeCube3Phase1Coordinates, isCube3Phase1Solved, solveCube3Phase1, Cube3Phase1SearchError } from "./phase1.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 { 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

@@ -0,0 +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"}

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

@@ -0,0 +1,5 @@
+export { applyCube3Phase2Moves, encodeCube3Phase2Coordinates, isCube3Phase2Solved, solveCube3Phase2, solveCube3State, Cube3Phase2SearchError } from "./phase2.js";
+export { applyCube3Phase1Moves, encodeCube3Phase1Coordinates, isCube3Phase1Solved, solveCube3Phase1, Cube3Phase1SearchError } from "./phase1.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.d.ts

@@ -0,0 +1,3 @@
+import type { Cube3SolverTables } from "./tables.js";
+export declare function readGeneratedCube3SolverTables(): Cube3SolverTables;
+//# sourceMappingURL=node-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/node-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAKV,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAuBrB,wBAAgB,8BAA8B,IAAI,iBAAiB,CAoClE"}

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

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+const GENERATED_DIRECTORY = "puzzles/cube3/solver/generated";
+export 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 = path.join(assetDirectory, "manifest.json");
+    const manifest = JSON.parse(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 = readFileSync(path.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 = readFileSync(path.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 && existsSync(path.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if (existsSync(path.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 = [
+        path.join(cwd, "src", GENERATED_DIRECTORY),
+        path.join(cwd, "dist", GENERATED_DIRECTORY),
+        path.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = createRequire(path.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(path.join(path.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/puzzles/cube3/solver/phase1.d.ts

@@ -0,0 +1,28 @@
+import type { Cube3Move, Cube3State } from "../types.js";
+import type { Cube3Phase1Tables } from "./tables.js";
+export interface Cube3Phase1Coordinates {
+    cornerOrientation: number;
+    edgeOrientation: number;
+    udSlice: number;
+}
+export interface Cube3Phase1Options {
+    maxDepth?: number;
+    timeoutMs?: number;
+    tables?: Cube3Phase1Tables;
+}
+export interface Cube3Phase1Result {
+    moves: Cube3Move[];
+    depth: number;
+    state: Cube3State;
+    coordinates: Cube3Phase1Coordinates;
+    visitedNodes: number;
+}
+export declare class Cube3Phase1SearchError extends Error {
+    readonly visitedNodes: number;
+    constructor(message: string, visitedNodes: number);
+}
+export declare function solveCube3Phase1(state: Cube3State, options?: Cube3Phase1Options): Promise<Cube3Phase1Result>;
+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;
+//# sourceMappingURL=phase1.d.ts.map

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

@@ -0,0 +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,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD,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;CAC5B;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;AA8BD,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAoE5B;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"}

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

@@ -0,0 +1,150 @@
+import { applyCube3Algorithm } from "../moves.js";
+import { encodeCornerOrientation, encodeEdgeOrientation, encodeUdSlice } from "./coordinates.js";
+import { loadCube3Phase1Tables, CUBE3_PHASE1_MOVES } from "./tables.js";
+import { getMoveFaceByIndex, shouldSkipCube3SearchMove } from "./search-utils.js";
+export class Cube3Phase1SearchError extends Error {
+    visitedNodes;
+    constructor(message, visitedNodes) {
+        super(message);
+        this.name = "Cube3Phase1SearchError";
+        this.visitedNodes = visitedNodes;
+    }
+}
+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 < CUBE3_PHASE1_MOVES.length; moveIndex += 1) {
+        const face = getMoveFaceByIndex(moveIndex, CUBE3_PHASE1_MOVES);
+        if (!shouldSkipCube3SearchMove(face, prevFace, prevPrevFace)) {
+            valid.push(moveIndex);
+        }
+    }
+    return valid;
+}));
+export async function solveCube3Phase1(state, options = {}) {
+    const tables = options.tables ?? await 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);
+}
+export function encodeCube3Phase1Coordinates(state) {
+    return {
+        cornerOrientation: encodeCornerOrientation(state),
+        edgeOrientation: encodeEdgeOrientation(state),
+        udSlice: encodeUdSlice(state)
+    };
+}
+export function isCube3Phase1Solved(input, tables) {
+    const coordinates = isCube3StateLike(input)
+        ? encodeCube3Phase1Coordinates(input)
+        : input;
+    return coordinates.cornerOrientation === 0 &&
+        coordinates.edgeOrientation === 0 &&
+        coordinates.udSlice === tables.moveTables.udSlice.solvedCoordinate;
+}
+export function applyCube3Phase1Moves(state, moves) {
+    return applyCube3Algorithm(state, moves);
+}
+const PHASE1_MOVE_FACES = 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;
+}

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

@@ -0,0 +1,44 @@
+import type { Cube3Move, Cube3State } from "../types.js";
+import type { Cube3Phase1Options, Cube3Phase1Result } from "./phase1.js";
+import type { Cube3Phase2Tables } from "./tables.js";
+export interface Cube3Phase2Coordinates {
+    cornerPermutation: number;
+    udEdgePermutation: number;
+    slicePermutation: number;
+}
+export interface Cube3Phase2Options {
+    maxDepth?: number;
+    timeoutMs?: number;
+    tables?: Cube3Phase2Tables;
+    previousFace?: number;
+    previousPreviousFace?: number;
+}
+export interface Cube3Phase2Result {
+    moves: Cube3Move[];
+    depth: number;
+    state: Cube3State;
+    coordinates: Cube3Phase2Coordinates;
+    visitedNodes: number;
+}
+export interface Cube3SolveOptions {
+    phase1?: Cube3Phase1Options;
+    phase2?: Cube3Phase2Options;
+}
+export interface Cube3SolveResult {
+    phase1: Cube3Phase1Result;
+    phase2: Cube3Phase2Result;
+    moves: Cube3Move[];
+    depth: number;
+    state: Cube3State;
+    visitedNodes: number;
+}
+export declare class Cube3Phase2SearchError extends Error {
+    readonly visitedNodes: number;
+    constructor(message: string, visitedNodes: number);
+}
+export declare function solveCube3Phase2(state: Cube3State, options?: Cube3Phase2Options): Promise<Cube3Phase2Result>;
+export declare function solveCube3State(state: Cube3State, options?: Cube3SolveOptions): Promise<Cube3SolveResult>;
+export declare function encodeCube3Phase2Coordinates(state: Cube3State): Cube3Phase2Coordinates;
+export declare function isCube3Phase2Solved(input: Cube3State | Cube3Phase2Coordinates): boolean;
+export declare function applyCube3Phase2Moves(state: Cube3State, moves: readonly Cube3Move[]): Cube3State;
+//# sourceMappingURL=phase2.d.ts.map

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

@@ -0,0 +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;AAcrD,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,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;AA6BD,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CA+E5B;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"}