@cubingcenter/scrambler 0.1.0 → 0.3.0

package/dist/puzzles/skewb/scrambler.js

@@ -0,0 +1,52 @@
+import { generateRandomSkewbState } from "./random-state.js";
+import { createSolvedSkewbState, isSolvedSkewbState, skewbStatesEqual } from "./state.js";
+import { applySkewbAlgorithm, formatSkewbAlgorithm, invertSkewbAlgorithm } from "./moves.js";
+import { solveSkewb } from "./solver.js";
+import { formatSkewbFacelets, toSkewbFacelets } from "./facelets.js";
+export const skewbScrambleGenerator = {
+    info: {
+        eventId: "skewb",
+        name: "Skewb",
+        puzzle: "skewb",
+        quality: "random-state",
+        generator: "skewb-bfs",
+        description: "Random-state Skewb scramble generated by an optimal bidirectional BFS solver.",
+    },
+    generate(options = {}) {
+        return generateSkewbScramble(options);
+    },
+};
+export async function generateSkewbScramble(options = {}) {
+    const state = generateRandomSkewbState(options);
+    const solution = solveSkewb(state);
+    const scrambleMoves = invertSkewbAlgorithm(solution);
+    if (!options.skipValidation) {
+        const scrambledState = applySkewbAlgorithm(createSolvedSkewbState(), scrambleMoves);
+        if (!skewbStatesEqual(scrambledState, state)) {
+            throw new Error("Generated Skewb scramble does not reproduce the target random state.");
+        }
+        if (!isSolvedSkewbState(applySkewbAlgorithm(state, solution))) {
+            throw new Error("Generated Skewb solution does not solve the target random state.");
+        }
+        if (scrambleMoves.length < 2)
+            throw new Error("Generated Skewb scramble is too short.");
+    }
+    const facelets = toSkewbFacelets(state);
+    const result = {
+        eventId: "skewb",
+        scramble: formatSkewbAlgorithm(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "skewb-bfs",
+        metadata: {
+            state,
+            facelets,
+            faceletString: formatSkewbFacelets(facelets),
+            solutionMoves: solution,
+            solutionDepth: solution.length,
+        },
+    };
+    if (options.seed !== undefined)
+        result.seed = options.seed;
+    return result;
+}

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

@@ -0,0 +1,11 @@
+import type { SkewbMove, SkewbState } 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 getCenterIndex(centers: readonly number[]): number;
+export declare function getCenterFromIndex(index: number): number[];
+export declare function getStateIndex(state: SkewbState): number;
+export declare function getStateFromIndex(index: number): SkewbState;
+export declare function solveSkewb(state: SkewbState): SkewbMove[];
+//# sourceMappingURL=solver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/solver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMxD,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,CAOrE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CASjE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAE1D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAOvD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAY3D;AAID,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,CA+CzD"}

package/dist/puzzles/skewb/solver.js

@@ -0,0 +1,149 @@
+import { applySkewbMove } from "./moves.js";
+import { createSolvedSkewbState } from "./state.js";
+const FACT = [1, 1, 2, 6, 24, 120, 720, 5040, 40320];
+export function getPermutationIndex(perm) {
+    // perm length 8, but pos0 is always 0 for WCA reachable states.
+    // We encode full 8-perm via Lehmer code (0..40319), but for fixed corner it will be in subset.
+    let index = 0;
+    const n = perm.length;
+    for (let i = 0; i < n; i++) {
+        let count = 0;
+        for (let j = i + 1; j < n; j++)
+            if (perm[j] < perm[i])
+                count++;
+        index += count * FACT[n - 1 - i];
+    }
+    return index;
+}
+export function getPermutationFromIndex(index, n) {
+    const perm = Array(n).fill(0);
+    const temp = Array.from({ length: n }, (_, i) => i);
+    let val = index;
+    for (let i = 0; i < n; i++) {
+        const f = FACT[n - 1 - i];
+        const choice = Math.floor(val / f);
+        val %= f;
+        perm[i] = temp[choice];
+        temp.splice(choice, 1);
+    }
+    return perm;
+}
+export function getOrientationIndex(orient) {
+    // orient length 8, index 0 is fixed 0, encode remaining 7 base3
+    let index = 0;
+    for (let i = 7; i >= 1; i--) {
+        index = index * 3 + orient[i];
+    }
+    return index;
+}
+export function getOrientationFromIndex(index) {
+    const orient = Array(8).fill(0);
+    orient[0] = 0;
+    let val = index;
+    for (let i = 1; i < 8; i++) {
+        orient[i] = val % 3;
+        val = Math.floor(val / 3);
+    }
+    return orient;
+}
+export function getCenterIndex(centers) {
+    let index = 0;
+    const n = centers.length;
+    for (let i = 0; i < n; i++) {
+        let count = 0;
+        for (let j = i + 1; j < n; j++)
+            if (centers[j] < centers[i])
+                count++;
+        index += count * FACT[n - 1 - i];
+    }
+    return index;
+}
+export function getCenterFromIndex(index) {
+    return getPermutationFromIndex(index, 6);
+}
+export function getStateIndex(state) {
+    const p = getPermutationIndex(state.corners.permutation);
+    const c = getCenterIndex(state.centers);
+    const o = getOrientationIndex(state.corners.orientation);
+    // p in 0..40319, c in 0..719, o in 0..2186
+    // Combine: ((p * 720 + c) * 2187 + o) -> up to 63B fits in JS number (53-bit)
+    return ((p * 720 + c) * 2187 + o);
+}
+export function getStateFromIndex(index) {
+    const o = index % 2187;
+    let val = Math.floor(index / 2187);
+    const c = val % 720;
+    const p = Math.floor(val / 720);
+    return {
+        corners: {
+            permutation: getPermutationFromIndex(p, 8),
+            orientation: getOrientationFromIndex(o),
+        },
+        centers: getCenterFromIndex(c),
+    };
+}
+const MOVES = ["R", "R'", "U", "U'", "L", "L'", "B", "B'"];
+export function solveSkewb(state) {
+    const startIdx = getStateIndex(state);
+    const solvedIdx = getStateIndex(createSolvedSkewbState());
+    if (startIdx === solvedIdx)
+        return [];
+    const forwardMap = new Map();
+    const backwardMap = new Map();
+    const forwardQueue = [startIdx];
+    const backwardQueue = [solvedIdx];
+    forwardMap.set(startIdx, { move: "", parent: -1 });
+    backwardMap.set(solvedIdx, { move: "", parent: -1 });
+    while (forwardQueue.length > 0 && backwardQueue.length > 0) {
+        const fSize = forwardQueue.length;
+        for (let i = 0; i < Math.min(fSize, 1000); i++) {
+            const currIdx = forwardQueue.shift();
+            const currState = getStateFromIndex(currIdx);
+            for (const move of MOVES) {
+                const nextState = applySkewbMove(currState, move);
+                const nextIdx = getStateIndex(nextState);
+                if (!forwardMap.has(nextIdx)) {
+                    forwardMap.set(nextIdx, { move, parent: currIdx });
+                    if (backwardMap.has(nextIdx))
+                        return reconstructPath(nextIdx, forwardMap, backwardMap);
+                    forwardQueue.push(nextIdx);
+                }
+            }
+        }
+        const bSize = backwardQueue.length;
+        for (let i = 0; i < Math.min(bSize, 1000); i++) {
+            const currIdx = backwardQueue.shift();
+            const currState = getStateFromIndex(currIdx);
+            for (const move of MOVES) {
+                const nextState = applySkewbMove(currState, move);
+                const nextIdx = getStateIndex(nextState);
+                if (!backwardMap.has(nextIdx)) {
+                    const invMove = move.endsWith("'") ? move.slice(0, -1) : `${move}'`;
+                    backwardMap.set(nextIdx, { move: invMove, parent: currIdx });
+                    if (forwardMap.has(nextIdx))
+                        return reconstructPath(nextIdx, forwardMap, backwardMap);
+                    backwardQueue.push(nextIdx);
+                }
+            }
+        }
+    }
+    throw new Error("Skewb state is unsolvable");
+}
+function reconstructPath(meetingIdx, forwardMap, backwardMap) {
+    const path = [];
+    let curr = meetingIdx;
+    while (curr !== -1) {
+        const edge = forwardMap.get(curr);
+        if (edge.parent !== -1)
+            path.unshift(edge.move);
+        curr = edge.parent;
+    }
+    curr = meetingIdx;
+    while (curr !== -1) {
+        const edge = backwardMap.get(curr);
+        if (edge.parent !== -1)
+            path.push(edge.move);
+        curr = edge.parent;
+    }
+    return path;
+}

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

@@ -0,0 +1,6 @@
+import type { SkewbState } from "./types.js";
+export declare function createSolvedSkewbState(): SkewbState;
+export declare function cloneSkewbState(state: SkewbState): SkewbState;
+export declare function skewbStatesEqual(left: SkewbState, right: SkewbState): boolean;
+export declare function isSolvedSkewbState(state: SkewbState): boolean;
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAQnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAQ7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAM7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAM7D"}

package/dist/puzzles/skewb/state.js

@@ -0,0 +1,31 @@
+export function createSolvedSkewbState() {
+    return {
+        corners: {
+            permutation: [0, 1, 2, 3, 4, 5, 6, 7],
+            orientation: [0, 0, 0, 0, 0, 0, 0, 0],
+        },
+        centers: [0, 1, 2, 3, 4, 5],
+    };
+}
+export function cloneSkewbState(state) {
+    return {
+        corners: {
+            permutation: [...state.corners.permutation],
+            orientation: [...state.corners.orientation],
+        },
+        centers: [...state.centers],
+    };
+}
+export function skewbStatesEqual(left, right) {
+    return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
+        arraysEqual(left.corners.orientation, right.corners.orientation) &&
+        arraysEqual(left.centers, right.centers));
+}
+export function isSolvedSkewbState(state) {
+    return (state.corners.permutation.every((value, index) => value === index) &&
+        state.corners.orientation.every((value) => value === 0) &&
+        state.centers.every((value, index) => value === index));
+}
+function arraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

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

