@cubingcenter/scrambler 0.1.0

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

@@ -0,0 +1,270 @@
+import { applyCube3Algorithm } from "../moves.js";
+import { isSolvedCube3State } from "../state.js";
+import { encodePermutation, encodeSlicePermutation, encodeUdEdgePermutation } from "./coordinates.js";
+import { isCube3Phase1Solved, solveCube3Phase1 } from "./phase1.js";
+import { loadCube3Phase1Tables, loadCube3Phase2Tables, CUBE3_PHASE1_MOVES, CUBE3_PHASE2_MOVES } from "./tables.js";
+import { getMoveFace, getMoveFaceByIndex, shouldSkipCube3SearchMove } from "./search-utils.js";
+export class Cube3Phase2SearchError extends Error {
+    visitedNodes;
+    constructor(message, visitedNodes) {
+        super(message);
+        this.name = "Cube3Phase2SearchError";
+        this.visitedNodes = visitedNodes;
+    }
+}
+const PHASE2_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_PHASE2_MOVES.length; moveIndex += 1) {
+        const face = getMoveFaceByIndex(moveIndex, CUBE3_PHASE2_MOVES);
+        if (!shouldSkipCube3SearchMove(face, prevFace, prevPrevFace)) {
+            valid.push(moveIndex);
+        }
+    }
+    return valid;
+}));
+export async function solveCube3Phase2(state, options = {}) {
+    if (isSolvedCube3State(state)) {
+        const coordinates = encodeCube3Phase2Coordinates(state);
+        return {
+            moves: [],
+            depth: 0,
+            state,
+            coordinates,
+            visitedNodes: 0
+        };
+    }
+    const phase1Tables = await loadCube3Phase1Tables();
+    if (!isCube3Phase1Solved(state, phase1Tables)) {
+        throw new Cube3Phase2SearchError("3x3 Phase 2 requires a state already in G1.", 0);
+    }
+    const tables = options.tables ?? await loadCube3Phase2Tables();
+    const maxDepth = options.maxDepth ?? 18;
+    const start = encodeCube3Phase2Coordinates(state);
+    const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
+    const context = {
+        tables,
+        deadline,
+        visitedNodes: 0,
+        timedOut: false
+    };
+    const spRange = tables.moveTables.slicePermutation.range;
+    const cpspTable = tables.pruningTables.cornerPermutationSlicePermutation.values;
+    const epspTable = tables.pruningTables.udEdgePermutationSlicePermutation.values;
+    const combinedCPIndex = start.cornerPermutation * spRange + start.slicePermutation;
+    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;
+    const initialPreviousFace = options.previousFace ?? -1;
+    const initialPreviousPreviousFace = options.previousPreviousFace ?? -1;
+    for (let depth = minDepth; depth <= maxDepth; depth += 1) {
+        const path = [];
+        const solved = searchPhase2(start.cornerPermutation, start.udEdgePermutation, start.slicePermutation, initialPreviousFace, initialPreviousPreviousFace, depth, path, context);
+        if (solved) {
+            const nextState = applyCube3Phase2Moves(state, path);
+            const coordinates = encodeCube3Phase2Coordinates(nextState);
+            return {
+                moves: path,
+                depth: path.length,
+                state: nextState,
+                coordinates,
+                visitedNodes: context.visitedNodes
+            };
+        }
+        if (context.timedOut) {
+            throw new Cube3Phase2SearchError(`3x3 Phase 2 search timed out after ${options.timeoutMs}ms.`, context.visitedNodes);
+        }
+    }
+    throw new Cube3Phase2SearchError(`3x3 Phase 2 solution not found within depth ${maxDepth}.`, context.visitedNodes);
+}
+export async function solveCube3State(state, options = {}) {
+    const phase1 = await solveCube3Phase1(state, options.phase1);
+    let previousFace = -1;
+    let previousPreviousFace = -1;
+    if (phase1.moves.length > 0) {
+        const lastMove = phase1.moves[phase1.moves.length - 1];
+        previousFace = getMoveFace(lastMove);
+        if (phase1.moves.length > 1) {
+            const prevMove = phase1.moves[phase1.moves.length - 2];
+            previousPreviousFace = getMoveFace(prevMove);
+        }
+    }
+    const phase2Options = {
+        ...options.phase2,
+        previousFace,
+        previousPreviousFace
+    };
+    const phase2 = await solveCube3Phase2(phase1.state, phase2Options);
+    const moves = [...phase1.moves, ...phase2.moves];
+    return {
+        phase1,
+        phase2,
+        moves,
+        depth: moves.length,
+        state: phase2.state,
+        visitedNodes: phase1.visitedNodes + phase2.visitedNodes
+    };
+}
+export function encodeCube3Phase2Coordinates(state) {
+    return {
+        cornerPermutation: encodeCornerPermutationForPhase2(state),
+        udEdgePermutation: encodeUdEdgePermutation(state),
+        slicePermutation: encodeSlicePermutation(state)
+    };
+}
+export function isCube3Phase2Solved(input) {
+    const coordinates = isCube3StateLike(input)
+        ? encodeCube3Phase2Coordinates(input)
+        : input;
+    return coordinates.cornerPermutation === 0 &&
+        coordinates.udEdgePermutation === 0 &&
+        coordinates.slicePermutation === 0;
+}
+export function applyCube3Phase2Moves(state, moves) {
+    return applyCube3Algorithm(state, moves);
+}
+const PHASE2_MOVE_FACES = CUBE3_PHASE2_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 searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, 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 cornerPermutation === 0 &&
+            udEdgePermutation === 0 &&
+            slicePermutation === 0;
+    }
+    const moveCount = context.tables.phase2Moves.length;
+    const validMoves = PHASE2_VALID_MOVES[previousFace + 1][previousPreviousFace + 1];
+    const cpTable = context.tables.moveTables.cornerPermutation.values;
+    const epTable = context.tables.moveTables.udEdgePermutation.values;
+    const spTable = context.tables.moveTables.slicePermutation.values;
+    const spRange = context.tables.moveTables.slicePermutation.range;
+    const cpspTable = context.tables.pruningTables.cornerPermutationSlicePermutation.values;
+    const epspTable = context.tables.pruningTables.udEdgePermutationSlicePermutation.values;
+    const cpOffset = cornerPermutation * moveCount;
+    const epOffset = udEdgePermutation * moveCount;
+    const spOffset = slicePermutation * moveCount;
+    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;
+        }
+        const face = PHASE2_MOVE_FACES[moveIndex];
+        path.push(context.tables.phase2Moves[moveIndex]);
+        if (searchPhase2(nextCornerPermutation, nextUdEdgePermutation, nextSlicePermutation, face, previousFace, remainingDepth - 1, path, context)) {
+            return true;
+        }
+        path.pop();
+        if (context.timedOut) {
+            return false;
+        }
+    }
+    return false;
+}
+function phase2LowerBound(coordinates, tables) {
+    const combinedCPIndex = coordinates.cornerPermutation * tables.moveTables.slicePermutation.range +
+        coordinates.slicePermutation;
+    const combinedEPIndex = coordinates.udEdgePermutation * tables.moveTables.slicePermutation.range +
+        coordinates.slicePermutation;
+    const cpspTable = tables.pruningTables.cornerPermutationSlicePermutation.values;
+    const epspTable = tables.pruningTables.udEdgePermutationSlicePermutation.values;
+    const cp = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
+    const ep = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
+    return cp > ep ? cp : ep;
+}
+function encodeCornerPermutationForPhase2(state) {
+    return encodePermutation(state.corners.permutation);
+}
+function isCube3StateLike(input) {
+    return "corners" in input && "edges" in input;
+}
+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;
+}));
+function searchPhase1Interleaved(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) {
+        const g1State = applyCube3Phase2Moves(context.originalState, path);
+        const start2 = encodeCube3Phase2Coordinates(g1State);
+        const maxPhase2Depth = 6;
+        const phase2Context = {
+            tables: context.phase2Tables,
+            deadline: context.deadline,
+            visitedNodes: 0,
+            timedOut: false
+        };
+        for (let d2 = 0; d2 <= maxPhase2Depth; d2 += 1) {
+            const path2 = [];
+            const solved2 = searchPhase2(start2.cornerPermutation, start2.udEdgePermutation, start2.slicePermutation, -1, -1, d2, path2, phase2Context);
+            if (solved2) {
+                context.finalPhase1Moves = [...path];
+                context.finalPhase2Moves = path2;
+                context.visitedNodes += phase2Context.visitedNodes;
+                return true;
+            }
+        }
+        context.visitedNodes += phase2Context.visitedNodes;
+        return false;
+    }
+    const moveCount = context.phase1Tables.phase1Moves.length;
+    const validMoves = PHASE1_VALID_MOVES[previousFace + 1][previousPreviousFace + 1];
+    const coTable = context.phase1Tables.moveTables.cornerOrientation.values;
+    const eoTable = context.phase1Tables.moveTables.edgeOrientation.values;
+    const udTable = context.phase1Tables.moveTables.udSlice.values;
+    const coeoTable = context.phase1Tables.pruningTables.cornerOrientationEdgeOrientation.values;
+    const udPruningTable = context.phase1Tables.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 = getMoveFaceByIndex(moveIndex, context.phase1Tables.phase1Moves);
+        path.push(context.phase1Tables.phase1Moves[moveIndex]);
+        if (searchPhase1Interleaved(nextCornerOrientation, nextEdgeOrientation, nextUdSlice, face, previousFace, remainingDepth - 1, path, context)) {
+            return true;
+        }
+        path.pop();
+        if (context.timedOut) {
+            return false;
+        }
+    }
+    return false;
+}

