@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist-cjs/puzzles/fto/coordinates.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * 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)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nCr = nCr;
+exports.getPermutationParity = getPermutationParity;
+exports.packSubset = packSubset;
+exports.unpackSubset = unpackSubset;
+exports.packEvenPerm = packEvenPerm;
+exports.unpackEvenPerm = unpackEvenPerm;
+exports.packCornerOrientation = packCornerOrientation;
+exports.unpackCornerOrientation = unpackCornerOrientation;
+exports.packCenterOrbit = packCenterOrbit;
+exports.unpackCenterOrbit = unpackCenterOrbit;
+const types_js_1 = require("./types.js");
+const FACTORIAL = [
+    1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600
+];
+/**
+ * Binomial coefficient nCr = n! / (k! * (n-k)!).
+ */
+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.
+ */
+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).
+ */
+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.
+ */
+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].
+ */
+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.
+ */
+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].
+ */
+function packCornerOrientation(co) {
+    let rank = 0;
+    for (let i = 0; i < types_js_1.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.
+ */
+function unpackCornerOrientation(rank, target) {
+    const co = target ? target : new Array(types_js_1.FTO_CORNER_COUNT);
+    co.length = types_js_1.FTO_CORNER_COUNT;
+    let sum = 0;
+    for (let i = 0; i < types_js_1.FTO_CORNER_COUNT - 1; i++) {
+        const val = (rank >> i) & 1;
+        co[i] = val;
+        sum += val;
+    }
+    co[types_js_1.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.
+ */
+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).
+ */
+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-cjs/puzzles/fto/facelets.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFaceCubeArray = toFaceCubeArray;
+exports.toFtoFacelets = toFtoFacelets;
+exports.formatFtoFacelets = formatFtoFacelets;
+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);
+        }
+    }
+}
+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;
+}
+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)
+    };
+}
+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-cjs/puzzles/fto/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.generateFtoScramble = exports.ftoScrambleGenerator = exports.isFtoSolverInitialized = exports.initFtoSolver = exports.solveFto = exports.generateRandomFtoState = exports.isTrivialFtoState = exports.validateFtoState = exports.unpackCenterOrbit = exports.packCenterOrbit = exports.unpackCornerOrientation = exports.packCornerOrientation = exports.unpackEvenPerm = exports.packEvenPerm = exports.unpackSubset = exports.packSubset = exports.getPermutationParity = exports.nCr = exports.formatFtoFacelets = exports.toFtoFacelets = exports.toFaceCubeArray = exports.isRedundantFtoMove = exports.applyFtoAlgorithm = exports.applyFtoMove = exports.formatFtoAlgorithm = exports.parseFtoAlgorithm = exports.invertFtoAlgorithm = exports.invertFtoMove = exports.getFtoMoveFace = exports.FTO_MOVE_MAP = exports.isSolvedFtoState = exports.statesEqual = exports.cloneFtoState = exports.createSolvedFtoState = exports.FtoCubie = exports.FTO_CENTER_ORBIT_STATES = exports.FTO_EDGE_PERM_STATES = exports.FTO_CORNER_ORI_STATES = exports.FTO_CORNER_PERM_STATES = exports.FTO_CENTER_ORBIT_COUNT = exports.FTO_EDGE_COUNT = exports.FTO_CORNER_COUNT = exports.SCRAMBLE_LENGTH = exports.FTO_AXIS_MAP = exports.FTO_ALL_MOVES = exports.FTO_FACES = void 0;
+exports.initializeScrambler = void 0;
+const index_js_1 = require("../../core/index.js");
+const scrambler_js_1 = require("./scrambler.js");
+(0, index_js_1.registerScrambleGenerator)(scrambler_js_1.ftoScrambleGenerator);
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "FTO_FACES", { enumerable: true, get: function () { return types_js_1.FTO_FACES; } });
+Object.defineProperty(exports, "FTO_ALL_MOVES", { enumerable: true, get: function () { return types_js_1.FTO_ALL_MOVES; } });
+Object.defineProperty(exports, "FTO_AXIS_MAP", { enumerable: true, get: function () { return types_js_1.FTO_AXIS_MAP; } });
+Object.defineProperty(exports, "SCRAMBLE_LENGTH", { enumerable: true, get: function () { return types_js_1.SCRAMBLE_LENGTH; } });
+Object.defineProperty(exports, "FTO_CORNER_COUNT", { enumerable: true, get: function () { return types_js_1.FTO_CORNER_COUNT; } });
+Object.defineProperty(exports, "FTO_EDGE_COUNT", { enumerable: true, get: function () { return types_js_1.FTO_EDGE_COUNT; } });
+Object.defineProperty(exports, "FTO_CENTER_ORBIT_COUNT", { enumerable: true, get: function () { return types_js_1.FTO_CENTER_ORBIT_COUNT; } });
+Object.defineProperty(exports, "FTO_CORNER_PERM_STATES", { enumerable: true, get: function () { return types_js_1.FTO_CORNER_PERM_STATES; } });
+Object.defineProperty(exports, "FTO_CORNER_ORI_STATES", { enumerable: true, get: function () { return types_js_1.FTO_CORNER_ORI_STATES; } });
+Object.defineProperty(exports, "FTO_EDGE_PERM_STATES", { enumerable: true, get: function () { return types_js_1.FTO_EDGE_PERM_STATES; } });
+Object.defineProperty(exports, "FTO_CENTER_ORBIT_STATES", { enumerable: true, get: function () { return types_js_1.FTO_CENTER_ORBIT_STATES; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "FtoCubie", { enumerable: true, get: function () { return state_js_1.FtoCubie; } });
+Object.defineProperty(exports, "createSolvedFtoState", { enumerable: true, get: function () { return state_js_1.createSolvedFtoState; } });
+Object.defineProperty(exports, "cloneFtoState", { enumerable: true, get: function () { return state_js_1.cloneFtoState; } });
+Object.defineProperty(exports, "statesEqual", { enumerable: true, get: function () { return state_js_1.statesEqual; } });
+Object.defineProperty(exports, "isSolvedFtoState", { enumerable: true, get: function () { return state_js_1.isSolvedFtoState; } });
+var moves_js_1 = require("./moves.js");
+Object.defineProperty(exports, "FTO_MOVE_MAP", { enumerable: true, get: function () { return moves_js_1.FTO_MOVE_MAP; } });
+Object.defineProperty(exports, "getFtoMoveFace", { enumerable: true, get: function () { return moves_js_1.getFtoMoveFace; } });
+Object.defineProperty(exports, "invertFtoMove", { enumerable: true, get: function () { return moves_js_1.invertFtoMove; } });
+Object.defineProperty(exports, "invertFtoAlgorithm", { enumerable: true, get: function () { return moves_js_1.invertFtoAlgorithm; } });
+Object.defineProperty(exports, "parseFtoAlgorithm", { enumerable: true, get: function () { return moves_js_1.parseFtoAlgorithm; } });
+Object.defineProperty(exports, "formatFtoAlgorithm", { enumerable: true, get: function () { return moves_js_1.formatFtoAlgorithm; } });
+Object.defineProperty(exports, "applyFtoMove", { enumerable: true, get: function () { return moves_js_1.applyFtoMove; } });
+Object.defineProperty(exports, "applyFtoAlgorithm", { enumerable: true, get: function () { return moves_js_1.applyFtoAlgorithm; } });
+Object.defineProperty(exports, "isRedundantFtoMove", { enumerable: true, get: function () { return moves_js_1.isRedundantFtoMove; } });
+var facelets_js_1 = require("./facelets.js");
+Object.defineProperty(exports, "toFaceCubeArray", { enumerable: true, get: function () { return facelets_js_1.toFaceCubeArray; } });
+Object.defineProperty(exports, "toFtoFacelets", { enumerable: true, get: function () { return facelets_js_1.toFtoFacelets; } });
+Object.defineProperty(exports, "formatFtoFacelets", { enumerable: true, get: function () { return facelets_js_1.formatFtoFacelets; } });
+var coordinates_js_1 = require("./coordinates.js");
+Object.defineProperty(exports, "nCr", { enumerable: true, get: function () { return coordinates_js_1.nCr; } });
+Object.defineProperty(exports, "getPermutationParity", { enumerable: true, get: function () { return coordinates_js_1.getPermutationParity; } });
+Object.defineProperty(exports, "packSubset", { enumerable: true, get: function () { return coordinates_js_1.packSubset; } });
+Object.defineProperty(exports, "unpackSubset", { enumerable: true, get: function () { return coordinates_js_1.unpackSubset; } });
+Object.defineProperty(exports, "packEvenPerm", { enumerable: true, get: function () { return coordinates_js_1.packEvenPerm; } });
+Object.defineProperty(exports, "unpackEvenPerm", { enumerable: true, get: function () { return coordinates_js_1.unpackEvenPerm; } });
+Object.defineProperty(exports, "packCornerOrientation", { enumerable: true, get: function () { return coordinates_js_1.packCornerOrientation; } });
+Object.defineProperty(exports, "unpackCornerOrientation", { enumerable: true, get: function () { return coordinates_js_1.unpackCornerOrientation; } });
+Object.defineProperty(exports, "packCenterOrbit", { enumerable: true, get: function () { return coordinates_js_1.packCenterOrbit; } });
+Object.defineProperty(exports, "unpackCenterOrbit", { enumerable: true, get: function () { return coordinates_js_1.unpackCenterOrbit; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "validateFtoState", { enumerable: true, get: function () { return validation_js_1.validateFtoState; } });
+Object.defineProperty(exports, "isTrivialFtoState", { enumerable: true, get: function () { return validation_js_1.isTrivialFtoState; } });
+var random_state_js_1 = require("./random-state.js");
+Object.defineProperty(exports, "generateRandomFtoState", { enumerable: true, get: function () { return random_state_js_1.generateRandomFtoState; } });
+var index_js_2 = require("./solver/index.js");
+Object.defineProperty(exports, "solveFto", { enumerable: true, get: function () { return index_js_2.solveFto; } });
+Object.defineProperty(exports, "initFtoSolver", { enumerable: true, get: function () { return index_js_2.initFtoSolver; } });
+Object.defineProperty(exports, "isFtoSolverInitialized", { enumerable: true, get: function () { return index_js_2.isFtoSolverInitialized; } });
+var scrambler_js_2 = require("./scrambler.js");
+Object.defineProperty(exports, "ftoScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.ftoScrambleGenerator; } });
+Object.defineProperty(exports, "generateFtoScramble", { enumerable: true, get: function () { return scrambler_js_2.generateFtoScramble; } });
+var index_js_3 = require("../../core/index.js");
+Object.defineProperty(exports, "generateScramble", { enumerable: true, get: function () { return index_js_3.generateScramble; } });
+Object.defineProperty(exports, "generateScrambles", { enumerable: true, get: function () { return index_js_3.generateScrambles; } });
+Object.defineProperty(exports, "getEventInfo", { enumerable: true, get: function () { return index_js_3.getEventInfo; } });
+Object.defineProperty(exports, "getSupportedEvents", { enumerable: true, get: function () { return index_js_3.getSupportedEvents; } });
+Object.defineProperty(exports, "initializeScrambler", { enumerable: true, get: function () { return index_js_3.initializeScrambler; } });

package/dist-cjs/puzzles/fto/moves.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FTO_MOVE_MAP = void 0;
+exports.getFtoMoveFace = getFtoMoveFace;
+exports.invertFtoMove = invertFtoMove;
+exports.invertFtoAlgorithm = invertFtoAlgorithm;
+exports.parseFtoAlgorithm = parseFtoAlgorithm;
+exports.formatFtoAlgorithm = formatFtoAlgorithm;
+exports.applyFtoMove = applyFtoMove;
+exports.applyFtoAlgorithm = applyFtoAlgorithm;
+exports.isRedundantFtoMove = isRedundantFtoMove;
+const types_js_1 = require("./types.js");
+const state_js_1 = require("./state.js");
+const moveU = new state_js_1.FtoCubie([1, 2, 0, 3, 4, 5], [0, 0, 0, 0, 0, 0], [2, 0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11], [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11], [0, 1, 2, 3, 6, 7, 11, 9, 8, 5, 10, 4]);
+const moveF = new state_js_1.FtoCubie([4, 1, 2, 3, 5, 0], [1, 0, 0, 0, 1, 0], [0, 1, 2, 3, 4, 6, 7, 5, 8, 9, 10, 11], [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10, 11], [0, 9, 10, 3, 4, 5, 2, 7, 1, 8, 6, 11]);
+const moveBR = new state_js_1.FtoCubie([0, 5, 2, 1, 4, 3], [0, 1, 0, 0, 0, 1], [0, 1, 2, 3, 10, 5, 6, 7, 8, 9, 11, 4], [0, 1, 2, 3, 4, 5, 7, 8, 6, 9, 10, 11], [5, 3, 2, 11, 4, 10, 6, 7, 8, 9, 0, 1]);
+const moveBL = new state_js_1.FtoCubie([0, 1, 3, 4, 2, 5], [0, 0, 1, 1, 0, 0], [0, 1, 2, 8, 4, 5, 6, 7, 9, 3, 10, 11], [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 9], [8, 1, 7, 2, 0, 5, 6, 3, 4, 9, 10, 11]);
+const moveD = new state_js_1.FtoCubie([0, 1, 2, 5, 3, 4], [0, 0, 0, 0, 0, 0], [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10, 11], [0, 1, 2, 3, 9, 10, 5, 7, 4, 8, 6, 11], [1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
+const moveB = new state_js_1.FtoCubie([0, 3, 1, 2, 4, 5], [0, 1, 1, 0, 0, 0], [0, 1, 10, 3, 4, 5, 6, 7, 8, 2, 9, 11], [0, 6, 7, 3, 4, 5, 11, 9, 8, 2, 10, 1], [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10, 11]);
+const moveR = new state_js_1.FtoCubie([5, 0, 2, 3, 4, 1], [1, 1, 0, 0, 0, 0], [6, 1, 2, 3, 4, 5, 11, 7, 8, 9, 10, 0], [5, 3, 2, 8, 4, 7, 6, 0, 1, 9, 10, 11], [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 9]);
+const moveL = new state_js_1.FtoCubie([2, 1, 4, 3, 0, 5], [1, 0, 1, 0, 0, 0], [0, 8, 2, 3, 4, 5, 6, 1, 7, 9, 10, 11], [11, 1, 10, 2, 0, 5, 6, 7, 8, 9, 3, 4], [0, 1, 2, 3, 4, 5, 7, 8, 6, 9, 10, 11]);
+exports.FTO_MOVE_MAP = {
+    U: moveU,
+    "U'": state_js_1.FtoCubie.multiply(moveU, moveU),
+    F: moveF,
+    "F'": state_js_1.FtoCubie.multiply(moveF, moveF),
+    BR: moveBR,
+    "BR'": state_js_1.FtoCubie.multiply(moveBR, moveBR),
+    BL: moveBL,
+    "BL'": state_js_1.FtoCubie.multiply(moveBL, moveBL),
+    D: moveD,
+    "D'": state_js_1.FtoCubie.multiply(moveD, moveD),
+    B: moveB,
+    "B'": state_js_1.FtoCubie.multiply(moveB, moveB),
+    R: moveR,
+    "R'": state_js_1.FtoCubie.multiply(moveR, moveR),
+    L: moveL,
+    "L'": state_js_1.FtoCubie.multiply(moveL, moveL)
+};
+function getFtoMoveFace(move) {
+    const base = move.replace(/'$/, "");
+    return base;
+}
+function invertFtoMove(move) {
+    if (move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return `${move}'`;
+}
+function invertFtoAlgorithm(moves) {
+    const inverted = new Array(moves.length);
+    for (let i = 0; i < moves.length; i++) {
+        inverted[moves.length - 1 - i] = invertFtoMove(moves[i]);
+    }
+    return inverted;
+}
+function parseFtoAlgorithm(algorithm) {
+    const tokens = algorithm.trim().split(/\s+/).filter(Boolean);
+    const result = [];
+    for (const token of tokens) {
+        if (token in exports.FTO_MOVE_MAP) {
+            result.push(token);
+        }
+        else {
+            throw new Error(`Invalid FTO move: ${token}`);
+        }
+    }
+    return result;
+}
+function formatFtoAlgorithm(moves) {
+    return moves.join(" ");
+}
+function applyFtoMove(state, move) {
+    const moveCubie = exports.FTO_MOVE_MAP[move];
+    if (!moveCubie) {
+        throw new Error(`Unsupported FTO move: ${move}`);
+    }
+    return state_js_1.FtoCubie.multiply(state, moveCubie);
+}
+function applyFtoAlgorithm(state, algorithm) {
+    const moves = typeof algorithm === "string" ? parseFtoAlgorithm(algorithm) : algorithm;
+    let current = state;
+    for (const move of moves) {
+        current = applyFtoMove(current, move);
+    }
+    return current;
+}
+const FTO_AXIS_ORDER = {
+    U: 0,
+    D: 1,
+    F: 0,
+    B: 1,
+    L: 0,
+    BR: 1,
+    R: 0,
+    BL: 1
+};
+function isRedundantFtoMove(moves, newMove) {
+    if (moves.length === 0)
+        return false;
+    const newFace = getFtoMoveFace(newMove);
+    const newAxis = types_js_1.FTO_AXIS_MAP[newFace];
+    const lastMove = moves[moves.length - 1];
+    const lastFace = getFtoMoveFace(lastMove);
+    // No same face consecutively
+    if (lastFace === newFace)
+        return true;
+    const lastAxis = types_js_1.FTO_AXIS_MAP[lastFace];
+    // Different axis is always allowed
+    if (newAxis !== lastAxis)
+        return false;
+    // Same axis (commutes): enforce canonical order
+    // to avoid duplicates like [D, U] vs [U, D] and prevent sequences like [U, D, U]
+    if (moves.length >= 2) {
+        const prevMove = moves[moves.length - 2];
+        const prevFace = getFtoMoveFace(prevMove);
+        if (types_js_1.FTO_AXIS_MAP[prevFace] === newAxis) {
+            return true; // Already 2 moves on this axis in a row
+        }
+    }
+    // Canonical ordering for commuting faces on the same axis
+    if (FTO_AXIS_ORDER[newFace] <= FTO_AXIS_ORDER[lastFace]) {
+        return true;
+    }
+    return false;
+}

package/dist-cjs/puzzles/fto/random-state.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Uniform random-state generation for Face-Turning Octahedron (FTO).
+ *
+ * Samples uniformly from the 3.14 x 10^22 reachable states:
+ *  - Corner permutation in A_6 (360)
+ *  - Corner orientation in Z_2^5 with sum ≡ 0 (mod 2) (32)
+ *  - Edge permutation in A_12 (239,500,800)
+ *  - Orbit 1 centers (uf): multiset arrangement C(12,3)*C(9,3)*C(6,3) (369,600)
+ *  - Orbit 2 centers (rl): multiset arrangement C(12,3)*C(9,3)*C(6,3) (369,600)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomFtoState = generateRandomFtoState;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+const state_js_1 = require("./state.js");
+const coordinates_js_1 = require("./coordinates.js");
+const validation_js_1 = require("./validation.js");
+/**
+ * Generates a legal, uniformly-sampled random FTO state.
+ */
+function generateRandomFtoState(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const cpRank = random.nextInt(types_js_1.FTO_CORNER_PERM_STATES);
+        const coRank = random.nextInt(types_js_1.FTO_CORNER_ORI_STATES);
+        const epRank = random.nextInt(types_js_1.FTO_EDGE_PERM_STATES);
+        const ufRank = random.nextInt(types_js_1.FTO_CENTER_ORBIT_STATES);
+        const rlRank = random.nextInt(types_js_1.FTO_CENTER_ORBIT_STATES);
+        const cp = (0, coordinates_js_1.unpackEvenPerm)(types_js_1.FTO_CORNER_COUNT, cpRank);
+        const co = (0, coordinates_js_1.unpackCornerOrientation)(coRank);
+        const ep = (0, coordinates_js_1.unpackEvenPerm)(types_js_1.FTO_EDGE_COUNT, epRank);
+        const uf = (0, coordinates_js_1.unpackCenterOrbit)(ufRank);
+        const rl = (0, coordinates_js_1.unpackCenterOrbit)(rlRank);
+        const state = new state_js_1.FtoCubie(cp, co, ep, uf, rl);
+        if (rejectTrivial && (0, validation_js_1.isTrivialFtoState)(state)) {
+            continue;
+        }
+        return state;
+    }
+    throw new Error("Unable to generate a non-trivial random FTO state.");
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ftoScrambleGenerator = void 0;
+exports.generateFtoScramble = generateFtoScramble;
+const index_js_1 = require("../../random/index.js");
+const moves_js_1 = require("./moves.js");
+const state_js_1 = require("./state.js");
+const facelets_js_1 = require("./facelets.js");
+const index_js_2 = require("./solver/index.js");
+exports.ftoScrambleGenerator = {
+    info: {
+        eventId: "fto",
+        name: "Face-Turning Octahedron",
+        puzzle: "fto",
+        quality: "random-state",
+        generator: "fto-three-phase",
+        description: "Random-state Face-Turning Octahedron scramble generated by a 3-phase reduction solver."
+    },
+    generate(options = {}) {
+        return generateFtoScramble(options);
+    }
+};
+function generateFtoScramble(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const { scramble, moves, state, facelets } = (0, index_js_2.generateFtoRandomState)(() => random.next());
+    if (!options.skipValidation) {
+        const replayed = (0, moves_js_1.applyFtoAlgorithm)((0, state_js_1.createSolvedFtoState)(), moves);
+        if (!replayed.isEqual(state)) {
+            throw new Error("Generated FTO scramble does not reproduce the target random state.");
+        }
+    }
+    const solutionMoves = (0, moves_js_1.invertFtoAlgorithm)(moves);
+    const faceletString = (0, facelets_js_1.formatFtoFacelets)(facelets);
+    const result = {
+        eventId: "fto",
+        scramble,
+        moves,
+        quality: "random-state",
+        generator: "fto-three-phase",
+        metadata: {
+            totalMoves: moves.length,
+            solutionDepth: solutionMoves.length,
+            solutionMoves,
+            state,
+            facelets,
+            faceletString
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}