@@ -0,0 +1,25 @@
+export declare const CORNER_COUNT = 8;
+export declare const CENTER_COUNT = 6;
+export type SkewbFace = "U" | "R" | "F" | "D" | "L" | "B";
+export type SkewbFaceMove = "R" | "U" | "L" | "B";
+export type SkewbMoveSuffix = "" | "'";
+export type SkewbMove = `${SkewbFaceMove}${SkewbMoveSuffix}`;
+export interface SkewbState {
+    corners: {
+        permutation: number[];
+        orientation: number[];
+    };
+    centers: number[];
+}
+export interface SkewbValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface SkewbRandomStateOptions {
+    seed?: string | number;
+    rejectTrivial?: boolean;
+}
+export type SkewbFacelets = Record<SkewbFace, string[]>;
+export declare const SKEWB_MOVES: readonly SkewbMove[];
+export declare const SKEWB_FACES: readonly SkewbFace[];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAClD,MAAM,MAAM,eAAe,GAAG,EAAE,GAAG,GAAG,CAAE;AACxC,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,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;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;CACzB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;AAExD,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAS3C,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAAmC,CAAC"}

package/dist/puzzles/skewb/types.js

@@ -0,0 +1,13 @@
+export const CORNER_COUNT = 8;
+export const CENTER_COUNT = 6;
+export const SKEWB_MOVES = [
+    "R",
+    "R'",
+    "U",
+    "U'",
+    "L",
+    "L'",
+    "B",
+    "B'",
+];
+export const SKEWB_FACES = ["U", "R", "F", "D", "L", "B"];

