@cubingcenter/scrambler 0.2.0 → 0.3.0

package/dist/puzzles/index.d.ts

@@ -7,4 +7,5 @@ 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";
+export * as skewb from "./skewb/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/puzzles/index.ts"],"names":[],"mappings":"AAuBA,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;AAC1C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC"}

package/dist/puzzles/index.js

@@ -8,6 +8,7 @@ import { cube6ScrambleGenerator } from "./cube6x6/index.js";
 import { cube7ScrambleGenerator } from "./cube7x7/index.js";
 import { pyraminxScrambleGenerator } from "./pyraminx/index.js";
 import { clockScrambleGenerator } from "./clock/index.js";
+import { skewbScrambleGenerator } from "./skewb/index.js";
 registerScrambleGenerator(cube2ScrambleGenerator);
 registerScrambleGenerator(cube3ScrambleGenerator);
 registerScrambleGenerator(cube4ScrambleGenerator);
@@ -17,6 +18,7 @@ registerScrambleGenerator(cube6ScrambleGenerator);
 registerScrambleGenerator(cube7ScrambleGenerator);
 registerScrambleGenerator(pyraminxScrambleGenerator);
 registerScrambleGenerator(clockScrambleGenerator);
+registerScrambleGenerator(skewbScrambleGenerator);
 export * as cube2 from "./cube2/index.js";
 export * as cube3 from "./cube3/index.js";
 export * as cube4 from "./cube4/index.js";
@@ -26,3 +28,4 @@ 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";
+export * as skewb from "./skewb/index.js";

package/dist/puzzles/pyraminx/scrambler.js

