@cubingcenter/scrambler 0.1.0

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

@@ -0,0 +1,202 @@
+import { CUBE3_MOVES } from "../types.js";
+import { CUBE3_COORDINATE_RANGES, encodeCube3Coordinates, moveCoordinate } from "./coordinates.js";
+import { createSolvedCube3State } from "../state.js";
+import { loadGeneratedCube3Phase1Tables, loadGeneratedCube3Phase2Tables, loadGeneratedCube3SolverTables } from "./generated-assets.js";
+export const CUBE3_PHASE1_MOVES = CUBE3_MOVES;
+export const CUBE3_PHASE2_MOVES = [
+    "U",
+    "U2",
+    "U'",
+    "D",
+    "D2",
+    "D'",
+    "R2",
+    "L2",
+    "F2",
+    "B2"
+];
+let cachedTables;
+let cachedPhase1Tables;
+let cachedPhase2Tables;
+export async function loadCube3SolverTables() {
+    cachedTables ??= await loadGeneratedCube3SolverTables();
+    return cachedTables;
+}
+export async function loadCube3Phase1Tables() {
+    cachedPhase1Tables ??= await loadGeneratedCube3Phase1Tables();
+    return cachedPhase1Tables;
+}
+export async function loadCube3Phase2Tables() {
+    cachedPhase2Tables ??= await loadGeneratedCube3Phase2Tables();
+    return cachedPhase2Tables;
+}
+export function generateCube3Phase1Tables() {
+    const cornerOrientation = generateCube3MoveTable("cornerOrientation", CUBE3_COORDINATE_RANGES.cornerOrientation, CUBE3_PHASE1_MOVES);
+    const edgeOrientation = generateCube3MoveTable("edgeOrientation", CUBE3_COORDINATE_RANGES.edgeOrientation, CUBE3_PHASE1_MOVES);
+    const udSlice = generateCube3MoveTable("udSlice", CUBE3_COORDINATE_RANGES.udSlice, CUBE3_PHASE1_MOVES);
+    return {
+        phase1Moves: CUBE3_PHASE1_MOVES,
+        moveTables: {
+            cornerOrientation,
+            edgeOrientation,
+            udSlice
+        },
+        pruningTables: {
+            cornerOrientation: generateCube3PruningTable(cornerOrientation),
+            edgeOrientation: generateCube3PruningTable(edgeOrientation),
+            udSlice: generateCube3PruningTable(udSlice),
+            cornerOrientationEdgeOrientation: generateCube3CombinedPruningTable(cornerOrientation, edgeOrientation)
+        }
+    };
+}
+export function generateCube3SolverTables() {
+    const phase1Tables = generateCube3Phase1Tables();
+    const phase2Tables = generateCube3Phase2Tables();
+    return {
+        phase1Moves: CUBE3_PHASE1_MOVES,
+        phase2Moves: CUBE3_PHASE2_MOVES,
+        moveTables: {
+            cornerOrientation: phase1Tables.moveTables.cornerOrientation,
+            edgeOrientation: phase1Tables.moveTables.edgeOrientation,
+            udSlice: phase1Tables.moveTables.udSlice,
+            cornerPermutation: phase2Tables.moveTables.cornerPermutation,
+            udEdgePermutation: phase2Tables.moveTables.udEdgePermutation,
+            slicePermutation: phase2Tables.moveTables.slicePermutation
+        },
+        pruningTables: {
+            cornerOrientation: phase1Tables.pruningTables.cornerOrientation,
+            edgeOrientation: phase1Tables.pruningTables.edgeOrientation,
+            udSlice: phase1Tables.pruningTables.udSlice,
+            cornerOrientationEdgeOrientation: phase1Tables.pruningTables.cornerOrientationEdgeOrientation,
+            cornerPermutation: phase2Tables.pruningTables.cornerPermutation,
+            udEdgePermutation: phase2Tables.pruningTables.udEdgePermutation,
+            slicePermutation: phase2Tables.pruningTables.slicePermutation,
+            cornerPermutationSlicePermutation: phase2Tables.pruningTables.cornerPermutationSlicePermutation,
+            udEdgePermutationSlicePermutation: phase2Tables.pruningTables.udEdgePermutationSlicePermutation
+        }
+    };
+}
+export function generateCube3Phase2Tables() {
+    const cornerPermutation = generateCube3MoveTable("cornerPermutation", CUBE3_COORDINATE_RANGES.cornerPermutation, CUBE3_PHASE2_MOVES);
+    const udEdgePermutation = generateCube3MoveTable("udEdgePermutation", CUBE3_COORDINATE_RANGES.udEdgePermutation, CUBE3_PHASE2_MOVES);
+    const slicePermutation = generateCube3MoveTable("slicePermutation", CUBE3_COORDINATE_RANGES.slicePermutation, CUBE3_PHASE2_MOVES);
+    return {
+        phase2Moves: CUBE3_PHASE2_MOVES,
+        moveTables: {
+            cornerPermutation,
+            udEdgePermutation,
+            slicePermutation
+        },
+        pruningTables: {
+            cornerPermutation: generateCube3PruningTable(cornerPermutation),
+            udEdgePermutation: generateCube3PruningTable(udEdgePermutation),
+            slicePermutation: generateCube3PruningTable(slicePermutation),
+            cornerPermutationSlicePermutation: generateCube3CombinedPruningTable(cornerPermutation, slicePermutation),
+            udEdgePermutationSlicePermutation: generateCube3CombinedPruningTable(udEdgePermutation, slicePermutation)
+        }
+    };
+}
+export function generateCube3MoveTable(coordinate, range, moves) {
+    const values = new Int32Array(range * moves.length);
+    for (let value = 0; value < range; value += 1) {
+        for (let moveIndex = 0; moveIndex < moves.length; moveIndex += 1) {
+            values[value * moves.length + moveIndex] = moveCoordinate(coordinate, value, moves[moveIndex]);
+        }
+    }
+    return {
+        coordinate,
+        moves,
+        range,
+        solvedCoordinate: encodeCube3Coordinates(createSolvedCube3State())[coordinate],
+        values,
+        checksum: checksum(values)
+    };
+}
+export function generateCube3PruningTable(moveTable) {
+    const values = new Uint8Array(moveTable.range);
+    values.fill(255);
+    values[moveTable.solvedCoordinate] = 0;
+    const queue = new Int32Array(moveTable.range);
+    let read = 0;
+    let write = 1;
+    queue[0] = moveTable.solvedCoordinate;
+    let maxDepth = 0;
+    while (read < write) {
+        const current = queue[read];
+        read += 1;
+        const nextDepth = values[current] + 1;
+        for (let moveIndex = 0; moveIndex < moveTable.moves.length; moveIndex += 1) {
+            const next = moveTable.values[current * moveTable.moves.length + moveIndex];
+            if (values[next] !== 255) {
+                continue;
+            }
+            values[next] = nextDepth;
+            maxDepth = Math.max(maxDepth, nextDepth);
+            queue[write] = next;
+            write += 1;
+        }
+    }
+    return {
+        coordinate: moveTable.coordinate,
+        moves: moveTable.moves,
+        range: moveTable.range,
+        values,
+        checksum: checksum(values),
+        maxDepth
+    };
+}
+export function generateCube3CombinedPruningTable(tableA, tableB) {
+    const combinedRange = tableA.range * tableB.range;
+    const values = new Uint8Array(combinedRange);
+    values.fill(255);
+    const solvedCoordinate = tableA.solvedCoordinate * tableB.range + tableB.solvedCoordinate;
+    values[solvedCoordinate] = 0;
+    const queue = new Int32Array(combinedRange);
+    let read = 0;
+    let write = 1;
+    queue[0] = solvedCoordinate;
+    let maxDepth = 0;
+    while (read < write) {
+        const current = queue[read];
+        read += 1;
+        const nextDepth = values[current] + 1;
+        const currentA = Math.floor(current / tableB.range);
+        const currentB = current % tableB.range;
+        for (let moveIndex = 0; moveIndex < tableA.moves.length; moveIndex += 1) {
+            const nextA = tableA.values[currentA * tableA.moves.length + moveIndex];
+            const nextB = tableB.values[currentB * tableB.moves.length + moveIndex];
+            const next = nextA * tableB.range + nextB;
+            if (values[next] !== 255) {
+                continue;
+            }
+            values[next] = nextDepth;
+            maxDepth = Math.max(maxDepth, nextDepth);
+            queue[write] = next;
+            write += 1;
+        }
+    }
+    const combinedName = `${tableA.coordinate}${tableB.coordinate.charAt(0).toUpperCase() + tableB.coordinate.slice(1)}`;
+    return {
+        coordinate: combinedName,
+        moves: tableA.moves,
+        range: combinedRange,
+        values,
+        checksum: checksum(values),
+        maxDepth
+    };
+}
+export function lookupCube3MoveTable(table, coordinate, move) {
+    const moveIndex = table.moves.indexOf(move);
+    if (moveIndex === -1) {
+        throw new RangeError(`Move ${move} is not part of ${table.coordinate} table.`);
+    }
+    return table.values[coordinate * table.moves.length + moveIndex];
+}
+export 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/worker-pool.d.ts