package/dist/puzzles/cube3/solver/search-utils.d.ts

@@ -0,0 +1,9 @@
+import type { Cube3Move } from "../types.js";
+export type Cube3SearchFace = number;
+export declare function getMoveFace(move: Cube3Move): Cube3SearchFace;
+export declare function getMoveFaceByIndex(moveIndex: number, moves: readonly Cube3Move[]): Cube3SearchFace;
+export declare const ARE_OPPOSITE_FACES: readonly boolean[];
+export declare function areOppositeFaces(left: Cube3SearchFace, right: Cube3SearchFace): boolean;
+export declare function shouldSkipCube3SearchMove(face: Cube3SearchFace, previousFace: Cube3SearchFace | undefined, previousPreviousFace: Cube3SearchFace | undefined): boolean;
+export declare function lookupMoveTableByIndex(values: Int32Array, coordinate: number, moveIndex: number, moveCount: number): number;
+//# sourceMappingURL=search-utils.d.ts.map

package/dist/puzzles/cube3/solver/search-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-utils.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/search-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAYrC,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,eAAe,CAElG;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,OAAO,EAOhD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAEvF;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,eAAe,GAAG,SAAS,EACzC,oBAAoB,EAAE,eAAe,GAAG,SAAS,GAChD,OAAO,CAcT;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAER"}