package/dist/puzzles/skewb/validation.d.ts

@@ -0,0 +1,6 @@
+import type { SkewbState, SkewbValidationResult } from "./types.js";
+export declare function validateSkewbState(state: SkewbState): SkewbValidationResult;
+export declare function isOneMoveFromSolvedSkewbState(state: SkewbState): boolean;
+export declare function isAllowedRandomSkewbState(state: SkewbState): boolean;
+export declare function permutationParity(permutation: readonly number[]): 0 | 1;
+//# sourceMappingURL=validation.d.ts.map

package/dist/puzzles/skewb/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAwB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAGxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAEpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAQvE"}

package/dist/puzzles/skewb/validation.js

@@ -0,0 +1,69 @@
+import { SKEWB_MOVES, CENTER_COUNT, CORNER_COUNT } from "./types.js";
+import { applySkewbMove } from "./moves.js";
+import { createSolvedSkewbState, isSolvedSkewbState, skewbStatesEqual } from "./state.js";
+export function validateSkewbState(state) {
+    const errors = [];
+    // corners permutation
+    errors.push(...validatePermutation("corner", state.corners.permutation, CORNER_COUNT));
+    // corners orientation
+    errors.push(...validateOrientations("corner", state.corners.orientation, CORNER_COUNT, 3));
+    // centers
+    errors.push(...validatePermutation("center", state.centers, CENTER_COUNT));
+    // parity checks - both perms must be even (as observed in BFS)
+    if (errors.length === 0) {
+        if (permutationParity(state.corners.permutation) !== 0) {
+            errors.push("Corner permutation parity must be even.");
+        }
+        if (permutationParity(state.centers) !== 0) {
+            errors.push("Center permutation parity must be even.");
+        }
+        // Check fixed corner invariant: corner 0 must be at position 0 with orientation 0 for WCA fixed model
+        // But we allow all states for validation; this is enforced by solver's reachable set, not validation.
+        // So we don't enforce fixed corner here; any even parity state is considered valid.
+    }
+    return { valid: errors.length === 0, errors };
+}
+export function isOneMoveFromSolvedSkewbState(state) {
+    const solved = createSolvedSkewbState();
+    return SKEWB_MOVES.some((move) => skewbStatesEqual(applySkewbMove(solved, move), state));
+}
+export function isAllowedRandomSkewbState(state) {
+    return validateSkewbState(state).valid && !isSolvedSkewbState(state) && !isOneMoveFromSolvedSkewbState(state);
+}
+export function permutationParity(permutation) {
+    let inversions = 0;
+    for (let left = 0; left < permutation.length; left++) {
+        for (let right = left + 1; right < permutation.length; right++) {
+            if (permutation[left] > permutation[right])
+                inversions++;
+        }
+    }
+    return (inversions % 2);
+}
+function validatePermutation(label, permutation, length) {
+    const errors = [];
+    const seen = new Set();
+    if (permutation.length !== length)
+        errors.push(`${label} permutation must contain ${length} values.`);
+    for (const value of permutation) {
+        if (!Number.isInteger(value) || value < 0 || value >= length) {
+            errors.push(`${label} permutation contains out-of-range value: ${value}.`);
+            continue;
+        }
+        if (seen.has(value))
+            errors.push(`${label} permutation contains duplicate value: ${value}.`);
+        seen.add(value);
+    }
+    return errors;
+}
+function validateOrientations(label, orientations, length, modulo) {
+    const errors = [];
+    if (orientations.length !== length)
+        errors.push(`${label} orientation must contain ${length} values.`);
+    for (const value of orientations) {
+        if (!Number.isInteger(value) || value < 0 || value >= modulo) {
+            errors.push(`${label} orientation contains out-of-range value: ${value}.`);
+        }
+    }
+    return errors;
+}