@@ -5,7 +5,7 @@ import { solvePyraminx } from "./solver.js";
 import { formatPyraminxFacelets, toPyraminxFacelets } from "./facelets.js";
 export const pyraminxScrambleGenerator = {
     info: {
-        eventId: "pyrso",
+        eventId: "pyra",
         name: "Pyraminx",
         puzzle: "pyraminx",
         quality: "random-state",
@@ -46,7 +46,7 @@ export async function generatePyraminxScramble(options = {}) {
     }
     const facelets = toPyraminxFacelets(state);
     return {
-        eventId: "pyrso",
+        eventId: "pyra",
         scramble: finalMoves.join(" "),
         moves: finalMoves,
         quality: "random-state",

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

@@ -0,0 +1,6 @@
+import type { SkewbFacelets, SkewbState } from "./types.js";
+export declare function createSolvedSkewbFacelets(): SkewbFacelets;
+export declare function toSkewbFacelets(state: SkewbState): SkewbFacelets;
+export declare function formatSkewbFacelets(facelets: SkewbFacelets): string;
+export declare function getSkewbFaceOrder(): readonly string[];
+//# sourceMappingURL=facelets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAgC5D,wBAAgB,yBAAyB,IAAI,aAAa,CASzD;AAaD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAsBhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAErD"}

package/dist/puzzles/skewb/facelets.js

@@ -0,0 +1,71 @@
+// Facelets model matching cubingcenter-viz/src/puzzles/skewb.ts
+// Each face has 5 stickers: 0=center, 1=TL,2=TR,3=BL,4=BR (net layout)
+const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+// Canonical sticker faces per corner position: [UD sticker, RL sticker, FB sticker]
+const CORNER_STICKERS = [
+    ["U", "R", "F"],
+    ["U", "L", "F"],
+    ["U", "R", "B"],
+    ["U", "L", "B"],
+    ["D", "R", "F"],
+    ["D", "L", "F"],
+    ["D", "R", "B"],
+    ["D", "L", "B"],
+];
+// Facelet index of each corner position on each of its 3 faces, aligned with CORNER_STICKERS order.
+const CORNER_SLOTS = [
+    [["U", 4], ["R", 1], ["F", 2]],
+    [["U", 3], ["L", 2], ["F", 1]],
+    [["U", 2], ["R", 2], ["B", 1]],
+    [["U", 1], ["L", 1], ["B", 2]],
+    [["D", 2], ["R", 3], ["F", 4]],
+    [["D", 1], ["L", 4], ["F", 3]],
+    [["D", 4], ["R", 4], ["B", 3]],
+    [["D", 3], ["L", 3], ["B", 4]],
+];
+export function createSolvedSkewbFacelets() {
+    return {
+        U: Array.from({ length: 5 }, () => "U"),
+        R: Array.from({ length: 5 }, () => "R"),
+        F: Array.from({ length: 5 }, () => "F"),
+        D: Array.from({ length: 5 }, () => "D"),
+        L: Array.from({ length: 5 }, () => "L"),
+        B: Array.from({ length: 5 }, () => "B"),
+    };
+}
+function createEmptySkewbFacelets() {
+    return {
+        U: Array(5).fill("?"),
+        R: Array(5).fill("?"),
+        F: Array(5).fill("?"),
+        D: Array(5).fill("?"),
+        L: Array(5).fill("?"),
+        B: Array(5).fill("?"),
+    };
+}
+export function toSkewbFacelets(state) {
+    const facelets = createEmptySkewbFacelets();
+    // centers
+    for (let face = 0; face < 6; face++) {
+        const targetFace = FACE_ORDER[face];
+        facelets[targetFace][0] = FACE_ORDER[state.centers[face]];
+    }
+    // corners
+    for (let pos = 0; pos < 8; pos++) {
+        const piece = state.corners.permutation[pos];
+        const ori = state.corners.orientation[pos];
+        const slots = CORNER_SLOTS[pos];
+        const stickers = CORNER_STICKERS[piece];
+        for (let i = 0; i < 3; i++) {
+            const [face, idx] = slots[i];
+            facelets[face][idx] = stickers[(i + 3 - ori) % 3];
+        }
+    }
+    return facelets;
+}
+export function formatSkewbFacelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+export function getSkewbFaceOrder() {
+    return FACE_ORDER;
+}

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

@@ -0,0 +1,10 @@
+export { SKEWB_MOVES, SKEWB_FACES } from "./types.js";
+export type { SkewbMove, SkewbState, SkewbFaceMove, SkewbRandomStateOptions, SkewbFacelets } from "./types.js";
+export { applySkewbAlgorithm, applySkewbMove, formatSkewbAlgorithm, invertSkewbAlgorithm, invertSkewbMove, parseSkewbAlgorithm, parseSkewbMove, } from "./moves.js";
+export { cloneSkewbState, createSolvedSkewbState, isSolvedSkewbState, skewbStatesEqual, } from "./state.js";
+export { permutationParity, validateSkewbState, isAllowedRandomSkewbState, isOneMoveFromSolvedSkewbState } from "./validation.js";
+export { generateRandomSkewbState } from "./random-state.js";
+export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
+export { solveSkewb, getStateIndex, getStateFromIndex } from "./solver.js";
+export { generateSkewbScramble, skewbScrambleGenerator } from "./scrambler.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC/G,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAC;AAClI,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/puzzles/skewb/index.js

@@ -0,0 +1,8 @@
+export { SKEWB_MOVES, SKEWB_FACES } from "./types.js";
+export { applySkewbAlgorithm, applySkewbMove, formatSkewbAlgorithm, invertSkewbAlgorithm, invertSkewbMove, parseSkewbAlgorithm, parseSkewbMove, } from "./moves.js";
+export { cloneSkewbState, createSolvedSkewbState, isSolvedSkewbState, skewbStatesEqual, } from "./state.js";
+export { permutationParity, validateSkewbState, isAllowedRandomSkewbState, isOneMoveFromSolvedSkewbState } from "./validation.js";
+export { generateRandomSkewbState } from "./random-state.js";
+export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
+export { solveSkewb, getStateIndex, getStateFromIndex } from "./solver.js";
+export { generateSkewbScramble, skewbScrambleGenerator } from "./scrambler.js";

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

@@ -0,0 +1,19 @@
+import type { SkewbMove, SkewbState } from "./types.js";
+interface MoveTable {
+    corners: {
+        permutation: readonly number[];
+        orientation: readonly number[];
+    };
+    centers: readonly number[];
+}
+declare const MOVE_TABLES: Record<string, MoveTable>;
+export declare function applySkewbMove(state: SkewbState, move: SkewbMove): SkewbState;
+export declare function applySkewbAlgorithm(state: SkewbState, moves: readonly SkewbMove[]): SkewbState;
+export declare function invertSkewbMove(move: SkewbMove): SkewbMove;
+export declare function invertSkewbAlgorithm(moves: readonly SkewbMove[]): SkewbMove[];
+export declare function parseSkewbMove(value: string): SkewbMove;
+export declare function parseSkewbAlgorithm(algorithm: string): SkewbMove[];
+export declare function formatSkewbAlgorithm(moves: readonly SkewbMove[]): string;
+export declare function getAllSkewbMovesForTables(): readonly string[];
+export { MOVE_TABLES };
+//# sourceMappingURL=moves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/moves.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMxD,UAAU,SAAS;IACjB,OAAO,EAAE;QAAE,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;IAC5E,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,QAAA,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAyB1C,CAAC;AAkBF,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAS7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CAE9F;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAG1D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAGvD;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAIlE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAGD,wBAAgB,yBAAyB,IAAI,SAAS,MAAM,EAAE,CAE7D;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/puzzles/skewb/moves.js

@@ -0,0 +1,84 @@
+import { SKEWB_MOVES } from "./types.js";
+import { cloneSkewbState } from "./state.js";
+const MOVE_TABLES = {
+    F: {
+        corners: { permutation: [0, 4, 1, 3, 2, 5, 6, 7], orientation: [1, 1, 1, 0, 1, 0, 0, 0] },
+        centers: [2, 0, 1, 3, 4, 5],
+    },
+    D: {
+        corners: { permutation: [5, 1, 2, 3, 4, 6, 0, 7], orientation: [2, 0, 0, 0, 2, 2, 2, 0] },
+        centers: [0, 2, 3, 1, 4, 5],
+    },
+    U: {
+        corners: { permutation: [0, 2, 7, 3, 4, 5, 6, 1], orientation: [0, 1, 1, 1, 0, 0, 0, 1] },
+        centers: [5, 1, 2, 3, 0, 4],
+    },
+    R: {
+        corners: { permutation: [0, 1, 4, 3, 7, 5, 6, 2], orientation: [0, 0, 1, 0, 1, 0, 1, 1] },
+        centers: [0, 3, 2, 5, 4, 1],
+    },
+    L: {
+        corners: { permutation: [0, 7, 2, 3, 1, 5, 6, 4], orientation: [0, 1, 0, 0, 1, 1, 0, 1] },
+        centers: [0, 1, 4, 2, 3, 5],
+    },
+    B: {
+        corners: { permutation: [0, 1, 2, 6, 4, 3, 5, 7], orientation: [0, 0, 0, 2, 0, 2, 2, 2] },
+        centers: [0, 1, 2, 4, 5, 3],
+    },
+};
+function applyFaceMove(state, table) {
+    const perm = state.corners.permutation;
+    const orient = state.corners.orientation;
+    const centers = state.centers;
+    const newPerm = table.corners.permutation.map((src) => perm[src]);
+    const newOrient = table.corners.permutation.map((src, tgt) => (orient[src] + table.corners.orientation[tgt]) % 3);
+    const newCenters = table.centers.map((src) => centers[src]);
+    for (let i = 0; i < perm.length; i++)
+        perm[i] = newPerm[i];
+    for (let i = 0; i < orient.length; i++)
+        orient[i] = newOrient[i];
+    for (let i = 0; i < centers.length; i++)
+        centers[i] = newCenters[i];
+}
+export function applySkewbMove(state, move) {
+    const face = move[0].toUpperCase();
+    const suffix = move.slice(1);
+    const table = MOVE_TABLES[face];
+    if (!table)
+        throw new Error(`Unknown Skewb move: ${move}`);
+    const repetitions = suffix === "'" || suffix === "2" ? 2 : 1;
+    const next = cloneSkewbState(state);
+    for (let i = 0; i < repetitions; i++)
+        applyFaceMove(next, table);
+    return next;
+}
+export function applySkewbAlgorithm(state, moves) {
+    return moves.reduce((current, move) => applySkewbMove(current, move), state);
+}
+export function invertSkewbMove(move) {
+    if (move.endsWith("'"))
+        return move.slice(0, -1);
+    return `${move}'`;
+}
+export function invertSkewbAlgorithm(moves) {
+    return [...moves].reverse().map(invertSkewbMove);
+}
+export function parseSkewbMove(value) {
+    if (SKEWB_MOVES.includes(value))
+        return value;
+    throw new Error(`Invalid Skewb move: ${value}`);
+}
+export function parseSkewbAlgorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0)
+        return [];
+    return trimmed.split(/\s+/).map(parseSkewbMove);
+}
+export function formatSkewbAlgorithm(moves) {
+    return moves.join(" ");
+}
+// For internal use by solver (needs all 6 faces for table generation)
+export function getAllSkewbMovesForTables() {
+    return ["R", "U", "L", "B", "F", "D"].flatMap((f) => [f, `${f}'`]);
+}
+export { MOVE_TABLES };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMtE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAS1F"}

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

@@ -0,0 +1,27 @@
+import { createRandomSource } from "../../random/index.js";
+import { isAllowedRandomSkewbState } from "./validation.js";
+import { applySkewbMove } from "./moves.js";
+import { createSolvedSkewbState } from "./state.js";
+import { SKEWB_MOVES } from "./types.js";
+export function generateRandomSkewbState(options = {}) {
+    const random = createRandomSource(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || isAllowedRandomSkewbState(state))
+            return state;
+    }
+    throw new Error("Unable to generate a non-trivial random Skewb state.");
+}
+function createLegalRandomState(random) {
+    // Generate a random reachable Skewb state via random walk from solved.
+    // Skewb has 3,149,280 reachable states with WCA moves (fixed corner).
+    // A walk of 30+ moves is sufficient to approach uniform distribution.
+    let state = createSolvedSkewbState();
+    const walkLength = 30 + random.nextInt(5); // 30-34 moves
+    for (let i = 0; i < walkLength; i++) {
+        const move = random.choice([...SKEWB_MOVES]);
+        state = applySkewbMove(state, move);
+    }
+    return state;
+}

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

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

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

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

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"}