package/dist/puzzles/cube3/solver/search-utils.js

@@ -0,0 +1,41 @@
+// Face indices: U=0, D=1, R=2, L=3, F=4, B=5
+const FACE_INDEX_BY_CHAR = {
+    U: 0,
+    D: 1,
+    R: 2,
+    L: 3,
+    F: 4,
+    B: 5
+};
+export function getMoveFace(move) {
+    return FACE_INDEX_BY_CHAR[move[0]];
+}
+export function getMoveFaceByIndex(moveIndex, moves) {
+    return FACE_INDEX_BY_CHAR[moves[moveIndex][0]];
+}
+export const ARE_OPPOSITE_FACES = [
+    false, true, false, false, false, false,
+    true, false, false, false, false, false,
+    false, false, false, true, false, false,
+    false, false, true, false, false, false,
+    false, false, false, false, false, true,
+    false, false, false, false, true, false
+];
+export function areOppositeFaces(left, right) {
+    return ARE_OPPOSITE_FACES[left * 6 + right];
+}
+export function shouldSkipCube3SearchMove(face, previousFace, previousPreviousFace) {
+    if (previousFace === undefined || previousFace === -1) {
+        return false;
+    }
+    if (face === previousFace) {
+        return true;
+    }
+    if (previousPreviousFace === face && areOppositeFaces(face, previousFace)) {
+        return true;
+    }
+    return areOppositeFaces(face, previousFace) && face < previousFace;
+}
+export function lookupMoveTableByIndex(values, coordinate, moveIndex, moveCount) {
+    return values[coordinate * moveCount + moveIndex];
+}

package/dist/puzzles/cube3/solver/table-metadata.d.ts

