@cubingcenter/scrambler 0.5.3 → 0.6.0

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

@@ -40,8 +40,14 @@ export interface Cube4State {
 }
 export type Cube4Sticker = "U" | "R" | "F" | "D" | "L" | "B";
 export type Cube4Facelets = Record<Cube4Face, Cube4Sticker[]>;
+export interface Cube4ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
 export interface Cube4RandomStateOptions {
     seed?: string | number;
+    /** Reject the solved state and the 36 single-move states. Defaults to true. */
+    rejectTrivial?: boolean;
 }
 /**
  * Corner numbering (same as 3x3):

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAIlC,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AAEnB,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAK1D,MAAM,MAAM,aAAa,GACrB,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GACjC,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,GAAG,aAAa,GAAG,eAAe,EAAE,CAAC;AAE7D,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAGpD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,SAAS,SAAS,EAE/C,CAAC;AAGF,eAAO,MAAM,iBAAiB,EAAE,SAAS,SAAS,EAIjD,CAAC;AAIF;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAC9B;AAED,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE7D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;AAE9D,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAIlC,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AACnB,eAAO,MAAM,CAAC,IAAI,CAAC;AAEnB,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAK1D,MAAM,MAAM,aAAa,GACrB,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GACjC,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,GAAG,aAAa,GAAG,eAAe,EAAE,CAAC;AAE7D,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAGpD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,SAAS,SAAS,EAE/C,CAAC;AAGF,eAAO,MAAM,iBAAiB,EAAE,SAAS,SAAS,EAIjD,CAAC;AAIF;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAC9B;AAED,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE7D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;AAE9D,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,+EAA+E;IAC/E,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG"}

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

@@ -0,0 +1,6 @@
+import type { Cube4State, Cube4ValidationResult } from "./types.js";
+export declare function validateCube4State(state: Cube4State): Cube4ValidationResult;
+export declare function isOneMoveFromSolvedCube4State(state: Cube4State): boolean;
+export declare function isTrivialCube4State(state: Cube4State): boolean;
+export declare function isAllowedRandomCube4State(state: Cube4State): boolean;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAKpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAoB3E;AASD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAExE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE9D;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAEpE"}

package/dist/puzzles/cube4/validation.js

@@ -0,0 +1,91 @@
+import { CENTER_COUNT, CORNER_COUNT, CUBE4_ALL_MOVES, FACE_COUNT, CENTERS_PER_FACE, WING_COUNT } from "./types.js";
+import { applyCube4Move } from "./moves.js";
+import { createSolvedCube4State, cube4StatesEqual, isSolvedCube4State } from "./state.js";
+export function validateCube4State(state) {
+    const errors = [
+        ...validatePermutation("corner", state.cp, CORNER_COUNT),
+        ...validateOrientations("corner", state.co, CORNER_COUNT, 3),
+        ...validatePermutation("wing", state.wp, WING_COUNT),
+        ...validateCenters(state.centers)
+    ];
+    if (errors.length === 0) {
+        const cornerOrientation = sum(state.co) % 3;
+        if (cornerOrientation !== 0) {
+            errors.push("Corner orientation sum must be divisible by 3.");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+// The 36 single-move states (12 base faces × 3 suffixes), precomputed once so
+// the hot random-state path checks "solved or one move from solved" with pure
+// array comparisons.
+const ONE_MOVE_FROM_SOLVED_STATES = CUBE4_ALL_MOVES.map((move) => applyCube4Move(createSolvedCube4State(), move));
+export function isOneMoveFromSolvedCube4State(state) {
+    return ONE_MOVE_FROM_SOLVED_STATES.some((candidate) => cube4StatesEqual(candidate, state));
+}
+export function isTrivialCube4State(state) {
+    return isSolvedCube4State(state) || isOneMoveFromSolvedCube4State(state);
+}
+export function isAllowedRandomCube4State(state) {
+    return validateCube4State(state).valid && !isTrivialCube4State(state);
+}
+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;
+}
+function validateCenters(centers) {
+    const errors = [];
+    if (centers.length !== CENTER_COUNT) {
+        errors.push(`centers must contain ${CENTER_COUNT} values.`);
+    }
+    const counts = new Uint8Array(FACE_COUNT);
+    for (const value of centers) {
+        if (!Number.isInteger(value) || value < 0 || value >= FACE_COUNT) {
+            errors.push(`center contains out-of-range color: ${value}.`);
+            continue;
+        }
+        counts[value] = counts[value] + 1;
+    }
+    for (let face = 0; face < FACE_COUNT; face += 1) {
+        if (counts[face] !== CENTERS_PER_FACE) {
+            errors.push(`center color ${face} must appear exactly ${CENTERS_PER_FACE} times.`);
+        }
+    }
+    return errors;
+}
+function sum(values) {
+    let total = 0;
+    for (const value of values) {
+        total += value;
+    }
+    return total;
+}

package/dist/puzzles/fto/coordinates.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Combinatorics and coordinate packing/unpacking for FTO (Face-Turning Octahedron).
+ *
+ * Implements exact bijections for:
+ *  - Even corner permutations (A_6, 360 states)
+ *  - Corner orientations (Z_2^5 with even sum, 32 states)
+ *  - Even edge permutations (A_12, 239,500,800 states)
+ *  - Center orbit arrangements (C(12,3)*C(9,3)*C(6,3) = 369,600 states per orbit)
+ */
+/**
+ * Binomial coefficient nCr = n! / (k! * (n-k)!).
+ */
+export declare function nCr(n: number, k: number): number;
+/**
+ * Compute the permutation parity (number of inversions mod 2).
+ * Returns true if odd, false if even.
+ */
+export declare function getPermutationParity(perm: readonly number[]): boolean;
+/**
+ * Pack a sorted k-subset of {0, ..., n-1} into an integer in [0, nCr(n, k) - 1].
+ * Uses standard combinatorial number system ranking: sum_{i=0}^{k-1} nCr(s_i, i + 1).
+ */
+export declare function packSubset(subset: readonly number[]): number;
+/**
+ * Unpack an integer index in [0, nCr(n, k) - 1] into a sorted k-subset.
+ */
+export declare function unpackSubset(target: number[], k: number, index: number): void;
+/**
+ * Pack an even permutation of length n into its rank in A_n: [0, n!/2 - 1].
+ */
+export declare function packEvenPerm(perm: readonly number[]): number;
+/**
+ * Unpack an integer rank in [0, n!/2 - 1] into an even permutation of length n.
+ */
+export declare function unpackEvenPerm(n: number, rank: number, target?: number[]): number[];
+/**
+ * Pack 6 corner orientations (each in {0, 1} with even sum) into [0, 31].
+ */
+export declare function packCornerOrientation(co: readonly number[]): number;
+/**
+ * Unpack an orientation rank in [0, 31] into 6 corner orientations with sum = 0 mod 2.
+ */
+export declare function unpackCornerOrientation(rank: number, target?: number[]): number[];
+/**
+ * Pack a center orbit (12 pieces, 3 of each of 4 colors) into [0, 369599].
+ * Pieces 0..2 are color 0, 3..5 are color 1, 6..8 are color 2, 9..11 are color 3.
+ */
+export declare function packCenterOrbit(centers: readonly number[]): number;
+/**
+ * Unpack a center orbit rank in [0, 369599] into 12 piece indices (0..11).
+ */
+export declare function unpackCenterOrbit(rank: number, target?: number[]): number[];
+//# sourceMappingURL=coordinates.d.ts.map

