@cubingcenter/scrambler 0.5.3 → 0.6.0

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

@@ -0,0 +1,2 @@
+export { solveFto, initFtoSolver, isFtoSolverInitialized, solveFtoFacelet, generateFtoRandomState } from "./engine.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/fto/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,aAAa,EACb,sBAAsB,EACtB,eAAe,EACf,sBAAsB,EACvB,MAAM,aAAa,CAAC"}

package/dist/puzzles/fto/solver/index.js

@@ -0,0 +1 @@
+export { solveFto, initFtoSolver, isFtoSolverInitialized, solveFtoFacelet, generateFtoRandomState } from "./engine.js";

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

@@ -0,0 +1,16 @@
+export declare class FtoCubie {
+    cp: number[];
+    co: number[];
+    ep: number[];
+    uf: number[];
+    rl: number[];
+    constructor(cp?: readonly number[], co?: readonly number[], ep?: readonly number[], uf?: readonly number[], rl?: readonly number[]);
+    clone(): FtoCubie;
+    isEqual(other: FtoCubie): boolean;
+    static multiply(...args: FtoCubie[]): FtoCubie;
+}
+export declare function createSolvedFtoState(): FtoCubie;
+export declare function cloneFtoState(state: FtoCubie): FtoCubie;
+export declare function statesEqual(a: FtoCubie, b: FtoCubie): boolean;
+export declare function isSolvedFtoState(state: FtoCubie): boolean;
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/state.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAQ;IACZ,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;gBAGlB,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,EACtB,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE;IASjB,KAAK,IAAI,QAAQ;IAIjB,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;WAkB1B,QAAQ,CAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,GAAG,QAAQ;CAgBtD;AAED,wBAAgB,oBAAoB,IAAI,QAAQ,CAE/C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAEvD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAE7D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAGzD"}

package/dist/puzzles/fto/state.js