package/dist-cjs/puzzles/cube3/scrambler.js

@@ -46,6 +46,7 @@ async function generateCube3Scramble(options = {}) {
         metadata: {
             generator: "cube3-two-phase",
             generatorVersion: "1.0.0",
+            facelets,
             faceletString: (0, facelets_js_1.formatCube3Facelets)(facelets),
             state: JSON.parse(JSON.stringify(state)),
             solutionMoves: solution.moves,

package/dist-cjs/puzzles/cube4/scrambler.js

@@ -44,9 +44,9 @@ exports.cube4ScrambleGenerator = {
         eventId: "444",
         name: "4x4x4 Cube",
         puzzle: "cube-4x4",
-        quality: "random-move",
-        generator: "cube4-random-move",
-        description: "Random-move 4x4 scramble with 40 moves."
+        quality: "random-state",
+        generator: "cubing-scramble",
+        description: "Random-state 4x4 scramble generated by cubing.js."
     },
     generate(options = {}) {
         return generateCube4Scramble(options);

package/dist-cjs/puzzles/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clock = exports.pyraminx = exports.cube7x7 = exports.cube6x6 = exports.cube5x5 = exports.megaminx = exports.cube4 = exports.cube3 = exports.cube2 = void 0;
+exports.skewb = exports.clock = exports.pyraminx = exports.cube7x7 = exports.cube6x6 = exports.cube5x5 = exports.megaminx = exports.cube4 = exports.cube3 = exports.cube2 = void 0;
 const index_js_1 = require("../core/index.js");
 const index_js_2 = require("./cube2/index.js");
 const index_js_3 = require("./cube3/index.js");
@@ -44,6 +44,7 @@ const index_js_7 = require("./cube6x6/index.js");
 const index_js_8 = require("./cube7x7/index.js");
 const index_js_9 = require("./pyraminx/index.js");
 const index_js_10 = require("./clock/index.js");
+const index_js_11 = require("./skewb/index.js");
 (0, index_js_1.registerScrambleGenerator)(index_js_2.cube2ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_3.cube3ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_4.cube4ScrambleGenerator);
@@ -53,6 +54,7 @@ const index_js_10 = require("./clock/index.js");
 (0, index_js_1.registerScrambleGenerator)(index_js_8.cube7ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_9.pyraminxScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_10.clockScrambleGenerator);
+(0, index_js_1.registerScrambleGenerator)(index_js_11.skewbScrambleGenerator);
 exports.cube2 = __importStar(require("./cube2/index.js"));
 exports.cube3 = __importStar(require("./cube3/index.js"));
 exports.cube4 = __importStar(require("./cube4/index.js"));
@@ -62,3 +64,4 @@ exports.cube6x6 = __importStar(require("./cube6x6/index.js"));
 exports.cube7x7 = __importStar(require("./cube7x7/index.js"));
 exports.pyraminx = __importStar(require("./pyraminx/index.js"));
 exports.clock = __importStar(require("./clock/index.js"));
+exports.skewb = __importStar(require("./skewb/index.js"));

package/dist-cjs/puzzles/pyraminx/facelets.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSolvedPyraminxFacelets = createSolvedPyraminxFacelets;
+exports.toPyraminxFacelets = toPyraminxFacelets;
+exports.formatPyraminxFacelets = formatPyraminxFacelets;
+exports.getPyraminxFaceOrder = getPyraminxFaceOrder;
+const FACE_ORDER = ["F", "L", "R", "D"];
+// positionId -> sticker slots (each slot = one triangle cell of the grid).
+// Positions follow the scrambler piece model (moves.ts):
+//   edges 0..5 = UL, UR, UB, LR, LB, RB
+//   centers 0..3 = U, L, R, B
+//   tips 0..3 = U, L, R, B
+//
+// The slot layout is validated against the piece model by
+// test/pyraminx-facelets.test.ts (single moves + randomized sequences).
+const EDGE_POSITION_SLOTS = [
+    [["F", 1], ["L", 7]], // 0 UL
+    [["F", 3], ["R", 5]], // 1 UR
+    [["L", 2], ["R", 2]], // 2 UB
+    [["F", 6], ["D", 2]], // 3 LR
+    [["L", 5], ["D", 5]], // 4 LB
+    [["R", 7], ["D", 7]], // 5 RB
+];
+const CENTER_POSITION_SLOTS = [
+    [["F", 2], ["L", 3], ["R", 1]], // 0 U
+    [["F", 5], ["L", 6], ["D", 1]], // 1 L
+    [["F", 7], ["R", 6], ["D", 3]], // 2 R
+    [["L", 1], ["R", 3], ["D", 6]], // 3 B
+];
+const TIP_POSITION_SLOTS = [
+    [["F", 0], ["L", 4], ["R", 0]], // 0 U
+    [["F", 4], ["D", 0], ["L", 8]], // 1 L
+    [["F", 8], ["R", 8], ["D", 4]], // 2 R
+    [["L", 0], ["D", 8], ["R", 4]], // 3 B
+];
+// pieceId -> sticker colors (canonical order aligned with the role order above)
+const EDGE_PIECE_STICKERS = [
+    ["F", "L"], // 0 UL
+    ["F", "R"], // 1 UR
+    ["L", "R"], // 2 UB
+    ["F", "D"], // 3 LR
+    ["L", "D"], // 4 LB
+    ["R", "D"], // 5 RB
+];
+const CENTER_PIECE_STICKERS = [
+    ["F", "L", "R"], // 0 U
+    ["F", "L", "D"], // 1 L
+    ["F", "R", "D"], // 2 R
+    ["L", "R", "D"], // 3 B
+];
+const TIP_PIECE_STICKERS = [
+    ["F", "L", "R"], // 0 U
+    ["F", "D", "L"], // 1 L
+    ["F", "R", "D"], // 2 R
+    ["L", "D", "R"], // 3 B
+];
+function createSolvedPyraminxFacelets() {
+    return {
+        F: Array.from({ length: 9 }, () => "F"),
+        L: Array.from({ length: 9 }, () => "L"),
+        R: Array.from({ length: 9 }, () => "R"),
+        D: Array.from({ length: 9 }, () => "D"),
+    };
+}
+function createEmptyPyraminxFacelets() {
+    return {
+        F: Array(9).fill("?"),
+        L: Array(9).fill("?"),
+        R: Array(9).fill("?"),
+        D: Array(9).fill("?"),
+    };
+}
+function placeOrientedStickers(facelets, slots, stickers, orientation) {
+    for (let index = 0; index < slots.length; index += 1) {
+        const [face, stickerIndex] = slots[index];
+        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
+        const arr = facelets[face];
+        arr[stickerIndex] = sticker;
+    }
+}
+function toPyraminxFacelets(state) {
+    const facelets = createEmptyPyraminxFacelets();
+    for (let position = 0; position < 6; position += 1) {
+        const piece = state.edgesPerm[position];
+        const orientation = state.edgesOrient[position];
+        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+    }
+    for (let position = 0; position < 4; position += 1) {
+        const orientation = state.centers[position];
+        placeOrientedStickers(facelets, CENTER_POSITION_SLOTS[position], CENTER_PIECE_STICKERS[position], orientation);
+    }
+    for (let position = 0; position < 4; position += 1) {
+        const orientation = state.tips[position];
+        placeOrientedStickers(facelets, TIP_POSITION_SLOTS[position], TIP_PIECE_STICKERS[position], orientation);
+    }
+    return facelets;
+}
+function formatPyraminxFacelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+function getPyraminxFaceOrder() {
+    return FACE_ORDER;
+}

package/dist-cjs/puzzles/pyraminx/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solvePyraminx = exports.generatePyraminxScramble = exports.pyraminxScrambleGenerator = exports.generateRandomPyraminxState = exports.isAllowedRandomPyraminxState = exports.validatePyraminxState = exports.permutationParity = exports.isSolvedPyraminxState = exports.pyraminxStatesEqual = exports.createSolvedPyraminxState = exports.clonePyraminxState = exports.parsePyraminxMove = exports.parsePyraminxAlgorithm = exports.invertPyraminxMove = exports.invertPyraminxAlgorithm = exports.formatPyraminxAlgorithm = exports.applyPyraminxMove = exports.applyPyraminxAlgorithm = exports.PYRAMINX_TIPS = exports.PYRAMINX_CORE_MOVES = void 0;
+exports.solvePyraminx = exports.toPyraminxFacelets = exports.getPyraminxFaceOrder = exports.formatPyraminxFacelets = exports.createSolvedPyraminxFacelets = exports.generatePyraminxScramble = exports.pyraminxScrambleGenerator = exports.generateRandomPyraminxState = exports.isAllowedRandomPyraminxState = exports.validatePyraminxState = exports.permutationParity = exports.isSolvedPyraminxState = exports.pyraminxStatesEqual = exports.createSolvedPyraminxState = exports.clonePyraminxState = exports.parsePyraminxMove = exports.parsePyraminxAlgorithm = exports.invertPyraminxMove = exports.invertPyraminxAlgorithm = exports.formatPyraminxAlgorithm = exports.applyPyraminxMove = exports.applyPyraminxAlgorithm = exports.PYRAMINX_TIPS = exports.PYRAMINX_CORE_MOVES = void 0;
 var types_js_1 = require("./types.js");
 Object.defineProperty(exports, "PYRAMINX_CORE_MOVES", { enumerable: true, get: function () { return types_js_1.PYRAMINX_CORE_MOVES; } });
 Object.defineProperty(exports, "PYRAMINX_TIPS", { enumerable: true, get: function () { return types_js_1.PYRAMINX_TIPS; } });
@@ -26,5 +26,10 @@ Object.defineProperty(exports, "generateRandomPyraminxState", { enumerable: true
 var scrambler_js_1 = require("./scrambler.js");
 Object.defineProperty(exports, "pyraminxScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.pyraminxScrambleGenerator; } });
 Object.defineProperty(exports, "generatePyraminxScramble", { enumerable: true, get: function () { return scrambler_js_1.generatePyraminxScramble; } });
+var facelets_js_1 = require("./facelets.js");
+Object.defineProperty(exports, "createSolvedPyraminxFacelets", { enumerable: true, get: function () { return facelets_js_1.createSolvedPyraminxFacelets; } });
+Object.defineProperty(exports, "formatPyraminxFacelets", { enumerable: true, get: function () { return facelets_js_1.formatPyraminxFacelets; } });
+Object.defineProperty(exports, "getPyraminxFaceOrder", { enumerable: true, get: function () { return facelets_js_1.getPyraminxFaceOrder; } });
+Object.defineProperty(exports, "toPyraminxFacelets", { enumerable: true, get: function () { return facelets_js_1.toPyraminxFacelets; } });
 var solver_js_1 = require("./solver.js");
 Object.defineProperty(exports, "solvePyraminx", { enumerable: true, get: function () { return solver_js_1.solvePyraminx; } });