package/dist/puzzles/fto/coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinates.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/coordinates.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAeH;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAShD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAWrE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAM5D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAc7E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAoB5D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CA+BnF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMnE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAYjF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAiClE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAmD3E"}

package/dist/puzzles/fto/coordinates.js

@@ -0,0 +1,228 @@
+/**
+ * Combinatorics and coordinate packing/unpacking for FTO (Face-Turning Octahedron).
+ *
+ * Implements exact bijections for:
+ *  - Even corner permutations (A_6, 360 states)
+ *  - Corner orientations (Z_2^5 with even sum, 32 states)
+ *  - Even edge permutations (A_12, 239,500,800 states)
+ *  - Center orbit arrangements (C(12,3)*C(9,3)*C(6,3) = 369,600 states per orbit)
+ */
+import { FTO_CORNER_COUNT } from "./types.js";
+const FACTORIAL = [
+    1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600
+];
+/**
+ * Binomial coefficient nCr = n! / (k! * (n-k)!).
+ */
+export function nCr(n, k) {
+    if (k < 0 || k > n)
+        return 0;
+    if (k === 0 || k === n)
+        return 1;
+    if (k > n - k)
+        k = n - k;
+    let res = 1;
+    for (let i = 1; i <= k; i++) {
+        res = (res * (n - i + 1)) / i;
+    }
+    return res;
+}
+/**
+ * Compute the permutation parity (number of inversions mod 2).
+ * Returns true if odd, false if even.
+ */
+export function getPermutationParity(perm) {
+    let inversions = 0;
+    const n = perm.length;
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            if (perm[i] > perm[j]) {
+                inversions++;
+            }
+        }
+    }
+    return (inversions & 1) === 1;
+}
+/**
+ * Pack a sorted k-subset of {0, ..., n-1} into an integer in [0, nCr(n, k) - 1].
+ * Uses standard combinatorial number system ranking: sum_{i=0}^{k-1} nCr(s_i, i + 1).
+ */
+export function packSubset(subset) {
+    let index = 0;
+    for (let i = subset.length - 1; i >= 0; i--) {
+        index += nCr(subset[i], i + 1);
+    }
+    return index;
+}
+/**
+ * Unpack an integer index in [0, nCr(n, k) - 1] into a sorted k-subset.
+ */
+export function unpackSubset(target, k, index) {
+    target.length = k;
+    let remaining = index;
+    let currentK = k;
+    for (let pos = 0; pos < k; pos++) {
+        let c = currentK - 1;
+        while (nCr(c + 1, currentK) <= remaining) {
+            c++;
+        }
+        target[k - 1 - pos] = c;
+        remaining -= nCr(c, currentK);
+        currentK--;
+    }
+}
+/**
+ * Pack an even permutation of length n into its rank in A_n: [0, n!/2 - 1].
+ */
+export function packEvenPerm(perm) {
+    const n = perm.length;
+    let rank = 0;
+    let used = 0;
+    for (let i = 0; i < n - 2; i++) {
+        const val = perm[i];
+        // Count how many smaller values haven't been used yet
+        let digit = 0;
+        for (let v = 0; v < val; v++) {
+            if ((used & (1 << v)) === 0) {
+                digit++;
+            }
+        }
+        used |= 1 << val;
+        const factor = FACTORIAL[n - 1 - i] / 2;
+        rank += digit * factor;
+    }
+    return rank;
+}
+/**
+ * Unpack an integer rank in [0, n!/2 - 1] into an even permutation of length n.
+ */
+export function unpackEvenPerm(n, rank, target) {
+    const perm = target ? target : new Array(n);
+    perm.length = n;
+    const lehmer = new Array(n);
+    let remaining = rank;
+    let sumLehmer = 0;
+    for (let i = 0; i < n - 2; i++) {
+        const factor = FACTORIAL[n - 1 - i] / 2;
+        const digit = Math.floor(remaining / factor);
+        remaining %= factor;
+        lehmer[i] = digit;
+        sumLehmer += digit;
+    }
+    // The (n-2)-th digit is fixed by even-parity constraint:
+    lehmer[n - 2] = sumLehmer & 1;
+    lehmer[n - 1] = 0;
+    // Reconstruct permutation from Lehmer code
+    const available = new Array(n);
+    for (let i = 0; i < n; i++)
+        available[i] = i;
+    for (let i = 0; i < n; i++) {
+        const choice = lehmer[i];
+        perm[i] = available[choice];
+        available.splice(choice, 1);
+    }
+    return perm;
+}
+/**
+ * Pack 6 corner orientations (each in {0, 1} with even sum) into [0, 31].
+ */
+export function packCornerOrientation(co) {
+    let rank = 0;
+    for (let i = 0; i < FTO_CORNER_COUNT - 1; i++) {
+        rank |= (co[i] & 1) << i;
+    }
+    return rank;
+}
+/**
+ * Unpack an orientation rank in [0, 31] into 6 corner orientations with sum = 0 mod 2.
+ */
+export function unpackCornerOrientation(rank, target) {
+    const co = target ? target : new Array(FTO_CORNER_COUNT);
+    co.length = FTO_CORNER_COUNT;
+    let sum = 0;
+    for (let i = 0; i < FTO_CORNER_COUNT - 1; i++) {
+        const val = (rank >> i) & 1;
+        co[i] = val;
+        sum += val;
+    }
+    co[FTO_CORNER_COUNT - 1] = sum & 1;
+    return co;
+}
+/**
+ * Pack a center orbit (12 pieces, 3 of each of 4 colors) into [0, 369599].
+ * Pieces 0..2 are color 0, 3..5 are color 1, 6..8 are color 2, 9..11 are color 3.
+ */
+export function packCenterOrbit(centers) {
+    const positions = [[], [], [], []];
+    for (let i = 0; i < 12; i++) {
+        const color = Math.floor(centers[i] / 3);
+        positions[color].push(i);
+    }
+    // 1. Color 0 positions in 0..11 (size 3)
+    const d0 = packSubset(positions[0]);
+    // Remaining 9 positions
+    const p1 = [];
+    const used0 = new Set(positions[0]);
+    for (let i = 0; i < 12; i++) {
+        if (!used0.has(i))
+            p1.push(i);
+    }
+    // 2. Color 1 positions mapped into p1 index space (0..8)
+    const s1 = positions[1].map((pos) => p1.indexOf(pos)).sort((a, b) => a - b);
+    const d1 = packSubset(s1);
+    // Remaining 6 positions
+    const p2 = [];
+    const used1 = new Set(positions[1]);
+    for (let i = 0; i < p1.length; i++) {
+        if (!used1.has(p1[i]))
+            p2.push(p1[i]);
+    }
+    // 3. Color 2 positions mapped into p2 index space (0..5)
+    const s2 = positions[2].map((pos) => p2.indexOf(pos)).sort((a, b) => a - b);
+    const d2 = packSubset(s2);
+    return d0 * (nCr(9, 3) * nCr(6, 3)) + d1 * nCr(6, 3) + d2;
+}
+/**
+ * Unpack a center orbit rank in [0, 369599] into 12 piece indices (0..11).
+ */
+export function unpackCenterOrbit(rank, target) {
+    const centers = target ? target : new Array(12);
+    centers.length = 12;
+    const C93_C63 = nCr(9, 3) * nCr(6, 3); // 84 * 20 = 1680
+    const C63 = nCr(6, 3); // 20
+    const d0 = Math.floor(rank / C93_C63);
+    let rem = rank % C93_C63;
+    const d1 = Math.floor(rem / C63);
+    const d2 = rem % C63;
+    const s0 = [];
+    unpackSubset(s0, 3, d0);
+    const s1 = [];
+    unpackSubset(s1, 3, d1);
+    const s2 = [];
+    unpackSubset(s2, 3, d2);
+    // Available positions pool
+    const pool = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    // Assign color 0 (piece indices 0, 1, 2)
+    for (let i = 0; i < 3; i++) {
+        const pos = s0[i];
+        centers[pos] = i; // 0, 1, 2
+    }
+    const remaining1 = pool.filter((p) => !s0.includes(p));
+    // Assign color 1 (piece indices 3, 4, 5)
+    const pos1 = s1.map((idx) => remaining1[idx]);
+    for (let i = 0; i < 3; i++) {
+        centers[pos1[i]] = 3 + i; // 3, 4, 5
+    }
+    const remaining2 = remaining1.filter((p) => !pos1.includes(p));
+    // Assign color 2 (piece indices 6, 7, 8)
+    const pos2 = s2.map((idx) => remaining2[idx]);
+    for (let i = 0; i < 3; i++) {
+        centers[pos2[i]] = 6 + i; // 6, 7, 8
+    }
+    const remaining3 = remaining2.filter((p) => !pos2.includes(p));
+    // Assign color 3 (piece indices 9, 10, 11)
+    for (let i = 0; i < 3; i++) {
+        centers[remaining3[i]] = 9 + i; // 9, 10, 11
+    }
+    return centers;
+}

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