@@ -0,0 +1,61 @@
+export class FtoCubie {
+    cp;
+    co;
+    ep;
+    uf;
+    rl;
+    constructor(cp, co, ep, uf, rl) {
+        this.cp = cp ? Array.from(cp) : [0, 1, 2, 3, 4, 5];
+        this.co = co ? Array.from(co) : [0, 0, 0, 0, 0, 0];
+        this.ep = ep ? Array.from(ep) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        this.uf = uf ? Array.from(uf) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        this.rl = rl ? Array.from(rl) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    }
+    clone() {
+        return new FtoCubie(this.cp, this.co, this.ep, this.uf, this.rl);
+    }
+    isEqual(other) {
+        for (let i = 0; i < 6; i++) {
+            if (this.cp[i] !== other.cp[i] || this.co[i] !== other.co[i]) {
+                return false;
+            }
+        }
+        for (let i = 0; i < 12; i++) {
+            if (this.ep[i] !== other.ep[i] ||
+                this.uf[i] !== other.uf[i] ||
+                this.rl[i] !== other.rl[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static multiply(...args) {
+        const prod = new FtoCubie();
+        for (let k = args.length - 1; k >= 0; k--) {
+            const a = args[k];
+            for (let i = 0; i < 6; i++) {
+                prod.co[i] = a.co[prod.cp[i]] ^ prod.co[i];
+                prod.cp[i] = a.cp[prod.cp[i]];
+            }
+            for (let i = 0; i < 12; i++) {
+                prod.ep[i] = a.ep[prod.ep[i]];
+                prod.uf[i] = a.uf[prod.uf[i]];
+                prod.rl[i] = a.rl[prod.rl[i]];
+            }
+        }
+        return prod;
+    }
+}
+export function createSolvedFtoState() {
+    return new FtoCubie();
+}
+export function cloneFtoState(state) {
+    return state.clone();
+}
+export function statesEqual(a, b) {
+    return a.isEqual(b);
+}
+export function isSolvedFtoState(state) {
+    const solved = new FtoCubie();
+    return state.isEqual(solved);
+}

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

@@ -0,0 +1,32 @@
+export type FtoFace = "U" | "D" | "F" | "B" | "L" | "BR" | "R" | "BL";
+export type FtoMove = "U" | "U'" | "D" | "D'" | "F" | "F'" | "B" | "B'" | "L" | "L'" | "R" | "R'" | "BL" | "BL'" | "BR" | "BR'";
+export interface FtoFacelets {
+    U: string[];
+    D: string[];
+    F: string[];
+    B: string[];
+    L: string[];
+    BR: string[];
+    R: string[];
+    BL: string[];
+}
+export declare const FTO_FACES: readonly FtoFace[];
+export declare const FTO_ALL_MOVES: readonly FtoMove[];
+export declare const FTO_AXIS_MAP: Record<FtoFace, number>;
+export declare const SCRAMBLE_LENGTH = 30;
+export declare const FTO_CORNER_COUNT = 6;
+export declare const FTO_EDGE_COUNT = 12;
+export declare const FTO_CENTER_ORBIT_COUNT = 12;
+export declare const FTO_CORNER_PERM_STATES = 360;
+export declare const FTO_CORNER_ORI_STATES = 32;
+export declare const FTO_EDGE_PERM_STATES = 239500800;
+export declare const FTO_CENTER_ORBIT_STATES = 369600;
+export interface FtoRandomStateOptions {
+    seed?: string | number;
+    rejectTrivial?: boolean;
+}
+export interface FtoValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC;AAEtE,MAAM,MAAM,OAAO,GACf,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,KAAK,CAAC;AAEV,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,EAAE,EAAE,MAAM,EAAE,CAAC;CACd;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,OAAO,EAS9B,CAAC;AAEX,eAAO,MAAM,aAAa,EAAE,SAAS,OAAO,EAiBlC,CAAC;AAEX,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAShD,CAAC;AAEF,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,oBAAoB,YAAY,CAAC;AAC9C,eAAO,MAAM,uBAAuB,SAAS,CAAC;AAE9C,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB"}

package/dist/puzzles/fto/types.js

@@ -0,0 +1,46 @@
+export const FTO_FACES = [
+    "U",
+    "D",
+    "F",
+    "B",
+    "L",
+    "BR",
+    "R",
+    "BL"
+];
+export const FTO_ALL_MOVES = [
+    "U",
+    "U'",
+    "D",
+    "D'",
+    "F",
+    "F'",
+    "B",
+    "B'",
+    "L",
+    "L'",
+    "R",
+    "R'",
+    "BL",
+    "BL'",
+    "BR",
+    "BR'"
+];
+export const FTO_AXIS_MAP = {
+    U: 0,
+    D: 0,
+    F: 1,
+    B: 1,
+    L: 2,
+    BR: 2,
+    R: 3,
+    BL: 3
+};
+export const SCRAMBLE_LENGTH = 30;
+export const FTO_CORNER_COUNT = 6;
+export const FTO_EDGE_COUNT = 12;
+export const FTO_CENTER_ORBIT_COUNT = 12;
+export const FTO_CORNER_PERM_STATES = 360; // 6! / 2
+export const FTO_CORNER_ORI_STATES = 32; // 2^5
+export const FTO_EDGE_PERM_STATES = 239500800; // 12! / 2
+export const FTO_CENTER_ORBIT_STATES = 369600; // C(12,3) * C(9,3) * C(6,3)

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

@@ -0,0 +1,19 @@
+/**
+ * Validation and reachability checking for FTO (Face-Turning Octahedron) states.
+ */
+import type { FtoValidationResult } from "./types.js";
+import { FtoCubie } from "./state.js";
+/**
+ * Validates the physical and group-theoretic reachability constraints of an FTO state:
+ *  - 6 corners with unique indices in 0..5 and even permutation parity (A_6)
+ *  - 6 corner orientations in {0, 1} with sum ≡ 0 (mod 2)
+ *  - 12 edges with unique indices in 0..11 and even permutation parity (A_12)
+ *  - 12 centers in orbit 1 (uf) with exactly 3 of each of the 4 colors (0..3)
+ *  - 12 centers in orbit 2 (rl) with exactly 3 of each of the 4 colors (0..3)
+ */
+export declare function validateFtoState(state: FtoCubie): FtoValidationResult;
+/**
+ * Checks if a state is trivial (solved or 1 move away from solved).
+ */
+export declare function isTrivialFtoState(state: FtoCubie): boolean;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/fto/validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,QAAQ,EAA0C,MAAM,YAAY,CAAC;AAI9E;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,GAAG,mBAAmB,CAsGrE;AAYD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAa1D"}

package/dist/puzzles/fto/validation.js

@@ -0,0 +1,143 @@
+/**
+ * Validation and reachability checking for FTO (Face-Turning Octahedron) states.
+ */
+import { FTO_ALL_MOVES, FTO_CORNER_COUNT, FTO_EDGE_COUNT } from "./types.js";
+import { createSolvedFtoState, isSolvedFtoState } from "./state.js";
+import { applyFtoMove } from "./moves.js";
+import { getPermutationParity } from "./coordinates.js";
+/**
+ * Validates the physical and group-theoretic reachability constraints of an FTO state:
+ *  - 6 corners with unique indices in 0..5 and even permutation parity (A_6)
+ *  - 6 corner orientations in {0, 1} with sum ≡ 0 (mod 2)
+ *  - 12 edges with unique indices in 0..11 and even permutation parity (A_12)
+ *  - 12 centers in orbit 1 (uf) with exactly 3 of each of the 4 colors (0..3)
+ *  - 12 centers in orbit 2 (rl) with exactly 3 of each of the 4 colors (0..3)
+ */
+export function validateFtoState(state) {
+    const errors = [];
+    // 1. Validate corners (cp)
+    if (!Array.isArray(state.cp) || state.cp.length !== FTO_CORNER_COUNT) {
+        errors.push(`Corner permutation array (cp) must have length ${FTO_CORNER_COUNT}`);
+    }
+    else {
+        const cpSeen = new Uint8Array(FTO_CORNER_COUNT);
+        let validRange = true;
+        for (let i = 0; i < FTO_CORNER_COUNT; i++) {
+            const v = state.cp[i];
+            if (v < 0 || v >= FTO_CORNER_COUNT || cpSeen[v] > 0) {
+                validRange = false;
+                break;
+            }
+            cpSeen[v] = 1;
+        }
+        if (!validRange) {
+            errors.push("Corner permutation array (cp) must contain a valid permutation of 0..5");
+        }
+        else if (getPermutationParity(state.cp)) {
+            errors.push("Corner permutation must have even parity (A_6)");
+        }
+    }
+    // 2. Validate corner orientations (co)
+    if (!Array.isArray(state.co) || state.co.length !== FTO_CORNER_COUNT) {
+        errors.push(`Corner orientation array (co) must have length ${FTO_CORNER_COUNT}`);
+    }
+    else {
+        let sum = 0;
+        let validValues = true;
+        for (let i = 0; i < FTO_CORNER_COUNT; i++) {
+            const o = state.co[i];
+            if (o !== 0 && o !== 1) {
+                validValues = false;
+                break;
+            }
+            sum += o;
+        }
+        if (!validValues) {
+            errors.push("Corner orientations must be 0 or 1");
+        }
+        else if ((sum & 1) !== 0) {
+            errors.push("Sum of corner orientations must be even (mod 2)");
+        }
+    }
+    // 3. Validate edges (ep)
+    if (!Array.isArray(state.ep) || state.ep.length !== FTO_EDGE_COUNT) {
+        errors.push(`Edge permutation array (ep) must have length ${FTO_EDGE_COUNT}`);
+    }
+    else {
+        const epSeen = new Uint8Array(FTO_EDGE_COUNT);
+        let validRange = true;
+        for (let i = 0; i < FTO_EDGE_COUNT; i++) {
+            const v = state.ep[i];
+            if (v < 0 || v >= FTO_EDGE_COUNT || epSeen[v] > 0) {
+                validRange = false;
+                break;
+            }
+            epSeen[v] = 1;
+        }
+        if (!validRange) {
+            errors.push("Edge permutation array (ep) must contain a valid permutation of 0..11");
+        }
+        else if (getPermutationParity(state.ep)) {
+            errors.push("Edge permutation must have even parity (A_12)");
+        }
+    }
+    // 4. Validate center orbit 1 (uf)
+    if (!Array.isArray(state.uf) || state.uf.length !== 12) {
+        errors.push("Center orbit 1 (uf) must have length 12");
+    }
+    else {
+        const counts = [0, 0, 0, 0];
+        for (let i = 0; i < 12; i++) {
+            const color = Math.floor(state.uf[i] / 3);
+            if (color >= 0 && color < 4) {
+                counts[color]++;
+            }
+        }
+        if (!counts.every((c) => c === 3)) {
+            errors.push("Center orbit 1 (uf) must contain exactly 3 pieces of each of the 4 colors");
+        }
+    }
+    // 5. Validate center orbit 2 (rl)
+    if (!Array.isArray(state.rl) || state.rl.length !== 12) {
+        errors.push("Center orbit 2 (rl) must have length 12");
+    }
+    else {
+        const counts = [0, 0, 0, 0];
+        for (let i = 0; i < 12; i++) {
+            const color = Math.floor(state.rl[i] / 3);
+            if (color >= 0 && color < 4) {
+                counts[color]++;
+            }
+        }
+        if (!counts.every((c) => c === 3)) {
+            errors.push("Center orbit 2 (rl) must contain exactly 3 pieces of each of the 4 colors");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+let singleMoveStates = null;
+function getSingleMoveStates() {
+    if (!singleMoveStates) {
+        const solved = createSolvedFtoState();
+        singleMoveStates = FTO_ALL_MOVES.map((move) => applyFtoMove(solved, move));
+    }
+    return singleMoveStates;
+}
+/**
+ * Checks if a state is trivial (solved or 1 move away from solved).
+ */
+export function isTrivialFtoState(state) {
+    if (isSolvedFtoState(state)) {
+        return true;
+    }
+    const oneMoveStates = getSingleMoveStates();
+    for (let i = 0; i < oneMoveStates.length; i++) {
+        if (state.isEqual(oneMoveStates[i])) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/puzzles/index.d.ts

@@ -8,4 +8,6 @@ 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";
+export * as fto from "./fto/index.js";
+export * as sq1 from "./sq1/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":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/puzzles/index.ts"],"names":[],"mappings":"AA2BA,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;AAC1C,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC"}

package/dist/puzzles/index.js

@@ -9,6 +9,8 @@ import { cube7ScrambleGenerator } from "./cube7x7/index.js";
 import { pyraminxScrambleGenerator } from "./pyraminx/index.js";
 import { clockScrambleGenerator } from "./clock/index.js";
 import { skewbScrambleGenerator } from "./skewb/index.js";
+import { ftoScrambleGenerator } from "./fto/index.js";
+import { sq1ScrambleGenerator } from "./sq1/index.js";
 registerScrambleGenerator(cube2ScrambleGenerator);
 registerScrambleGenerator(cube3ScrambleGenerator);
 registerScrambleGenerator(cube4ScrambleGenerator);
@@ -19,6 +21,8 @@ registerScrambleGenerator(cube7ScrambleGenerator);
 registerScrambleGenerator(pyraminxScrambleGenerator);
 registerScrambleGenerator(clockScrambleGenerator);
 registerScrambleGenerator(skewbScrambleGenerator);
+registerScrambleGenerator(ftoScrambleGenerator);
+registerScrambleGenerator(sq1ScrambleGenerator);
 export * as cube2 from "./cube2/index.js";
 export * as cube3 from "./cube3/index.js";
 export * as cube4 from "./cube4/index.js";
@@ -29,3 +33,5 @@ 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";
+export * as fto from "./fto/index.js";
+export * as sq1 from "./sq1/index.js";

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

@@ -3,7 +3,7 @@ export type { SkewbMove, SkewbState, SkewbFaceMove, SkewbRandomStateOptions, Ske
 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 { generateRandomSkewbState, generateRandomSkewbStateSync } from "./random-state.js";
 export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
 export { solveSkewb, solveSkewbWithInfo, solveSkewbSync, verifySkewbScramble, verifySkewbSolution, getStateIndex, getStateFromIndex, } from "./solver/index.js";
 export * as solver from "./solver/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/index.ts"],"names":[],"mappings":"AAKA,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,EACL,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAE/E,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/index.ts"],"names":[],"mappings":"AAKA,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,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAC3F,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAE/E,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/skewb/index.js

@@ -5,7 +5,7 @@ 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 { generateRandomSkewbState, generateRandomSkewbStateSync } from "./random-state.js";
 export { createSolvedSkewbFacelets, formatSkewbFacelets, getSkewbFaceOrder, toSkewbFacelets } from "./facelets.js";
 export { solveSkewb, solveSkewbWithInfo, solveSkewbSync, verifySkewbScramble, verifySkewbSolution, getStateIndex, getStateFromIndex, } from "./solver/index.js";
 export * as solver from "./solver/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/random-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AActE,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,UAAU,CAAC,CAGrB;AAID,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAmB9F"}
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/random-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AActE,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,UAAU,CAAC,CAKrB;AAID,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAmB9F"}

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

@@ -1,7 +1,10 @@
 import { createRandomSource } from "../../random/index.js";
 import { ensureTablesLoaded, areSkewbTablesLoaded, getCentersTransition, getOrientationTransition, getPermutationTransition, getStateFromRank, MOVE_COUNT, rankFromComponents, SOLVED_RANK, STATE_COUNT, } from "./solver/index.js";
 export async function generateRandomSkewbState(options = {}) {
-    await ensureTablesLoaded();
+    // Only pay the await/table-load cost when the tables are not already
+    // loaded: in the hot path this runs the sync body directly.
+    if (!areSkewbTablesLoaded())
+        await ensureTablesLoaded();
     return generateRandomSkewbStateSync(options);
 }
 // Synchronous variant for callers that have already ensured the tables are

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

@@ -0,0 +1,12 @@
+import type { Square1Facelets, Square1State } from "./types.js";
+/**
+ * Converts a Square-1 state into a Square1Facelets structure.
+ * Extracting face colors and side rim colors for the 12 slots on top and bottom,
+ * and the middle layer state.
+ */
+export declare function toSquare1Facelets(state: Square1State): Square1Facelets;
+/**
+ * Formats Square1Facelets into a compact serialization string.
+ */
+export declare function formatSquare1Facelets(facelets: Square1Facelets): string;
+//# sourceMappingURL=facelets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CAUtE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAMvE"}

package/dist/puzzles/sq1/facelets.js

@@ -0,0 +1,26 @@
+/**
+ * Converts a Square-1 state into a Square1Facelets structure.
+ * Extracting face colors and side rim colors for the 12 slots on top and bottom,
+ * and the middle layer state.
+ */
+export function toSquare1Facelets(state) {
+    return {
+        top: state.top.map((s) => s.faceColor),
+        topSides: state.top.map((s) => s.sideColor),
+        bottom: state.bottom.map((s) => s.faceColor),
+        bottomSides: state.bottom.map((s) => s.sideColor),
+        middle: state.middle,
+        topSlots: state.top.map((s) => ({ ...s })),
+        bottomSlots: state.bottom.map((s) => ({ ...s })),
+    };
+}
+/**
+ * Formats Square1Facelets into a compact serialization string.
+ */
+export function formatSquare1Facelets(facelets) {
+    const topStr = facelets.top.join("");
+    const topSidesStr = facelets.topSides.join("");
+    const botStr = facelets.bottom.join("");
+    const botSidesStr = facelets.bottomSides.join("");
+    return `${topStr}:${topSidesStr}/${botStr}:${botSidesStr}/${facelets.middle}`;
+}

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

@@ -0,0 +1,10 @@
+export type { Square1Color, Square1Slot, Square1State, Square1Facelets, Square1RandomStateOptions, Square1ValidationResult, Square1Move } from "./types.js";
+export { createSolvedSquare1State, cloneSquare1State, statesEqual, isSolvedSquare1State } from "./state.js";
+export { isSliceable, applyTopTurn, applyBottomTurn, applyTurn, applySlice, getValidTurns, parseSquare1Algorithm, formatSquare1Algorithm, applySquare1Move, applySquare1Algorithm, invertSquare1Move, invertSquare1Algorithm } from "./moves.js";
+export { toSquare1Facelets, formatSquare1Facelets } from "./facelets.js";
+export { validateSquare1State, isTrivialSquare1State } from "./validation.js";
+export { generateRandomSquare1State } from "./random-state.js";
+export { sq1ScrambleGenerator, generateSquare1Scramble, generateSquare1ScrambleSync } from "./scrambler.js";
+export { FullCube, fullCubeToState, stateToFullCube, Square1Searcher, ensureSquare1TablesLoaded, areSquare1TablesLoaded, getSquare1SolverTablesSync, generateSquare1SolverTables, INVERSE_SOLUTION, type Square1Solution, type Square1SolverTables } from "./solver/index.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/index.ts"],"names":[],"mappings":"AAKA,YAAY,EACV,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,eAAe,EACf,yBAAyB,EACzB,uBAAuB,EACvB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,WAAW,EACX,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,WAAW,EACX,YAAY,EACZ,eAAe,EACf,SAAS,EACT,UAAU,EACV,aAAa,EACb,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,0BAA0B,EAC3B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,QAAQ,EACR,eAAe,EACf,eAAe,EACf,eAAe,EACf,yBAAyB,EACzB,sBAAsB,EACtB,0BAA0B,EAC1B,2BAA2B,EAC3B,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/sq1/index.js

@@ -0,0 +1,11 @@
+import { registerScrambleGenerator } from "../../core/index.js";
+import { sq1ScrambleGenerator } from "./scrambler.js";
+registerScrambleGenerator(sq1ScrambleGenerator);
+export { createSolvedSquare1State, cloneSquare1State, statesEqual, isSolvedSquare1State } from "./state.js";
+export { isSliceable, applyTopTurn, applyBottomTurn, applyTurn, applySlice, getValidTurns, parseSquare1Algorithm, formatSquare1Algorithm, applySquare1Move, applySquare1Algorithm, invertSquare1Move, invertSquare1Algorithm } from "./moves.js";
+export { toSquare1Facelets, formatSquare1Facelets } from "./facelets.js";
+export { validateSquare1State, isTrivialSquare1State } from "./validation.js";
+export { generateRandomSquare1State } from "./random-state.js";
+export { sq1ScrambleGenerator, generateSquare1Scramble, generateSquare1ScrambleSync } from "./scrambler.js";
+export { FullCube, fullCubeToState, stateToFullCube, Square1Searcher, ensureSquare1TablesLoaded, areSquare1TablesLoaded, getSquare1SolverTablesSync, generateSquare1SolverTables, INVERSE_SOLUTION } from "./solver/index.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";

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

@@ -0,0 +1,55 @@
+import type { Square1State } from "./types.js";
+/**
+ * Checks whether the puzzle is in a state where a slice (/) turn is physically possible.
+ * Both top and bottom layers must have clean cuts at 11/0 (Back seam) and 5/6 (Front seam).
+ */
+export declare function isSliceable(state: Square1State): boolean;
+/**
+ * Applies a clockwise turn of the top layer by u * 30 degrees (u in range -5..6 or any integer).
+ */
+export declare function applyTopTurn(state: Square1State, u: number): Square1State;
+/**
+ * Applies a turn of the bottom layer by d * 30 degrees (d in range -5..6 or any integer).
+ */
+export declare function applyBottomTurn(state: Square1State, d: number): Square1State;
+/**
+ * Applies simultaneous top (u) and bottom (d) turns.
+ */
+export declare function applyTurn(state: Square1State, u: number, d: number): Square1State;
+/**
+ * Applies a slice (/) move, swapping the right half of top (slots 6..11)
+ * with the right half of bottom (slots 0..5).
+ */
+export declare function applySlice(state: Square1State): Square1State;
+/**
+ * Returns all (u, d) turns from the current state that lead to a sliceable state.
+ * u and d are within range [-5, 6].
+ */
+export declare function getValidTurns(state: Square1State): [number, number][];
+/**
+ * Parses a Square-1 algorithm string into individual move tokens.
+ * Supported tokens: "/", "(u, d)", "(u, d) /", etc.
+ */
+export declare function parseSquare1Algorithm(alg: string): string[];
+/**
+ * Formats an array of Square-1 move tokens into standard WCA notation.
+ */
+export declare function formatSquare1Algorithm(moves: string[]): string;
+/**
+ * Applies a single move token to the Square-1 state.
+ * Token can be "/", "(u, d)", or "(u, d) /".
+ */
+export declare function applySquare1Move(state: Square1State, move: string): Square1State;
+/**
+ * Applies a full algorithm to a Square-1 state.
+ */
+export declare function applySquare1Algorithm(state: Square1State, alg: string | string[]): Square1State;
+/**
+ * Inverts a single Square-1 move token.
+ */
+export declare function invertSquare1Move(move: string): string;
+/**
+ * Inverts an entire Square-1 algorithm sequence.
+ */
+export declare function invertSquare1Algorithm(alg: string | string[]): string[];
+//# sourceMappingURL=moves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/moves.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAkBxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAazE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAa5E;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAiBjF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAoB5D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAarE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAsB3D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAE9D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAqBhF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GACrB,YAAY,CAOd;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAatD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAwBvE"}