@@ -0,0 +1,97 @@
+export declare const CUBE3_SOLVER_TABLE_METADATA: {
+    readonly moveTables: {
+        readonly cornerOrientation: {
+            readonly range: 2187;
+            readonly moves: 18;
+            readonly solvedCoordinate: 0;
+            readonly checksum: 404550471;
+        };
+        readonly edgeOrientation: {
+            readonly range: 2048;
+            readonly moves: 18;
+            readonly solvedCoordinate: 0;
+            readonly checksum: 2992539525;
+        };
+        readonly udSlice: {
+            readonly range: 495;
+            readonly moves: 18;
+            readonly solvedCoordinate: 494;
+            readonly checksum: 4272096359;
+        };
+        readonly cornerPermutation: {
+            readonly range: 40320;
+            readonly moves: 10;
+            readonly solvedCoordinate: 0;
+            readonly checksum: 3774927605;
+        };
+        readonly udEdgePermutation: {
+            readonly range: 40320;
+            readonly moves: 10;
+            readonly solvedCoordinate: 0;
+            readonly checksum: 400302421;
+        };
+        readonly slicePermutation: {
+            readonly range: 24;
+            readonly moves: 10;
+            readonly solvedCoordinate: 0;
+            readonly checksum: 3510358217;
+        };
+    };
+    readonly pruningTables: {
+        readonly cornerOrientation: {
+            readonly range: 2187;
+            readonly moves: 18;
+            readonly checksum: 1708398310;
+            readonly maxDepth: 6;
+        };
+        readonly edgeOrientation: {
+            readonly range: 2048;
+            readonly moves: 18;
+            readonly checksum: 1305811170;
+            readonly maxDepth: 7;
+        };
+        readonly udSlice: {
+            readonly range: 495;
+            readonly moves: 18;
+            readonly checksum: 1205412689;
+            readonly maxDepth: 5;
+        };
+        readonly cornerOrientationEdgeOrientation: {
+            readonly range: 4478976;
+            readonly moves: 18;
+            readonly checksum: 3003139252;
+            readonly maxDepth: 9;
+        };
+        readonly cornerPermutation: {
+            readonly range: 40320;
+            readonly moves: 10;
+            readonly checksum: 2124468218;
+            readonly maxDepth: 13;
+        };
+        readonly udEdgePermutation: {
+            readonly range: 40320;
+            readonly moves: 10;
+            readonly checksum: 3536968007;
+            readonly maxDepth: 8;
+        };
+        readonly slicePermutation: {
+            readonly range: 24;
+            readonly moves: 10;
+            readonly checksum: 2803408469;
+            readonly maxDepth: 4;
+        };
+        readonly cornerPermutationSlicePermutation: {
+            readonly range: 967680;
+            readonly moves: 10;
+            readonly checksum: 4187188769;
+            readonly maxDepth: 14;
+        };
+        readonly udEdgePermutationSlicePermutation: {
+            readonly range: 967680;
+            readonly moves: 10;
+            readonly checksum: 2840452350;
+            readonly maxDepth: 12;
+        };
+    };
+};
+//# sourceMappingURL=table-metadata.d.ts.map

package/dist/puzzles/cube3/solver/table-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-metadata.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/table-metadata.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB9B,CAAC"}

package/dist/puzzles/cube3/solver/table-metadata.js

@@ -0,0 +1,21 @@
+export const CUBE3_SOLVER_TABLE_METADATA = {
+    moveTables: {
+        cornerOrientation: { range: 2187, moves: 18, solvedCoordinate: 0, checksum: 404550471 },
+        edgeOrientation: { range: 2048, moves: 18, solvedCoordinate: 0, checksum: 2992539525 },
+        udSlice: { range: 495, moves: 18, solvedCoordinate: 494, checksum: 4272096359 },
+        cornerPermutation: { range: 40320, moves: 10, solvedCoordinate: 0, checksum: 3774927605 },
+        udEdgePermutation: { range: 40320, moves: 10, solvedCoordinate: 0, checksum: 400302421 },
+        slicePermutation: { range: 24, moves: 10, solvedCoordinate: 0, checksum: 3510358217 }
+    },
+    pruningTables: {
+        cornerOrientation: { range: 2187, moves: 18, checksum: 1708398310, maxDepth: 6 },
+        edgeOrientation: { range: 2048, moves: 18, checksum: 1305811170, maxDepth: 7 },
+        udSlice: { range: 495, moves: 18, checksum: 1205412689, maxDepth: 5 },
+        cornerOrientationEdgeOrientation: { range: 4478976, moves: 18, checksum: 3003139252, maxDepth: 9 },
+        cornerPermutation: { range: 40320, moves: 10, checksum: 2124468218, maxDepth: 13 },
+        udEdgePermutation: { range: 40320, moves: 10, checksum: 3536968007, maxDepth: 8 },
+        slicePermutation: { range: 24, moves: 10, checksum: 2803408469, maxDepth: 4 },
+        cornerPermutationSlicePermutation: { range: 967680, moves: 10, checksum: 4187188769, maxDepth: 14 },
+        udEdgePermutationSlicePermutation: { range: 967680, moves: 10, checksum: 2840452350, maxDepth: 12 }
+    }
+};

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