@@ -0,0 +1,6 @@
+import type { FtoFacelets } from "./types.js";
+import { FtoCubie } from "./state.js";
+export declare function toFaceCubeArray(state: FtoCubie): number[];
+export declare function toFtoFacelets(state: FtoCubie): FtoFacelets;
+export declare function formatFtoFacelets(facelets: FtoFacelets): string;
+//# sourceMappingURL=facelets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAqEtC,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,EAAE,CAWzD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,WAAW,CAsB1D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAW/D"}

package/dist/puzzles/fto/facelets.js

@@ -0,0 +1,99 @@
+const FACE_NAMES = ["U", "F", "BR", "BL", "D", "B", "R", "L"];
+const U = 0, F = 9, r = 18, l = 27, D = 36, B = 45, R = 54, L = 63;
+const cornFacelets = [
+    [U + 0, R + 0, F + 0, L + 0],
+    [U + 4, B + 8, r + 4, R + 8],
+    [U + 8, L + 4, l + 8, B + 4],
+    [l + 0, D + 0, r + 0, B + 0],
+    [F + 4, D + 8, l + 4, L + 8],
+    [r + 8, D + 4, F + 8, R + 4]
+];
+const edgeFacelets = [
+    [U + 1, R + 3],
+    [U + 3, L + 1],
+    [U + 6, B + 6],
+    [l + 1, D + 3],
+    [r + 3, D + 1],
+    [F + 6, D + 6],
+    [F + 3, R + 1],
+    [F + 1, L + 3],
+    [l + 6, L + 6],
+    [l + 3, B + 1],
+    [r + 1, B + 3],
+    [r + 6, R + 6]
+];
+const ctufFacelets = [
+    U + 2, U + 5, U + 7,
+    F + 2, F + 5, F + 7,
+    r + 2, r + 5, r + 7,
+    l + 2, l + 5, l + 7
+];
+const ctrlFacelets = [
+    D + 2, D + 5, D + 7,
+    B + 2, B + 5, B + 7,
+    L + 2, L + 5, L + 7,
+    R + 2, R + 5, R + 7
+];
+function fillFacelet(faceletMap, f, perm, ori, divcol) {
+    for (let i = 0; i < faceletMap.length; i++) {
+        const cubie = faceletMap[i];
+        const p = perm[i] === undefined ? i : perm[i];
+        if (typeof cubie === "number") {
+            const src = faceletMap[p];
+            f[cubie] = Math.floor((typeof src === "number" ? src : src[0]) / divcol);
+            continue;
+        }
+        const o = ori ? (ori[i] || 0) : 0;
+        const src = faceletMap[p];
+        for (let j = 0; j < cubie.length; j++) {
+            const destIndex = cubie[(j + o) % cubie.length];
+            const srcIndex = typeof src === "number" ? src : src[j];
+            f[destIndex] = Math.floor(srcIndex / divcol);
+        }
+    }
+}
+export function toFaceCubeArray(state) {
+    const f = new Array(72);
+    const co = new Array(6);
+    for (let i = 0; i < 6; i++) {
+        co[i] = state.co[i] * 2;
+    }
+    fillFacelet(cornFacelets, f, state.cp, co, 9);
+    fillFacelet(edgeFacelets, f, state.ep, null, 9);
+    fillFacelet(ctufFacelets, f, state.uf, null, 9);
+    fillFacelet(ctrlFacelets, f, state.rl, null, 9);
+    return f;
+}
+export function toFtoFacelets(state) {
+    const faceArray = toFaceCubeArray(state);
+    const getFaceStickers = (offset) => {
+        const stickers = new Array(9);
+        for (let i = 0; i < 9; i++) {
+            const colorVal = faceArray[offset + i];
+            stickers[i] = FACE_NAMES[colorVal] ?? "U";
+        }
+        return stickers;
+    };
+    return {
+        U: getFaceStickers(U),
+        F: getFaceStickers(F),
+        BR: getFaceStickers(r),
+        BL: getFaceStickers(l),
+        D: getFaceStickers(D),
+        B: getFaceStickers(B),
+        R: getFaceStickers(R),
+        L: getFaceStickers(L)
+    };
+}
+export function formatFtoFacelets(facelets) {
+    return [
+        facelets.U.join(""),
+        facelets.D.join(""),
+        facelets.F.join(""),
+        facelets.B.join(""),
+        facelets.L.join(""),
+        facelets.BR.join(""),
+        facelets.R.join(""),
+        facelets.BL.join("")
+    ].join(" ");
+}

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

