@cubingcenter/scrambler 0.1.0

package/dist/puzzles/cube7x7/scrambler.js

@@ -0,0 +1,93 @@
+import { createRandomSource } from "../../random/index.js";
+import { CUBE7_ALL_MOVES, SCRAMBLE_LENGTH } from "./types.js";
+export const cube7ScrambleGenerator = {
+    info: {
+        eventId: "777",
+        name: "7x7x7 Cube",
+        puzzle: "cube-7x7",
+        quality: "random-move",
+        generator: "cube7-random-move",
+        description: "Random-move 7x7 scramble with 100 moves."
+    },
+    generate(options = {}) {
+        return generateCube7Scramble(options);
+    }
+};
+export function generateCube7Scramble(options = {}) {
+    const random = createRandomSource(options.seed);
+    const moves = [];
+    for (let i = 0; i < SCRAMBLE_LENGTH; i++) {
+        let move;
+        do {
+            move = random.choice(CUBE7_ALL_MOVES);
+        } while (isRedundant(moves, move));
+        moves.push(move);
+    }
+    const scramble = moves.join(" ");
+    const result = {
+        eventId: "777",
+        scramble,
+        moves,
+        quality: "random-move",
+        generator: "cube7-random-move",
+        metadata: {
+            totalMoves: moves.length,
+            distribution: "random-move-wca-format"
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+const MAX_AXIS_BLOCK = 4;
+function getBaseMove(move) {
+    if (move.endsWith("2") || move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return move;
+}
+function getAxis(base) {
+    if (base.includes("R") || base.includes("L"))
+        return "X";
+    if (base.includes("U") || base.includes("D"))
+        return "Y";
+    if (base.includes("F") || base.includes("B"))
+        return "Z";
+    return "";
+}
+function isRedundant(moves, newMove) {
+    if (moves.length === 0)
+        return false;
+    const newBase = getBaseMove(newMove);
+    const newAxis = getAxis(newBase);
+    const lastBase = getBaseMove(moves[moves.length - 1]);
+    // No same base move consecutively
+    if (lastBase === newBase)
+        return true;
+    const lastAxis = getAxis(lastBase);
+    // Different axis: always allowed
+    if (newAxis !== lastAxis)
+        return false;
+    // Same axis: scan the current block
+    const basesInBlock = new Set();
+    basesInBlock.add(lastBase);
+    let blockLength = 1;
+    for (let i = moves.length - 2; i >= 0; i--) {
+        const base = getBaseMove(moves[i]);
+        if (getAxis(base) === newAxis) {
+            basesInBlock.add(base);
+            blockLength++;
+        }
+        else {
+            break;
+        }
+    }
+    // No same base within the block
+    if (basesInBlock.has(newBase))
+        return true;
+    // Max block length
+    if (blockLength >= MAX_AXIS_BLOCK)
+        return true;
+    return false;
+}

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

@@ -0,0 +1,4 @@
+export type Cube7Move = "U" | "U2" | "U'" | "D" | "D2" | "D'" | "R" | "R2" | "R'" | "L" | "L2" | "L'" | "F" | "F2" | "F'" | "B" | "B2" | "B'" | "Uw" | "Uw2" | "Uw'" | "Dw" | "Dw2" | "Dw'" | "Rw" | "Rw2" | "Rw'" | "Lw" | "Lw2" | "Lw'" | "Fw" | "Fw2" | "Fw'" | "Bw" | "Bw2" | "Bw'" | "3Uw" | "3Uw2" | "3Uw'" | "3Dw" | "3Dw2" | "3Dw'" | "3Rw" | "3Rw2" | "3Rw'" | "3Lw" | "3Lw2" | "3Lw'" | "3Fw" | "3Fw2" | "3Fw'" | "3Bw" | "3Bw2" | "3Bw'";
+export declare const CUBE7_ALL_MOVES: readonly Cube7Move[];
+export declare const SCRAMBLE_LENGTH = 100;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube7x7/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB,GAAG,GAAG,IAAI,GAAG,IAAI,GACjB,GAAG,GAAG,IAAI,GAAG,IAAI,GACjB,GAAG,GAAG,IAAI,GAAG,IAAI,GACjB,GAAG,GAAG,IAAI,GAAG,IAAI,GACjB,GAAG,GAAG,IAAI,GAAG,IAAI,GACjB,GAAG,GAAG,IAAI,GAAG,IAAI,GACjB,IAAI,GAAG,KAAK,GAAG,KAAK,GACpB,IAAI,GAAG,KAAK,GAAG,KAAK,GACpB,IAAI,GAAG,KAAK,GAAG,KAAK,GACpB,IAAI,GAAG,KAAK,GAAG,KAAK,GACpB,IAAI,GAAG,KAAK,GAAG,KAAK,GACpB,IAAI,GAAG,KAAK,GAAG,KAAK,GACpB,KAAK,GAAG,MAAM,GAAG,MAAM,GACvB,KAAK,GAAG,MAAM,GAAG,MAAM,GACvB,KAAK,GAAG,MAAM,GAAG,MAAM,GACvB,KAAK,GAAG,MAAM,GAAG,MAAM,GACvB,KAAK,GAAG,MAAM,GAAG,MAAM,GACvB,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAS5B,eAAO,MAAM,eAAe,EAAE,SAAS,SAAS,EAE/C,CAAC;AAEF,eAAO,MAAM,eAAe,MAAM,CAAC"}

package/dist/puzzles/cube7x7/types.js

@@ -0,0 +1,8 @@
+const BASE_MOVES = [
+    "U", "D", "R", "L", "F", "B",
+    "Uw", "Dw", "Rw", "Lw", "Fw", "Bw",
+    "3Uw", "3Dw", "3Rw", "3Lw", "3Fw", "3Bw"
+];
+const SUFFIXES = ["", "2", "'"];
+export const CUBE7_ALL_MOVES = BASE_MOVES.flatMap((base) => SUFFIXES.map(suffix => `${base}${suffix}`));
+export const SCRAMBLE_LENGTH = 100;

package/dist/puzzles/index.d.ts

@@ -0,0 +1,10 @@
+export * as cube2 from "./cube2/index.js";
+export * as cube3 from "./cube3/index.js";
+export * as cube4 from "./cube4/index.js";
+export * as megaminx from "./megaminx/index.js";
+export * as cube5x5 from "./cube5x5/index.js";
+export * as cube6x6 from "./cube6x6/index.js";
+export * as cube7x7 from "./cube7x7/index.js";
+export * as pyraminx from "./pyraminx/index.js";
+export * as clock from "./clock/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/puzzles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/puzzles/index.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC"}

package/dist/puzzles/index.js

@@ -0,0 +1,28 @@
+import { registerScrambleGenerator } from "../core/index.js";
+import { cube2ScrambleGenerator } from "./cube2/index.js";
+import { cube3ScrambleGenerator } from "./cube3/index.js";
+import { cube4ScrambleGenerator } from "./cube4/index.js";
+import { megaminxScrambleGenerator } from "./megaminx/index.js";
+import { cube5ScrambleGenerator } from "./cube5x5/index.js";
+import { cube6ScrambleGenerator } from "./cube6x6/index.js";
+import { cube7ScrambleGenerator } from "./cube7x7/index.js";
+import { pyraminxScrambleGenerator } from "./pyraminx/index.js";
+import { clockScrambleGenerator } from "./clock/index.js";
+registerScrambleGenerator(cube2ScrambleGenerator);
+registerScrambleGenerator(cube3ScrambleGenerator);
+registerScrambleGenerator(cube4ScrambleGenerator);
+registerScrambleGenerator(megaminxScrambleGenerator);
+registerScrambleGenerator(cube5ScrambleGenerator);
+registerScrambleGenerator(cube6ScrambleGenerator);
+registerScrambleGenerator(cube7ScrambleGenerator);
+registerScrambleGenerator(pyraminxScrambleGenerator);
+registerScrambleGenerator(clockScrambleGenerator);
+export * as cube2 from "./cube2/index.js";
+export * as cube3 from "./cube3/index.js";
+export * as cube4 from "./cube4/index.js";
+export * as megaminx from "./megaminx/index.js";
+export * as cube5x5 from "./cube5x5/index.js";
+export * as cube6x6 from "./cube6x6/index.js";
+export * as cube7x7 from "./cube7x7/index.js";
+export * as pyraminx from "./pyraminx/index.js";
+export * as clock from "./clock/index.js";

package/dist/puzzles/megaminx/index.d.ts

@@ -0,0 +1,4 @@
+export type { MegaminxMove } from "./types.js";
+export { MEGAMINX_R_MOVES, MEGAMINX_D_MOVES, SCRAMBLE_LINES, MOVES_PER_LINE } from "./types.js";
+export { megaminxScrambleGenerator, generateMegaminxScramble } from "./scrambler.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/puzzles/megaminx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/megaminx/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,gBAAgB,CAAC"}

package/dist/puzzles/megaminx/index.js

@@ -0,0 +1,2 @@
+export { MEGAMINX_R_MOVES, MEGAMINX_D_MOVES, SCRAMBLE_LINES, MOVES_PER_LINE } from "./types.js";
+export { megaminxScrambleGenerator, generateMegaminxScramble } from "./scrambler.js";

package/dist/puzzles/megaminx/scrambler.d.ts

@@ -0,0 +1,4 @@
+import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
+export declare const megaminxScrambleGenerator: ScrambleGenerator;
+export declare function generateMegaminxScramble(options?: ScrambleOptions): ScrambleResult;
+//# sourceMappingURL=scrambler.d.ts.map

package/dist/puzzles/megaminx/scrambler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/megaminx/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAK9F,eAAO,MAAM,yBAAyB,EAAE,iBAYvC,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,eAAoB,GAAG,cAAc,CAuCtF"}

package/dist/puzzles/megaminx/scrambler.js

@@ -0,0 +1,56 @@
+import { createRandomSource } from "../../random/index.js";
+import { MEGAMINX_R_MOVES, MEGAMINX_D_MOVES, SCRAMBLE_LINES, MOVES_PER_LINE } from "./types.js";
+export const megaminxScrambleGenerator = {
+    info: {
+        eventId: "mega",
+        name: "Megaminx",
+        puzzle: "megaminx",
+        quality: "random-move",
+        generator: "megaminx-random-move",
+        description: "Random-move Megaminx scramble using WCA notation (7 lines of 10 moves + U/U')."
+    },
+    generate(options = {}) {
+        return generateMegaminxScramble(options);
+    }
+};
+export function generateMegaminxScramble(options = {}) {
+    const random = createRandomSource(options.seed);
+    const moves = [];
+    for (let line = 0; line < SCRAMBLE_LINES; line++) {
+        let lastD = "D++";
+        for (let pair = 0; pair < 5; pair++) {
+            const rMove = random.choice(MEGAMINX_R_MOVES);
+            const dMove = random.choice(MEGAMINX_D_MOVES);
+            moves.push(rMove, dMove);
+            lastD = dMove;
+        }
+        const uMove = lastD === "D++" ? "U" : "U'";
+        moves.push(uMove);
+    }
+    const scramble = formatMegaminxScramble(moves);
+    const result = {
+        eventId: "mega",
+        scramble,
+        moves,
+        quality: "random-move",
+        generator: "megaminx-random-move",
+        metadata: {
+            lines: SCRAMBLE_LINES,
+            movesPerLine: MOVES_PER_LINE,
+            totalMoves: moves.length,
+            distribution: "random-move-wca-format"
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+function formatMegaminxScramble(moves) {
+    const lines = [];
+    for (let i = 0; i < SCRAMBLE_LINES; i++) {
+        const lineMoves = moves.slice(i * MOVES_PER_LINE, (i + 1) * MOVES_PER_LINE);
+        lines.push(lineMoves.join(" "));
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,6 @@
+export type MegaminxMove = "R++" | "R--" | "D++" | "D--" | "U" | "U'";
+export declare const MEGAMINX_R_MOVES: readonly MegaminxMove[];
+export declare const MEGAMINX_D_MOVES: readonly MegaminxMove[];
+export declare const SCRAMBLE_LINES = 7;
+export declare const MOVES_PER_LINE = 11;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/megaminx/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC;AAEtE,eAAO,MAAM,gBAAgB,EAAE,SAAS,YAAY,EAA4B,CAAC;AACjF,eAAO,MAAM,gBAAgB,EAAE,SAAS,YAAY,EAA4B,CAAC;AAEjF,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,cAAc,KAAK,CAAC"}

package/dist/puzzles/megaminx/types.js

@@ -0,0 +1,4 @@
+export const MEGAMINX_R_MOVES = ["R++", "R--"];
+export const MEGAMINX_D_MOVES = ["D++", "D--"];
+export const SCRAMBLE_LINES = 7;
+export const MOVES_PER_LINE = 11;

package/dist/puzzles/pyraminx/index.d.ts

@@ -0,0 +1,9 @@
+export { PYRAMINX_CORE_MOVES, PYRAMINX_TIPS } from "./types.js";
+export type { PyraminxMove, PyraminxState, PyraminxFaceMove, PyraminxTipMove, PyraminxRandomStateOptions } from "./types.js";
+export { applyPyraminxAlgorithm, applyPyraminxMove, formatPyraminxAlgorithm, invertPyraminxAlgorithm, invertPyraminxMove, parsePyraminxAlgorithm, parsePyraminxMove } from "./moves.js";
+export { clonePyraminxState, createSolvedPyraminxState, pyraminxStatesEqual, isSolvedPyraminxState } from "./state.js";
+export { permutationParity, validatePyraminxState, isAllowedRandomPyraminxState } from "./validation.js";
+export { generateRandomPyraminxState } from "./random-state.js";
+export { pyraminxScrambleGenerator, generatePyraminxScramble } from "./scrambler.js";
+export { solvePyraminx } from "./solver.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/puzzles/pyraminx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,2BAA2B,EAC5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,aAAa,EACd,MAAM,aAAa,CAAC"}

package/dist/puzzles/pyraminx/index.js

@@ -0,0 +1,7 @@
+export { PYRAMINX_CORE_MOVES, PYRAMINX_TIPS } from "./types.js";
+export { applyPyraminxAlgorithm, applyPyraminxMove, formatPyraminxAlgorithm, invertPyraminxAlgorithm, invertPyraminxMove, parsePyraminxAlgorithm, parsePyraminxMove } from "./moves.js";
+export { clonePyraminxState, createSolvedPyraminxState, pyraminxStatesEqual, isSolvedPyraminxState } from "./state.js";
+export { permutationParity, validatePyraminxState, isAllowedRandomPyraminxState } from "./validation.js";
+export { generateRandomPyraminxState } from "./random-state.js";
+export { pyraminxScrambleGenerator, generatePyraminxScramble } from "./scrambler.js";
+export { solvePyraminx } from "./solver.js";

package/dist/puzzles/pyraminx/moves.d.ts

@@ -0,0 +1,9 @@
+import type { PyraminxMove, PyraminxState } from "./types.js";
+export declare function applyPyraminxMove(state: PyraminxState, move: PyraminxMove): PyraminxState;
+export declare function applyPyraminxAlgorithm(state: PyraminxState, moves: readonly PyraminxMove[]): PyraminxState;
+export declare function invertPyraminxAlgorithm(moves: readonly PyraminxMove[]): PyraminxMove[];
+export declare function parsePyraminxAlgorithm(algorithm: string): PyraminxMove[];
+export declare function formatPyraminxAlgorithm(moves: readonly PyraminxMove[]): string;
+export declare function parsePyraminxMove(value: string): PyraminxMove;
+export declare function invertPyraminxMove(move: PyraminxMove): PyraminxMove;
+//# sourceMappingURL=moves.d.ts.map

package/dist/puzzles/pyraminx/moves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/moves.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAqC,MAAM,YAAY,CAAC;AAKjG,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,GAAG,aAAa,CA4BzF;AA8DD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,aAAa,CAE1G;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,EAAE,CAEtF;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,EAAE,CAMxE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAE9E;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAU7D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAKnE"}

package/dist/puzzles/pyraminx/moves.js

@@ -0,0 +1,117 @@
+import { PYRAMINX_CORE_MOVES, PYRAMINX_TIPS } from "./types.js";
+import { clonePyraminxState } from "./state.js";
+// Mathematical representation of Pyraminx moves
+export function applyPyraminxMove(state, move) {
+    const isInverse = move.endsWith("'");
+    const baseMove = move.replace("'", "");
+    const isTip = baseMove === baseMove.toLowerCase();
+    const next = clonePyraminxState(state);
+    if (isTip) {
+        const tipIndex = PYRAMINX_TIPS.indexOf(baseMove);
+        if (tipIndex !== -1) {
+            if (isInverse) {
+                next.tips[tipIndex] = (next.tips[tipIndex] + 2) % 3;
+            }
+            else {
+                next.tips[tipIndex] = (next.tips[tipIndex] + 1) % 3;
+            }
+        }
+        return next;
+    }
+    // Otherwise, it is a core layer move
+    const face = baseMove;
+    const turns = isInverse ? 2 : 1; // CW is 1, CCW is 2 turns CW
+    for (let step = 0; step < turns; step++) {
+        applySingleCoreMoveCW(next, face);
+    }
+    return next;
+}
+function applySingleCoreMoveCW(state, face) {
+    const centers = state.centers;
+    const perm = state.edgesPerm;
+    const orient = state.edgesOrient;
+    // Clone arrays for temporary storage
+    const prevPerm = [...perm];
+    const prevOrient = [...orient];
+    if (face === "U") {
+        // Center
+        centers[0] = (centers[0] + 1) % 3;
+        // Edges cycle: 0 -> 1 -> 2 -> 0 (UL -> UR -> UB -> UL)
+        // No orientation flips for U
+        perm[1] = prevPerm[0];
+        perm[2] = prevPerm[1];
+        perm[0] = prevPerm[2];
+        orient[1] = prevOrient[0];
+        orient[2] = prevOrient[1];
+        orient[0] = prevOrient[2];
+    }
+    else if (face === "L") {
+        // Center
+        centers[1] = (centers[1] + 1) % 3;
+        // Edges cycle: 0 -> 4 -> 3 -> 0 (UL -> LB -> LR -> UL)
+        // Flips: UL(0) flips, LB(4) flips, LR(3) does not flip
+        perm[4] = prevPerm[0];
+        perm[3] = prevPerm[4];
+        perm[0] = prevPerm[3];
+        orient[4] = (prevOrient[0] + 1) % 2;
+        orient[3] = (prevOrient[4] + 1) % 2;
+        orient[0] = prevOrient[3];
+    }
+    else if (face === "R") {
+        // Center
+        centers[2] = (centers[2] + 1) % 3;
+        // Edges cycle: 1 -> 3 -> 5 -> 1 (UR -> LR -> RB -> UR)
+        // Flips: UR(1) flips, LR(3) flips, RB(5) does not flip
+        perm[3] = prevPerm[1];
+        perm[5] = prevPerm[3];
+        perm[1] = prevPerm[5];
+        orient[3] = (prevOrient[1] + 1) % 2;
+        orient[5] = (prevOrient[3] + 1) % 2;
+        orient[1] = prevOrient[5];
+    }
+    else if (face === "B") {
+        // Center
+        centers[3] = (centers[3] + 1) % 3;
+        // Edges cycle: 2 -> 5 -> 4 -> 2 (UB -> RB -> LB -> UB)
+        // Flips: UB(2) flips, RB(5) flips, LB(4) does not flip
+        perm[5] = prevPerm[2];
+        perm[4] = prevPerm[5];
+        perm[2] = prevPerm[4];
+        orient[5] = (prevOrient[2] + 1) % 2;
+        orient[4] = (prevOrient[5] + 1) % 2;
+        orient[2] = prevOrient[4];
+    }
+}
+export function applyPyraminxAlgorithm(state, moves) {
+    return moves.reduce((current, move) => applyPyraminxMove(current, move), state);
+}
+export function invertPyraminxAlgorithm(moves) {
+    return [...moves].reverse().map(invertPyraminxMove);
+}
+export function parsePyraminxAlgorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed.split(/\s+/).map(parsePyraminxMove);
+}
+export function formatPyraminxAlgorithm(moves) {
+    return moves.join(" ");
+}
+export function parsePyraminxMove(value) {
+    const baseMove = value.replace("'", "");
+    const isInverse = value.endsWith("'") || value.endsWith(""); // wait, standard validation
+    if (PYRAMINX_CORE_MOVES.includes(value) || PYRAMINX_TIPS.map(t => `${t}'`).includes(value) || PYRAMINX_TIPS.includes(value)) {
+        return value;
+    }
+    if (PYRAMINX_CORE_MOVES.map(m => `${m}'`).includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid Pyraminx move: ${value}`);
+}
+export function invertPyraminxMove(move) {
+    if (move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return `${move}'`;
+}

package/dist/puzzles/pyraminx/random-state.d.ts

@@ -0,0 +1,3 @@
+import type { PyraminxRandomStateOptions, PyraminxState } from "./types.js";
+export declare function generateRandomPyraminxState(options?: PyraminxRandomStateOptions): PyraminxState;
+//# sourceMappingURL=random-state.d.ts.map

package/dist/puzzles/pyraminx/random-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG5E,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAYnG"}

package/dist/puzzles/pyraminx/random-state.js

@@ -0,0 +1,53 @@
+import { createRandomSource } from "../../random/index.js";
+import { isAllowedRandomPyraminxState, permutationParity } from "./validation.js";
+export function generateRandomPyraminxState(options = {}) {
+    const random = createRandomSource(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || isAllowedRandomPyraminxState(state)) {
+            return state;
+        }
+    }
+    throw new Error("Unable to generate a non-trivial random Pyraminx state.");
+}
+function createLegalRandomState(random) {
+    // 4 random centers
+    const centers = Array.from({ length: 4 }, () => random.nextInt(3));
+    // 4 random tips
+    const tips = Array.from({ length: 4 }, () => random.nextInt(3));
+    // 6 edges permutation
+    const edgesPerm = shuffledRange(6, random);
+    // Ensure even parity
+    if (permutationParity(edgesPerm) !== 0) {
+        // Swap the first two elements to flip parity
+        const temp = edgesPerm[0];
+        edgesPerm[0] = edgesPerm[1];
+        edgesPerm[1] = temp;
+    }
+    // 6 edges orientation (sum must be even)
+    const edgesOrient = Array(6).fill(0);
+    let sumOrient = 0;
+    for (let i = 0; i < 5; i++) {
+        const val = random.nextInt(2);
+        edgesOrient[i] = val;
+        sumOrient += val;
+    }
+    edgesOrient[5] = sumOrient % 2 === 0 ? 0 : 1;
+    return {
+        centers,
+        edgesPerm,
+        edgesOrient,
+        tips
+    };
+}
+function shuffledRange(length, random) {
+    const values = Array.from({ length }, (_, index) => index);
+    for (let index = values.length - 1; index > 0; index -= 1) {
+        const swapIndex = random.nextInt(index + 1);
+        const temporary = values[index];
+        values[index] = values[swapIndex];
+        values[swapIndex] = temporary;
+    }
+    return values;
+}

package/dist/puzzles/pyraminx/scrambler.d.ts

@@ -0,0 +1,6 @@
+import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
+export declare const pyraminxScrambleGenerator: ScrambleGenerator;
+export declare function generatePyraminxScramble(options?: ScrambleOptions & {
+    skipValidation?: boolean;
+}): Promise<ScrambleResult>;
+//# sourceMappingURL=scrambler.d.ts.map

package/dist/puzzles/pyraminx/scrambler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAO9F,eAAO,MAAM,yBAAyB,EAAE,iBAYvC,CAAC;AAEF,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CAyCzB"}

package/dist/puzzles/pyraminx/scrambler.js

@@ -0,0 +1,56 @@
+import { generateRandomPyraminxState } from "./random-state.js";
+import { createSolvedPyraminxState } from "./state.js";
+import { applyPyraminxAlgorithm, invertPyraminxAlgorithm } from "./moves.js";
+import { solvePyraminx } from "./solver.js";
+export const pyraminxScrambleGenerator = {
+    info: {
+        eventId: "pyrso",
+        name: "Pyraminx",
+        puzzle: "pyraminx",
+        quality: "random-state",
+        generator: "pyraminx-ida-star",
+        description: "Random-state Pyraminx scramble generated by an optimal bidirectional BFS solver."
+    },
+    generate(options = {}) {
+        return generatePyraminxScramble(options);
+    }
+};
+export async function generatePyraminxScramble(options = {}) {
+    const state = generateRandomPyraminxState(options);
+    // Solve the core edges and centers
+    const solution = solvePyraminx(state);
+    const scrambleMoves = invertPyraminxAlgorithm(solution);
+    // Append tips to scrambleMoves
+    const finalMoves = [...scrambleMoves];
+    const tipsNotation = ["u", "l", "r", "b"];
+    for (let i = 0; i < 4; i++) {
+        const tipVal = state.tips[i];
+        if (tipVal === 1) {
+            finalMoves.push(tipsNotation[i]);
+        }
+        else if (tipVal === 2) {
+            finalMoves.push(`${tipsNotation[i]}'`);
+        }
+    }
+    if (!options.skipValidation) {
+        const scrambledState = applyPyraminxAlgorithm(createSolvedPyraminxState(), finalMoves);
+        if (scrambledState.edgesPerm.toString() !== state.edgesPerm.toString() ||
+            scrambledState.edgesOrient.toString() !== state.edgesOrient.toString() ||
+            scrambledState.centers.toString() !== state.centers.toString() ||
+            scrambledState.tips.toString() !== state.tips.toString()) {
+            throw new Error("Generated Pyraminx scramble does not reproduce the target random state.");
+        }
+    }
+    return {
+        eventId: "pyrso",
+        scramble: finalMoves.join(" "),
+        moves: finalMoves,
+        quality: "random-state",
+        generator: "pyraminx-ida-star",
+        metadata: {
+            state,
+            solutionMoves: solution,
+            solutionDepth: solution.length
+        }
+    };
+}

package/dist/puzzles/pyraminx/solver.d.ts

@@ -0,0 +1,10 @@
+import type { PyraminxState, PyraminxMove } from "./types.js";
+export declare function getPermutationIndex(perm: readonly number[]): number;
+export declare function getPermutationFromIndex(index: number, n: number): number[];
+export declare function getOrientationIndex(orient: readonly number[]): number;
+export declare function getOrientationFromIndex(index: number): number[];
+export declare function getCentersIndex(centers: readonly number[]): number;
+export declare function getCentersFromIndex(index: number): number[];
+export declare function getStateIndex(state: PyraminxState): number;
+export declare function solvePyraminx(state: PyraminxState): PyraminxMove[];
+//# sourceMappingURL=solver.d.ts.map

package/dist/puzzles/pyraminx/solver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/solver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAS9D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWnE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAY1E;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMrE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAY/D;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAElE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ3D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAM1D;AAKD,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,EAAE,CA8DlE"}