@@ -0,0 +1,18 @@
+import type { ScrambleOptions, ScrambleResult } from "../../../core/types.js";
+export declare class Cube3WorkerPool {
+    private workers;
+    private available;
+    private pending;
+    private queue;
+    private nextId;
+    private terminated;
+    constructor(size?: number);
+    generate(options?: ScrambleOptions & {
+        skipValidation?: boolean;
+    }): Promise<ScrambleResult>;
+    generateBatch(count: number, deriveSeed: (index: number) => string | number | undefined): Promise<ScrambleResult[]>;
+    terminate(): Promise<number[]>;
+    private handleResponse;
+    private handleError;
+}
+//# sourceMappingURL=worker-pool.d.ts.map

package/dist/puzzles/cube3/solver/worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-pool.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/worker-pool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAkC9E,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,UAAU,CAAS;gBAEf,IAAI,GAAE,MAAgD;IAsBlE,QAAQ,CAAC,OAAO,GAAE,eAAe,GAAG;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IAwB/F,aAAa,CACX,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,GAAG,SAAS,GACzD,OAAO,CAAC,cAAc,EAAE,CAAC;IAQ5B,SAAS,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAW9B,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,WAAW;CAMpB"}

package/dist/puzzles/cube3/solver/worker-pool.js

@@ -0,0 +1,116 @@
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import os from "node:os";
+function resolveWorkerPath() {
+    const currentFile = fileURLToPath(import.meta.url);
+    const currentDir = dirname(currentFile);
+    const isSource = currentFile.includes("/src/") || currentFile.includes("\\src\\");
+    const filename = isSource ? "worker.ts" : "worker.js";
+    return join(currentDir, filename);
+}
+function getWorkerExecArgv() {
+    const currentFile = fileURLToPath(import.meta.url);
+    const isSource = currentFile.includes("/src/") || currentFile.includes("\\src\\");
+    if (!isSource)
+        return [];
+    return ["--import", "tsx"];
+}
+export class Cube3WorkerPool {
+    workers = [];
+    available = [];
+    pending = new Map();
+    queue = [];
+    nextId = 0;
+    terminated = false;
+    constructor(size = Math.max(1, Math.min(8, getCpuCount()))) {
+        const workerPath = resolveWorkerPath();
+        const execArgv = getWorkerExecArgv();
+        for (let i = 0; i < size; i++) {
+            const worker = new Worker(workerPath, {
+                execArgv
+            });
+            worker.on("message", (response) => {
+                this.handleResponse(worker, response);
+            });
+            worker.on("error", (error) => {
+                this.handleError(error);
+            });
+            this.workers.push(worker);
+            this.available.push(worker);
+        }
+    }
+    generate(options = {}) {
+        if (this.terminated) {
+            return Promise.reject(new Error("Worker pool has been terminated."));
+        }
+        const id = this.nextId++;
+        const task = {
+            id,
+            ...(options.seed !== undefined ? { seed: options.seed } : {}),
+            ...(options.skipValidation !== undefined ? { skipValidation: options.skipValidation } : {})
+        };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            if (this.available.length > 0) {
+                const worker = this.available.pop();
+                worker.postMessage(task);
+            }
+            else {
+                this.queue.push(task);
+            }
+        });
+    }
+    generateBatch(count, deriveSeed) {
+        const promises = Array.from({ length: count }, (_, index) => {
+            const seed = deriveSeed(index);
+            return this.generate(seed !== undefined ? { seed } : {});
+        });
+        return Promise.all(promises);
+    }
+    terminate() {
+        this.terminated = true;
+        this.queue = [];
+        this.pending.forEach(({ reject }) => {
+            reject(new Error("Worker pool terminated."));
+        });
+        this.pending.clear();
+        return Promise.all(this.workers.map((w) => w.terminate()));
+    }
+    handleResponse(worker, response) {
+        const pending = this.pending.get(response.id);
+        if (!pending)
+            return;
+        this.pending.delete(response.id);
+        if (response.error) {
+            pending.reject(new Error(response.error));
+        }
+        else if (response.result) {
+            pending.resolve(response.result);
+        }
+        else {
+            pending.reject(new Error("Worker returned empty response."));
+        }
+        if (this.queue.length > 0) {
+            const nextTask = this.queue.shift();
+            worker.postMessage(nextTask);
+        }
+        else {
+            this.available.push(worker);
+        }
+    }
+    handleError(error) {
+        // If a worker crashes, reject all pending tasks
+        // In a production system we'd respawn the worker
+        this.pending.forEach(({ reject }) => reject(error));
+        this.pending.clear();
+    }
+}
+function getCpuCount() {
+    try {
+        return os.cpus().length;
+    }
+    catch {
+        return 4;
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/worker.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,73 @@
+import { parentPort } from "node:worker_threads";
+import { generateRandomCube3State } from "../random-state.js";
+import { createSolvedCube3State, cube3StatesEqual, isSolvedCube3State } from "../state.js";
+import { applyCube3Algorithm, formatCube3Algorithm, invertCube3Algorithm } from "../moves.js";
+import { formatCube3Facelets, toCube3Facelets } from "../facelets.js";
+import { solveCube3State } from "./index.js";
+let tablesLoaded = false;
+async function ensureTables() {
+    if (tablesLoaded)
+        return;
+    const { loadCube3SolverTables } = await import("./tables.js");
+    await loadCube3SolverTables();
+    tablesLoaded = true;
+}
+async function generate(task) {
+    await ensureTables();
+    const options = {
+        ...(task.seed !== undefined ? { seed: task.seed } : {}),
+        ...(task.skipValidation !== undefined ? { skipValidation: task.skipValidation } : {})
+    };
+    const state = generateRandomCube3State(options);
+    const solution = await solveCube3State(state);
+    const scrambleMoves = invertCube3Algorithm(solution.moves);
+    if (!options.skipValidation) {
+        const scrambledState = applyCube3Algorithm(createSolvedCube3State(), scrambleMoves);
+        if (!cube3StatesEqual(scrambledState, state)) {
+            throw new Error("Generated 3x3 scramble does not reproduce the target random state.");
+        }
+        if (!isSolvedCube3State(solution.state)) {
+            throw new Error("Generated 3x3 solution does not solve the target random state.");
+        }
+        if (scrambleMoves.length < 2) {
+            throw new Error("Generated 3x3 scramble is too short.");
+        }
+    }
+    const facelets = toCube3Facelets(state);
+    const result = {
+        eventId: "333",
+        scramble: formatCube3Algorithm(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "cube3-two-phase",
+        metadata: {
+            state,
+            facelets,
+            faceletString: formatCube3Facelets(facelets),
+            solutionMoves: solution.moves,
+            solutionDepth: solution.depth,
+            phase1Depth: solution.phase1.depth,
+            phase2Depth: solution.phase2.depth,
+            visitedNodes: solution.visitedNodes
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+if (!parentPort) {
+    throw new Error("This module must be run as a worker thread.");
+}
+parentPort.on("message", async (task) => {
+    try {
+        const result = await generate(task);
+        const response = { id: task.id, result };
+        parentPort.postMessage(response);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const response = { id: task.id, error: message };
+        parentPort.postMessage(response);
+    }
+});

package/dist/puzzles/cube3/state.d.ts

@@ -0,0 +1,6 @@
+import type { Cube3State } from "./types.js";
+export declare function createSolvedCube3State(): Cube3State;
+export declare function cloneCube3State(state: Cube3State): Cube3State;
+export declare function cube3StatesEqual(left: Cube3State, right: Cube3State): boolean;
+export declare function isSolvedCube3State(state: Cube3State): boolean;
+//# sourceMappingURL=state.d.ts.map

package/dist/puzzles/cube3/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAWnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAW7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAO7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}

package/dist/puzzles/cube3/state.js

@@ -0,0 +1,40 @@
+import { CORNER_COUNT, EDGE_COUNT } from "./types.js";
+export function createSolvedCube3State() {
+    return {
+        corners: {
+            permutation: range(CORNER_COUNT),
+            orientation: Array(CORNER_COUNT).fill(0)
+        },
+        edges: {
+            permutation: range(EDGE_COUNT),
+            orientation: Array(EDGE_COUNT).fill(0)
+        }
+    };
+}
+export function cloneCube3State(state) {
+    return {
+        corners: {
+            permutation: [...state.corners.permutation],
+            orientation: [...state.corners.orientation]
+        },
+        edges: {
+            permutation: [...state.edges.permutation],
+            orientation: [...state.edges.orientation]
+        }
+    };
+}
+export function cube3StatesEqual(left, right) {
+    return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
+        arraysEqual(left.corners.orientation, right.corners.orientation) &&
+        arraysEqual(left.edges.permutation, right.edges.permutation) &&
+        arraysEqual(left.edges.orientation, right.edges.orientation));
+}
+export function isSolvedCube3State(state) {
+    return cube3StatesEqual(state, createSolvedCube3State());
+}
+function range(length) {
+    return Array.from({ length }, (_, index) => index);
+}
+function arraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/puzzles/cube3/subset-state.d.ts

@@ -0,0 +1,4 @@
+import type { RandomSource } from "../../random/index.js";
+import type { Cube3State } from "./types.js";
+export declare function generateSubsetCube3State(subset: string, random: RandomSource): Cube3State;
+//# sourceMappingURL=subset-state.d.ts.map

package/dist/puzzles/cube3/subset-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subset-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/subset-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAK7C,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,UAAU,CAsBzF"}

package/dist/puzzles/cube3/subset-state.js

@@ -0,0 +1,163 @@
+import { createSolvedCube3State } from "./state.js";
+// The indices for the U layer pieces are 0, 1, 2, 3.
+export function generateSubsetCube3State(subset, random) {
+    const state = createSolvedCube3State();
+    if (subset === "pll") {
+        shuffleULayerPermutations(state, random);
+    }
+    else if (subset === "oll" || subset === "ll") {
+        shuffleULayerPermutations(state, random);
+        randomizeULayerOrientations(state, random, true, true);
+    }
+    else if (subset === "zbll") {
+        shuffleULayerPermutations(state, random);
+        randomizeULayerOrientations(state, random, true, false); // corners only
+    }
+    else if (subset === "lsll") {
+        shuffleLSLL(state, random);
+    }
+    else if (subset === "f2l") {
+        shuffleF2L(state, random);
+    }
+    else if (subset === "cross") {
+        shuffleFullCube(state, random);
+    }
+    else {
+        throw new Error(`Subset "${subset}" is not supported yet.`);
+    }
+    return state;
+}
+function shuffleULayerPermutations(state, random) {
+    const cornerPerm = [0, 1, 2, 3];
+    const edgePerm = [0, 1, 2, 3];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    for (let i = 0; i < 4; i++) {
+        state.corners.permutation[i] = cornerPerm[i];
+        state.edges.permutation[i] = edgePerm[i];
+    }
+}
+function randomizeULayerOrientations(state, random, corners, edges) {
+    if (corners) {
+        let sum = 0;
+        for (let i = 0; i < 3; i++) {
+            const o = random.nextInt(3);
+            state.corners.orientation[i] = o;
+            sum += o;
+        }
+        state.corners.orientation[3] = (3 - (sum % 3)) % 3;
+    }
+    if (edges) {
+        let sum = 0;
+        for (let i = 0; i < 3; i++) {
+            const o = random.nextInt(2);
+            state.edges.orientation[i] = o;
+            sum += o;
+        }
+        state.edges.orientation[3] = (2 - (sum % 2)) % 2;
+    }
+}
+function shuffle(array, random) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = random.nextInt(i + 1);
+        swap(array, i, j);
+    }
+}
+function swap(array, i, j) {
+    const temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+}
+function getParity(array) {
+    let inversions = 0;
+    for (let i = 0; i < array.length; i++) {
+        for (let j = i + 1; j < array.length; j++) {
+            if (array[i] > array[j]) {
+                inversions++;
+            }
+        }
+    }
+    return inversions % 2;
+}
+function shuffleLSLL(state, random) {
+    const cornerPerm = [0, 1, 2, 3, 4];
+    const edgePerm = [0, 1, 2, 3, 8];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    const cornerIndices = [0, 1, 2, 3, 4];
+    for (let i = 0; i < cornerIndices.length; i++) {
+        const idx = cornerIndices[i];
+        state.corners.permutation[idx] = cornerPerm[i];
+        state.corners.orientation[idx] = random.nextInt(3);
+    }
+    let cornerSum = 0;
+    for (let i = 0; i < 8; i++)
+        cornerSum += state.corners.orientation[i];
+    state.corners.orientation[4] = (state.corners.orientation[4] + (3 - (cornerSum % 3))) % 3;
+    const edgeIndices = [0, 1, 2, 3, 8];
+    for (let i = 0; i < edgeIndices.length; i++) {
+        const idx = edgeIndices[i];
+        state.edges.permutation[idx] = edgePerm[i];
+        state.edges.orientation[idx] = random.nextInt(2);
+    }
+    let edgeSum = 0;
+    for (let i = 0; i < 12; i++)
+        edgeSum += state.edges.orientation[i];
+    state.edges.orientation[8] = (state.edges.orientation[8] + (2 - (edgeSum % 2))) % 2;
+}
+function shuffleF2L(state, random) {
+    const cornerPerm = [0, 1, 2, 3, 4, 5, 6, 7];
+    const edgePerm = [0, 1, 2, 3, 8, 9, 10, 11];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    const edgeIndices = [0, 1, 2, 3, 8, 9, 10, 11];
+    for (let i = 0; i < 8; i++) {
+        state.corners.permutation[i] = cornerPerm[i];
+        state.corners.orientation[i] = random.nextInt(3);
+        const idx = edgeIndices[i];
+        state.edges.permutation[idx] = edgePerm[i];
+        state.edges.orientation[idx] = random.nextInt(2);
+    }
+    let cornerSum = 0;
+    for (let i = 0; i < 8; i++)
+        cornerSum += state.corners.orientation[i];
+    state.corners.orientation[0] = (state.corners.orientation[0] + (3 - (cornerSum % 3))) % 3;
+    let edgeSum = 0;
+    for (let i = 0; i < 12; i++)
+        edgeSum += state.edges.orientation[i];
+    state.edges.orientation[0] = (state.edges.orientation[0] + (2 - (edgeSum % 2))) % 2;
+}
+function shuffleFullCube(state, random) {
+    const cornerPerm = [0, 1, 2, 3, 4, 5, 6, 7];
+    const edgePerm = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    for (let i = 0; i < 8; i++) {
+        state.corners.permutation[i] = cornerPerm[i];
+        state.corners.orientation[i] = random.nextInt(3);
+    }
+    for (let i = 0; i < 12; i++) {
+        state.edges.permutation[i] = edgePerm[i];
+        state.edges.orientation[i] = random.nextInt(2);
+    }
+    let cornerSum = 0;
+    for (let i = 0; i < 8; i++)
+        cornerSum += state.corners.orientation[i];
+    state.corners.orientation[0] = (state.corners.orientation[0] + (3 - (cornerSum % 3))) % 3;
+    let edgeSum = 0;
+    for (let i = 0; i < 12; i++)
+        edgeSum += state.edges.orientation[i];
+    state.edges.orientation[0] = (state.edges.orientation[0] + (2 - (edgeSum % 2))) % 2;
+}

package/dist/puzzles/cube3/types.d.ts

@@ -0,0 +1,29 @@
+export declare const CORNER_COUNT = 8;
+export declare const EDGE_COUNT = 12;
+export type Cube3FaceMove = "U" | "D" | "R" | "L" | "F" | "B";
+export type Cube3Face = "U" | "R" | "F" | "D" | "L" | "B";
+export type Cube3Sticker = Cube3Face;
+export type Cube3MoveSuffix = "" | "2" | "'";
+export type Cube3Move = `${Cube3FaceMove}${Cube3MoveSuffix}`;
+export interface Cube3State {
+    corners: {
+        permutation: number[];
+        orientation: number[];
+    };
+    edges: {
+        permutation: number[];
+        orientation: number[];
+    };
+}
+export interface Cube3ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface Cube3RandomStateOptions {
+    seed?: string | number;
+    rejectTrivial?: boolean;
+    subset?: string;
+}
+export type Cube3Facelets = Record<Cube3Face, Cube3Sticker[]>;
+export declare const CUBE3_MOVES: readonly Cube3Move[];
+//# sourceMappingURL=types.d.ts.map

package/dist/puzzles/cube3/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,UAAU,KAAK,CAAC;AAE7B,MAAM,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAC9D,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAC1D,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AACrC,MAAM,MAAM,eAAe,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,GAAG,aAAa,GAAG,eAAe,EAAE,CAAC;AAE7D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,WAAW,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;IACF,KAAK,EAAE;QACL,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,WAAW,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;AAE9D,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAmB3C,CAAC"}