@@ -0,0 +1,12 @@
+export type { FtoFace, FtoMove, FtoFacelets, FtoRandomStateOptions, FtoValidationResult } from "./types.js";
+export { FTO_FACES, FTO_ALL_MOVES, FTO_AXIS_MAP, SCRAMBLE_LENGTH, FTO_CORNER_COUNT, FTO_EDGE_COUNT, FTO_CENTER_ORBIT_COUNT, FTO_CORNER_PERM_STATES, FTO_CORNER_ORI_STATES, FTO_EDGE_PERM_STATES, FTO_CENTER_ORBIT_STATES } from "./types.js";
+export { FtoCubie, createSolvedFtoState, cloneFtoState, statesEqual, isSolvedFtoState } from "./state.js";
+export { FTO_MOVE_MAP, getFtoMoveFace, invertFtoMove, invertFtoAlgorithm, parseFtoAlgorithm, formatFtoAlgorithm, applyFtoMove, applyFtoAlgorithm, isRedundantFtoMove } from "./moves.js";
+export { toFaceCubeArray, toFtoFacelets, formatFtoFacelets } from "./facelets.js";
+export { nCr, getPermutationParity, packSubset, unpackSubset, packEvenPerm, unpackEvenPerm, packCornerOrientation, unpackCornerOrientation, packCenterOrbit, unpackCenterOrbit } from "./coordinates.js";
+export { validateFtoState, isTrivialFtoState } from "./validation.js";
+export { generateRandomFtoState } from "./random-state.js";
+export { solveFto, initFtoSolver, isFtoSolverInitialized } from "./solver/index.js";
+export { ftoScrambleGenerator, generateFtoScramble } from "./scrambler.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/index.ts"],"names":[],"mappings":"AAKA,YAAY,EACV,OAAO,EACP,OAAO,EACP,WAAW,EACX,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,SAAS,EACT,aAAa,EACb,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,aAAa,EACb,WAAW,EACX,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,YAAY,EACZ,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,eAAe,EACf,aAAa,EACb,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,GAAG,EACH,oBAAoB,EACpB,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,EACf,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,QAAQ,EACR,aAAa,EACb,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/fto/index.js