@@ -0,0 +1,72 @@
+import type { Cube3Move } from "../types.js";
+import type { Cube3CoordinateState } from "./coordinates.js";
+export type Cube3CoordinateName = keyof Cube3CoordinateState;
+export type Cube3PruningTableName = Cube3CoordinateName | "cornerOrientationEdgeOrientation" | "cornerPermutationSlicePermutation" | "udEdgePermutationSlicePermutation";
+export interface Cube3MoveTable {
+    coordinate: Cube3CoordinateName;
+    moves: readonly Cube3Move[];
+    range: number;
+    solvedCoordinate: number;
+    values: Int32Array;
+    checksum: number;
+}
+export interface Cube3PruningTable {
+    coordinate: Cube3PruningTableName;
+    moves: readonly Cube3Move[];
+    range: number;
+    values: Uint8Array;
+    checksum: number;
+    maxDepth: number;
+}
+export interface Cube3SolverTables {
+    phase1Moves: readonly Cube3Move[];
+    phase2Moves: readonly Cube3Move[];
+    moveTables: {
+        cornerOrientation: Cube3MoveTable;
+        edgeOrientation: Cube3MoveTable;
+        udSlice: Cube3MoveTable;
+        cornerPermutation: Cube3MoveTable;
+        udEdgePermutation: Cube3MoveTable;
+        slicePermutation: Cube3MoveTable;
+    };
+    pruningTables: {
+        cornerOrientation: Cube3PruningTable;
+        edgeOrientation: Cube3PruningTable;
+        udSlice: Cube3PruningTable;
+        cornerOrientationEdgeOrientation: Cube3PruningTable;
+        cornerPermutation: Cube3PruningTable;
+        udEdgePermutation: Cube3PruningTable;
+        slicePermutation: Cube3PruningTable;
+        cornerPermutationSlicePermutation: Cube3PruningTable;
+        udEdgePermutationSlicePermutation: Cube3PruningTable;
+    };
+}
+export interface Cube3Phase1Tables {
+    phase1Moves: readonly Cube3Move[];
+    moveTables: Pick<Cube3SolverTables["moveTables"], "cornerOrientation" | "edgeOrientation" | "udSlice">;
+    pruningTables: Pick<Cube3SolverTables["pruningTables"], "cornerOrientation" | "edgeOrientation" | "udSlice"> & {
+        cornerOrientationEdgeOrientation: Cube3PruningTable;
+    };
+}
+export interface Cube3Phase2Tables {
+    phase2Moves: readonly Cube3Move[];
+    moveTables: Pick<Cube3SolverTables["moveTables"], "cornerPermutation" | "udEdgePermutation" | "slicePermutation">;
+    pruningTables: Pick<Cube3SolverTables["pruningTables"], "cornerPermutation" | "udEdgePermutation" | "slicePermutation"> & {
+        cornerPermutationSlicePermutation: Cube3PruningTable;
+        udEdgePermutationSlicePermutation: Cube3PruningTable;
+    };
+}
+export declare const CUBE3_PHASE1_MOVES: readonly ("U" | "D" | "R" | "L" | "F" | "B" | "U2" | "U'" | "D2" | "D'" | "R2" | "R'" | "L2" | "L'" | "F2" | "F'" | "B2" | "B'")[];
+export declare const CUBE3_PHASE2_MOVES: readonly Cube3Move[];
+export declare function loadCube3SolverTables(): Promise<Cube3SolverTables>;
+export declare function loadCube3Phase1Tables(): Promise<Cube3Phase1Tables>;
+export declare function loadCube3Phase2Tables(): Promise<Cube3Phase2Tables>;
+export declare function generateCube3Phase1Tables(): Cube3Phase1Tables;
+export declare function generateCube3SolverTables(): Cube3SolverTables;
+export declare function generateCube3Phase2Tables(): Cube3Phase2Tables;
+export declare function generateCube3MoveTable(coordinate: Cube3CoordinateName, range: number, moves: readonly Cube3Move[]): Cube3MoveTable;
+export declare function generateCube3PruningTable(moveTable: Cube3MoveTable): Cube3PruningTable;
+export declare function generateCube3CombinedPruningTable(tableA: Cube3MoveTable, tableB: Cube3MoveTable): Cube3PruningTable;
+export declare function lookupCube3MoveTable(table: Cube3MoveTable, coordinate: number, move: Cube3Move): number;
+export declare function checksum(values: ArrayLike<number>): number;
+//# sourceMappingURL=tables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/tables.ts"],"names":[],"mappings":"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"}