@@ -0,0 +1,13 @@
+import { registerScrambleGenerator } from "../../core/index.js";
+import { ftoScrambleGenerator } from "./scrambler.js";
+registerScrambleGenerator(ftoScrambleGenerator);
+export { FTO_FACES, FTO_ALL_MOVES, FTO_AXIS_MAP, SCRAMBLE_LENGTH, FTO_CORNER_COUNT, FTO_EDGE_COUNT, FTO_CENTER_ORBIT_COUNT, FTO_CORNER_PERM_STATES, FTO_CORNER_ORI_STATES, FTO_EDGE_PERM_STATES, FTO_CENTER_ORBIT_STATES } from "./types.js";
+export { FtoCubie, createSolvedFtoState, cloneFtoState, statesEqual, isSolvedFtoState } from "./state.js";
+export { FTO_MOVE_MAP, getFtoMoveFace, invertFtoMove, invertFtoAlgorithm, parseFtoAlgorithm, formatFtoAlgorithm, applyFtoMove, applyFtoAlgorithm, isRedundantFtoMove } from "./moves.js";
+export { toFaceCubeArray, toFtoFacelets, formatFtoFacelets } from "./facelets.js";
+export { nCr, getPermutationParity, packSubset, unpackSubset, packEvenPerm, unpackEvenPerm, packCornerOrientation, unpackCornerOrientation, packCenterOrbit, unpackCenterOrbit } from "./coordinates.js";
+export { validateFtoState, isTrivialFtoState } from "./validation.js";
+export { generateRandomFtoState } from "./random-state.js";
+export { solveFto, initFtoSolver, isFtoSolverInitialized } from "./solver/index.js";
+export { ftoScrambleGenerator, generateFtoScramble } from "./scrambler.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";

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

@@ -0,0 +1,12 @@
+import type { FtoFace, FtoMove } from "./types.js";
+import { FtoCubie } from "./state.js";
+export declare const FTO_MOVE_MAP: Record<FtoMove, FtoCubie>;
+export declare function getFtoMoveFace(move: FtoMove | string): FtoFace;
+export declare function invertFtoMove(move: FtoMove): FtoMove;
+export declare function invertFtoAlgorithm(moves: readonly FtoMove[]): FtoMove[];
+export declare function parseFtoAlgorithm(algorithm: string): FtoMove[];
+export declare function formatFtoAlgorithm(moves: readonly FtoMove[]): string;
+export declare function applyFtoMove(state: FtoCubie, move: FtoMove | string): FtoCubie;
+export declare function applyFtoAlgorithm(state: FtoCubie, algorithm: readonly (FtoMove | string)[] | string): FtoCubie;
+export declare function isRedundantFtoMove(moves: readonly FtoMove[], newMove: FtoMove): boolean;
+//# sourceMappingURL=moves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/moves.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAkEtC,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,OAAO,EAAE,QAAQ,CAiBlD,CAAC;AAEF,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAG9D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAKpD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAMvE;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,EAAE,CAW9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAEpE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAM9E;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM,GAChD,QAAQ,CAQV;AAaD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,OAAO,EAAE,OAAO,GACf,OAAO,CA+BT"}