@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist/puzzles/sq1/solver/tables.js

@@ -0,0 +1,66 @@
+import { generateShapeTables } from "./shape.js";
+import { generateSquareTables } from "./square.js";
+let cachedTables;
+let tableLoadPromise;
+export function areSquare1TablesLoaded() {
+    return cachedTables !== undefined;
+}
+export function getSquare1SolverTablesSync() {
+    if (!cachedTables) {
+        // Check if running in Node.js
+        if (typeof process !== "undefined" && process.versions?.node) {
+            try {
+                const { readGeneratedSquare1SolverTables } = require("./node-loader.js");
+                cachedTables = readGeneratedSquare1SolverTables();
+                return cachedTables;
+            }
+            catch {
+                // Fall back to on-the-fly generation
+            }
+        }
+        // Generate on the fly
+        cachedTables = generateSquare1SolverTables();
+    }
+    return cachedTables;
+}
+export async function ensureSquare1TablesLoaded(baseUrl) {
+    if (cachedTables) {
+        return cachedTables;
+    }
+    if (tableLoadPromise) {
+        return tableLoadPromise;
+    }
+    tableLoadPromise = (async () => {
+        if (typeof window !== "undefined" || typeof self !== "undefined" && typeof self.importScripts === "function") {
+            try {
+                const { loadBrowserTables } = await import("./browser-loader.js");
+                cachedTables = await loadBrowserTables(baseUrl);
+                return cachedTables;
+            }
+            catch {
+                // Fall back to on-the-fly generation
+            }
+        }
+        cachedTables = getSquare1SolverTablesSync();
+        return cachedTables;
+    })();
+    return tableLoadPromise;
+}
+export function generateSquare1SolverTables() {
+    const shape = generateShapeTables();
+    const square = generateSquareTables();
+    return {
+        shapeIdx: shape.shapeIdx,
+        shapePrun: shape.shapePrun,
+        shapeTopMove: shape.shapeTopMove,
+        shapeBottomMove: shape.shapeBottomMove,
+        shapeTwistMove: shape.shapeTwistMove,
+        squareTwistMove: square.squareTwistMove,
+        squareTopMove: square.squareTopMove,
+        squareBottomMove: square.squareBottomMove,
+        squarePrun: square.squarePrun
+    };
+}
+export function setCachedSquare1Tables(tables) {
+    cachedTables = tables;
+}

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

@@ -0,0 +1,10 @@
+import type { Square1Slot, Square1State } from "./types.js";
+export declare const WEDGE_DEFS: Square1Slot[];
+/**
+ * Creates a solved Square-1 state aligned with the standard WCA visualization.
+ */
+export declare function createSolvedSquare1State(): Square1State;
+export declare function cloneSquare1State(state: Square1State): Square1State;
+export declare function statesEqual(a: Square1State, b: Square1State): boolean;
+export declare function isSolvedSquare1State(state: Square1State): boolean;
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE5D,eAAO,MAAM,UAAU,EAAE,WAAW,EA2BnC,CAAC;AAEF;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,YAAY,CAQvD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAMnE;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CA0BrE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAGjE"}

package/dist/puzzles/sq1/state.js

@@ -0,0 +1,74 @@
+export const WEDGE_DEFS = [
+    // Top layer (0..11) - Yellow (D in WCA_COLORS):
+    { pieceId: 0, isCorner: true, partIndex: 0, faceColor: "D", sideColor: "R" }, // 0
+    { pieceId: 0, isCorner: true, partIndex: 1, faceColor: "D", sideColor: "B" }, // 1
+    { pieceId: 9, isCorner: false, partIndex: 0, faceColor: "D", sideColor: "B" }, // 2
+    { pieceId: 1, isCorner: true, partIndex: 0, faceColor: "D", sideColor: "B" }, // 3
+    { pieceId: 1, isCorner: true, partIndex: 1, faceColor: "D", sideColor: "L" }, // 4
+    { pieceId: 10, isCorner: false, partIndex: 0, faceColor: "D", sideColor: "L" }, // 5
+    { pieceId: 2, isCorner: true, partIndex: 0, faceColor: "D", sideColor: "L" }, // 6
+    { pieceId: 2, isCorner: true, partIndex: 1, faceColor: "D", sideColor: "F" }, // 7
+    { pieceId: 11, isCorner: false, partIndex: 0, faceColor: "D", sideColor: "F" }, // 8
+    { pieceId: 3, isCorner: true, partIndex: 0, faceColor: "D", sideColor: "F" }, // 9
+    { pieceId: 3, isCorner: true, partIndex: 1, faceColor: "D", sideColor: "R" }, // 10
+    { pieceId: 8, isCorner: false, partIndex: 0, faceColor: "D", sideColor: "R" }, // 11
+    // Bottom layer (12..23) - White (U in WCA_COLORS):
+    { pieceId: 12, isCorner: false, partIndex: 0, faceColor: "U", sideColor: "R" }, // 12
+    { pieceId: 4, isCorner: true, partIndex: 0, faceColor: "U", sideColor: "R" }, // 13
+    { pieceId: 4, isCorner: true, partIndex: 1, faceColor: "U", sideColor: "F" }, // 14
+    { pieceId: 13, isCorner: false, partIndex: 0, faceColor: "U", sideColor: "F" }, // 15
+    { pieceId: 5, isCorner: true, partIndex: 0, faceColor: "U", sideColor: "F" }, // 16
+    { pieceId: 5, isCorner: true, partIndex: 1, faceColor: "U", sideColor: "L" }, // 17
+    { pieceId: 14, isCorner: false, partIndex: 0, faceColor: "U", sideColor: "L" }, // 18
+    { pieceId: 6, isCorner: true, partIndex: 0, faceColor: "U", sideColor: "L" }, // 19
+    { pieceId: 6, isCorner: true, partIndex: 1, faceColor: "U", sideColor: "B" }, // 20
+    { pieceId: 15, isCorner: false, partIndex: 0, faceColor: "U", sideColor: "B" }, // 21
+    { pieceId: 7, isCorner: true, partIndex: 0, faceColor: "U", sideColor: "B" }, // 22
+    { pieceId: 7, isCorner: true, partIndex: 1, faceColor: "U", sideColor: "R" }, // 23
+];
+/**
+ * Creates a solved Square-1 state aligned with the standard WCA visualization.
+ */
+export function createSolvedSquare1State() {
+    const top = Array.from({ length: 12 }, (_, i) => ({ ...WEDGE_DEFS[i] }));
+    const bottom = Array.from({ length: 12 }, (_, i) => ({ ...WEDGE_DEFS[12 + i] }));
+    return {
+        top,
+        bottom,
+        middle: 0,
+    };
+}
+export function cloneSquare1State(state) {
+    return {
+        top: state.top.map((s) => ({ ...s })),
+        bottom: state.bottom.map((s) => ({ ...s })),
+        middle: state.middle,
+    };
+}
+export function statesEqual(a, b) {
+    if (a.middle !== b.middle)
+        return false;
+    for (let i = 0; i < 12; i++) {
+        const at = a.top[i];
+        const bt = b.top[i];
+        if (at.pieceId !== bt.pieceId ||
+            at.partIndex !== bt.partIndex ||
+            at.faceColor !== bt.faceColor ||
+            at.sideColor !== bt.sideColor) {
+            return false;
+        }
+        const ab = a.bottom[i];
+        const bb = b.bottom[i];
+        if (ab.pieceId !== bb.pieceId ||
+            ab.partIndex !== bb.partIndex ||
+            ab.faceColor !== bb.faceColor ||
+            ab.sideColor !== bb.sideColor) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isSolvedSquare1State(state) {
+    const solved = createSolvedSquare1State();
+    return statesEqual(state, solved);
+}

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

@@ -0,0 +1,32 @@
+export type Square1Color = "U" | "D" | "F" | "R" | "B" | "L";
+export interface Square1Slot {
+    pieceId: number;
+    isCorner: boolean;
+    partIndex: 0 | 1;
+    faceColor: Square1Color;
+    sideColor: Square1Color;
+}
+export interface Square1State {
+    top: Square1Slot[];
+    bottom: Square1Slot[];
+    middle: number;
+}
+export interface Square1Facelets {
+    top: string[];
+    topSides: string[];
+    bottom: string[];
+    bottomSides: string[];
+    middle: number;
+    topSlots?: Square1Slot[];
+    bottomSlots?: Square1Slot[];
+}
+export interface Square1RandomStateOptions {
+    seed?: string | number;
+    rejectTrivial?: boolean;
+}
+export interface Square1ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export type Square1Move = string;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE7D,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC;IACjB,SAAS,EAAE,YAAY,CAAC;IACxB,SAAS,EAAE,YAAY,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,WAAW,EAAE,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,WAAW,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC"}

package/dist/puzzles/sq1/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import type { Square1State, Square1ValidationResult } from "./types.js";
+/**
+ * Validates whether a given Square-1 state is physically and mathematically legal.
+ */
+export declare function validateSquare1State(state: Square1State): Square1ValidationResult;
+export declare function isTrivialSquare1State(state: Square1State): boolean;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAIxE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,uBAAuB,CA+DjF;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAElE"}

package/dist/puzzles/sq1/validation.js

@@ -0,0 +1,64 @@
+import { isSolvedSquare1State } from "./state.js";
+/**
+ * Validates whether a given Square-1 state is physically and mathematically legal.
+ */
+export function validateSquare1State(state) {
+    const errors = [];
+    if (!state || !Array.isArray(state.top) || !Array.isArray(state.bottom)) {
+        return { valid: false, errors: ["Invalid state structure: top and bottom must be arrays."] };
+    }
+    if (state.top.length !== 12) {
+        errors.push(`Top layer must have 12 slots, found ${state.top.length}.`);
+    }
+    if (state.bottom.length !== 12) {
+        errors.push(`Bottom layer must have 12 slots, found ${state.bottom.length}.`);
+    }
+    if (state.middle !== 0 && state.middle !== 1) {
+        errors.push(`Middle layer must be 0 or 1, found ${state.middle}.`);
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    // Count pieces
+    const cornerParts = {};
+    const edges = {};
+    const checkSlot = (slot, layer, idx) => {
+        if (typeof slot.pieceId !== "number" || typeof slot.isCorner !== "boolean") {
+            errors.push(`Invalid slot at ${layer}[${idx}].`);
+            return;
+        }
+        if (slot.isCorner) {
+            if (slot.pieceId < 0 || slot.pieceId > 7) {
+                errors.push(`Invalid corner pieceId ${slot.pieceId} at ${layer}[${idx}].`);
+            }
+            cornerParts[slot.pieceId] = (cornerParts[slot.pieceId] || 0) + 1;
+        }
+        else {
+            if (slot.pieceId < 8 || slot.pieceId > 15) {
+                errors.push(`Invalid edge pieceId ${slot.pieceId} at ${layer}[${idx}].`);
+            }
+            edges[slot.pieceId] = (edges[slot.pieceId] || 0) + 1;
+        }
+    };
+    for (let i = 0; i < 12; i++)
+        checkSlot(state.top[i], "top", i);
+    for (let i = 0; i < 12; i++)
+        checkSlot(state.bottom[i], "bottom", i);
+    for (let c = 0; c < 8; c++) {
+        if (cornerParts[c] !== 2) {
+            errors.push(`Corner ${c} must appear exactly twice (2 parts), found ${cornerParts[c] || 0}.`);
+        }
+    }
+    for (let e = 8; e <= 15; e++) {
+        if (edges[e] !== 1) {
+            errors.push(`Edge ${e} must appear exactly once, found ${edges[e] || 0}.`);
+        }
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return { valid: true, errors: [] };
+}
+export function isTrivialSquare1State(state) {
+    return isSolvedSquare1State(state);
+}

package/dist/random/prng.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prng.d.ts","sourceRoot":"","sources":["../../src/random/prng.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;CACnC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAOvE"}
+{"version":3,"file":"prng.d.ts","sourceRoot":"","sources":["../../src/random/prng.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;CACnC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAOvE"}

package/dist/random/prng.js

@@ -1,4 +1,3 @@
-import { randomBytes } from "node:crypto";
 // 4096 bytes per refill (~682 values per syscall).
 const CRYPTO_BUFFER_BYTES = 4096;
 // Shared unseeded source: the crypto refill costs a syscall per buffer, so a
@@ -16,10 +15,16 @@ class CryptoRandomSource {
     buffer = null;
     offset = 0;
     next() {
-        // Batch the crypto calls: one randomBytes per move is ~2 orders of
-        // magnitude slower in Node (syscall per call). Refill lazily.
         if (this.buffer === null || this.offset + 6 > CRYPTO_BUFFER_BYTES) {
-            this.buffer = randomBytes(CRYPTO_BUFFER_BYTES);
+            this.buffer = new Uint8Array(CRYPTO_BUFFER_BYTES);
+            if (typeof globalThis.crypto?.getRandomValues === "function") {
+                globalThis.crypto.getRandomValues(this.buffer);
+            }
+            else {
+                for (let i = 0; i < CRYPTO_BUFFER_BYTES; i++) {
+                    this.buffer[i] = Math.floor(Math.random() * 256);
+                }
+            }
             this.offset = 0;
         }
         const bytes = this.buffer;

package/dist-cjs/core/api.js

@@ -75,12 +75,22 @@ async function initializeScrambler(baseUrl, eventId) {
         const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/skewb/solver/browser-loader.js")));
         await loadBrowserTables(baseUrl);
     }
+    else if (eventId === "sq1") {
+        const { loadBrowserTables } = await Promise.resolve().then(() => __importStar(require("../puzzles/sq1/solver/browser-loader.js")));
+        await loadBrowserTables(baseUrl);
+    }
+    else if (eventId === "444") {
+        const { loadCube4ReductionTablesBrowser } = await Promise.resolve().then(() => __importStar(require("../puzzles/cube4/reduction/browser-loader.js")));
+        await loadCube4ReductionTablesBrowser(baseUrl);
+    }
     else if (!eventId) {
         await Promise.all([
             Promise.resolve().then(() => __importStar(require("../puzzles/cube2/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
             Promise.resolve().then(() => __importStar(require("../puzzles/cube3/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
             Promise.resolve().then(() => __importStar(require("../puzzles/pyraminx/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
-            Promise.resolve().then(() => __importStar(require("../puzzles/skewb/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl))
+            Promise.resolve().then(() => __importStar(require("../puzzles/skewb/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
+            Promise.resolve().then(() => __importStar(require("../puzzles/sq1/solver/browser-loader.js"))).then((m) => m.loadBrowserTables(baseUrl)),
+            Promise.resolve().then(() => __importStar(require("../puzzles/cube4/reduction/browser-loader.js"))).then((m) => m.loadCube4ReductionTablesBrowser(baseUrl))
         ]);
     }
 }

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

@@ -3,7 +3,7 @@
 // cube4 barrel exports
 // ---------------------------------------------------------------------------
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.getCube4FaceOrder = exports.formatCube4Facelets = exports.toCube4Facelets = exports.generateCube4Scramble = exports.cube4ScrambleGenerator = exports.FACE_MOVE_EFFECTS = exports.parseMove = exports.parseCube4Move = exports.parseCube4Algorithm = exports.formatCube4Algorithm = exports.invertCube4Algorithm = exports.invertCube4Move = exports.applyCube4Algorithm = exports.applyCube4Move = exports.areWingsPaired = exports.areCentersReduced = exports.isSolvedCube4State = exports.cube4StatesEqual = exports.cloneCube4State = exports.createSolvedCube4State = exports.CUBE4_OUTER_MOVES = exports.CUBE4_ALL_MOVES = exports.CUBE4_FACE_MOVES = exports.B = exports.L = exports.D = exports.F = exports.R = exports.U = exports.CENTERS_PER_FACE = exports.FACE_COUNT = exports.CENTER_COUNT = exports.WING_COUNT = exports.CORNER_COUNT = void 0;
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.getCube4FaceOrder = exports.formatCube4Facelets = exports.toCube4Facelets = exports.isAllowedRandomCube4State = exports.isTrivialCube4State = exports.isOneMoveFromSolvedCube4State = exports.validateCube4State = exports.generateRandomCube4State = exports.FACE_MOVE_EFFECTS = exports.parseMove = exports.parseCube4Move = exports.parseCube4Algorithm = exports.formatCube4Algorithm = exports.invertCube4Algorithm = exports.invertCube4Move = exports.applyCube4Algorithm = exports.applyCube4Move = exports.generateCube4Scramble = exports.cube4ScrambleGenerator = exports.areWingsPaired = exports.areCentersReduced = exports.isSolvedCube4State = exports.cube4StatesEqual = exports.cloneCube4State = exports.createSolvedCube4State = exports.CUBE4_OUTER_MOVES = exports.CUBE4_ALL_MOVES = exports.CUBE4_FACE_MOVES = exports.B = exports.L = exports.D = exports.F = exports.R = exports.U = exports.CENTERS_PER_FACE = exports.FACE_COUNT = exports.CENTER_COUNT = exports.WING_COUNT = exports.CORNER_COUNT = 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.cube4ScrambleGenerator);
@@ -29,6 +29,9 @@ Object.defineProperty(exports, "cube4StatesEqual", { enumerable: true, get: func
 Object.defineProperty(exports, "isSolvedCube4State", { enumerable: true, get: function () { return state_js_1.isSolvedCube4State; } });
 Object.defineProperty(exports, "areCentersReduced", { enumerable: true, get: function () { return state_js_1.areCentersReduced; } });
 Object.defineProperty(exports, "areWingsPaired", { enumerable: true, get: function () { return state_js_1.areWingsPaired; } });
+var scrambler_js_2 = require("./scrambler.js");
+Object.defineProperty(exports, "cube4ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.cube4ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube4Scramble", { enumerable: true, get: function () { return scrambler_js_2.generateCube4Scramble; } });
 var moves_js_1 = require("./moves.js");
 Object.defineProperty(exports, "applyCube4Move", { enumerable: true, get: function () { return moves_js_1.applyCube4Move; } });
 Object.defineProperty(exports, "applyCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.applyCube4Algorithm; } });
@@ -39,9 +42,13 @@ Object.defineProperty(exports, "parseCube4Algorithm", { enumerable: true, get: f
 Object.defineProperty(exports, "parseCube4Move", { enumerable: true, get: function () { return moves_js_1.parseCube4Move; } });
 Object.defineProperty(exports, "parseMove", { enumerable: true, get: function () { return moves_js_1.parseMove; } });
 Object.defineProperty(exports, "FACE_MOVE_EFFECTS", { enumerable: true, get: function () { return moves_js_1.FACE_MOVE_EFFECTS; } });
-var scrambler_js_2 = require("./scrambler.js");
-Object.defineProperty(exports, "cube4ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.cube4ScrambleGenerator; } });
-Object.defineProperty(exports, "generateCube4Scramble", { enumerable: true, get: function () { return scrambler_js_2.generateCube4Scramble; } });
+var random_state_js_1 = require("./random-state.js");
+Object.defineProperty(exports, "generateRandomCube4State", { enumerable: true, get: function () { return random_state_js_1.generateRandomCube4State; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "validateCube4State", { enumerable: true, get: function () { return validation_js_1.validateCube4State; } });
+Object.defineProperty(exports, "isOneMoveFromSolvedCube4State", { enumerable: true, get: function () { return validation_js_1.isOneMoveFromSolvedCube4State; } });
+Object.defineProperty(exports, "isTrivialCube4State", { enumerable: true, get: function () { return validation_js_1.isTrivialCube4State; } });
+Object.defineProperty(exports, "isAllowedRandomCube4State", { enumerable: true, get: function () { return validation_js_1.isAllowedRandomCube4State; } });
 var facelets_js_1 = require("./facelets.js");
 Object.defineProperty(exports, "toCube4Facelets", { enumerable: true, get: function () { return facelets_js_1.toCube4Facelets; } });
 Object.defineProperty(exports, "formatCube4Facelets", { enumerable: true, get: function () { return facelets_js_1.formatCube4Facelets; } });

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

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Uniform random-state generation for 4x4x4.
+ *
+ * Samples uniformly from the reachable states of the normal (non-super) 4x4:
+ *  - corner permutation 8! + orientation with sum ≡ 0 (mod 3)
+ *  - wing permutation 24! (wings have no orientation)
+ *  - centers: 24!/(4!)^6 (any arrangement with 4 centers of each color)
+ *
+ * On a normal 4x4 the corner and wing permutation parities are independent
+ * (a single face turn changes corner parity while leaving wing parity even),
+ * so no cross-parity constraint is applied here — the reduction solver must
+ * be able to reduce states with all four parity combinations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomCube4State = generateRandomCube4State;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+const validation_js_1 = require("./validation.js");
+function generateRandomCube4State(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        // The state is legal by construction (permutations shuffled, corner
+        // orientation sum fixed, 4 centers per color), so the only meaningful
+        // rejection is the trivial set (solved + the 36 single-move states).
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || !(0, validation_js_1.isTrivialCube4State)(state)) {
+            return state;
+        }
+    }
+    throw new Error("Unable to generate a non-trivial random 4x4 state.");
+}
+function createLegalRandomState(random) {
+    const cp = shuffledRange(types_js_1.CORNER_COUNT, random);
+    const wp = shuffledRange(types_js_1.WING_COUNT, random);
+    return {
+        cp,
+        co: randomOrientations(types_js_1.CORNER_COUNT, 3, random),
+        wp,
+        centers: shuffledCenters(random)
+    };
+}
+function shuffledRange(length, random) {
+    const values = Uint8Array.from({ length }, (_, index) => index);
+    for (let index = values.length - 1; index > 0; index -= 1) {
+        const swapIndex = random.nextInt(index + 1);
+        const temporary = values[index];
+        values[index] = values[swapIndex];
+        values[swapIndex] = temporary;
+    }
+    return values;
+}
+function randomOrientations(length, modulo, random) {
+    const orientations = new Uint8Array(length);
+    let total = 0;
+    for (let index = 0; index < length - 1; index += 1) {
+        const orientation = random.nextInt(modulo);
+        orientations[index] = orientation;
+        total += orientation;
+    }
+    orientations[length - 1] = (modulo - (total % modulo)) % modulo;
+    return orientations;
+}
+function shuffledCenters(random) {
+    const centers = new Uint8Array(types_js_1.CENTER_COUNT);
+    for (let face = 0; face < types_js_1.FACE_COUNT; face += 1) {
+        for (let index = 0; index < types_js_1.CENTERS_PER_FACE; index += 1) {
+            centers[face * types_js_1.CENTERS_PER_FACE + index] = face;
+        }
+    }
+    for (let index = centers.length - 1; index > 0; index -= 1) {
+        const swapIndex = random.nextInt(index + 1);
+        const temporary = centers[index];
+        centers[index] = centers[swapIndex];
+        centers[swapIndex] = temporary;
+    }
+    return centers;
+}

package/dist-cjs/puzzles/cube4/reduction/browser-loader.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Browser loader for the cube4 reduction tables (the committed .bin files).
+ * The manifests are per-phase (`center1-manifest.json`, ...).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedCube4Tables = getCachedCube4Tables;
+exports.clearCachedCube4Tables = clearCachedCube4Tables;
+exports.loadCube4ReductionTablesBrowser = loadCube4ReductionTablesBrowser;
+const edge3_js_1 = require("./edge3.js");
+const compressed_fetch_js_1 = require("../../shared/compressed-fetch.js");
+const GENERATED_DIRECTORY = "puzzles/cube4/reduction/generated";
+const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
+let cachedTables;
+function getCachedCube4Tables() {
+    return cachedTables;
+}
+function clearCachedCube4Tables() {
+    cachedTables = undefined;
+}
+function resolveBaseUrl(provided) {
+    if (provided) {
+        return provided.replace(/\/$/, "");
+    }
+    if (typeof document !== "undefined") {
+        const script = document.currentScript;
+        if (script?.src) {
+            const base = new URL(".", script.src).href;
+            return base.replace(/\/$/, "");
+        }
+    }
+    return ".";
+}
+async function loadCube4ReductionTablesBrowser(baseUrl) {
+    if (cachedTables) {
+        return cachedTables;
+    }
+    const resolved = resolveBaseUrl(baseUrl);
+    const [center1, center2, center3, edge3] = await Promise.all([
+        loadCenter1(resolved),
+        loadCenter2(resolved),
+        loadCenter3(resolved),
+        loadEdge3(resolved)
+    ]);
+    cachedTables = { center1, center2, center3, edge3 };
+    return cachedTables;
+}
+async function fetchJson(baseUrl, file) {
+    const url = `${baseUrl}/${GENERATED_DIRECTORY}/${file}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load ${file}: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+async function loadCenter1(baseUrl) {
+    const manifest = await fetchJson(baseUrl, "center1-manifest.json");
+    const [distanceBuffer, moveMapsBuffer] = await Promise.all([
+        (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.distanceTable.file, { cacheName: CACHE_NAME, compressed: manifest.distanceTable.compressed !== false }),
+        (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.moveMaps.file, { cacheName: CACHE_NAME, compressed: manifest.moveMaps.compressed !== false })
+    ]);
+    return {
+        distance: new Uint8Array(distanceBuffer),
+        moveMaps: new Int32Array(moveMapsBuffer)
+    };
+}
+async function loadCenter2(baseUrl) {
+    const manifest = await fetchJson(baseUrl, "center2-manifest.json");
+    const [ctMoveBuffer, rlMoveBuffer, pruningBuffer] = await Promise.all([
+        (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.ctMove.file, { cacheName: CACHE_NAME, compressed: manifest.ctMove.compressed !== false }),
+        (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.rlMove.file, { cacheName: CACHE_NAME, compressed: manifest.rlMove.compressed !== false }),
+        (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.pruningTable.file, { cacheName: CACHE_NAME, compressed: manifest.pruningTable.compressed !== false })
+    ]);
+    const ctMove = new Int32Array(ctMoveBuffer);
+    const rlMove = new Int32Array(rlMoveBuffer);
+    const pruningPacked = new Uint8Array(pruningBuffer);
+    const pruning = new Uint8Array(450450);
+    for (let i = 0; i < 450450; i++) {
+        const byte = pruningPacked[i >> 1];
+        pruning[i] = (i & 1) === 0 ? byte & 0x0f : byte >> 4;
+    }
+    return { ctMove, rlMove, pruning };
+}
+async function loadCenter3(baseUrl) {
+    const manifest = await fetchJson(baseUrl, "center3-manifest.json");
+    const [moveTableBuffer, pruningBuffer] = await Promise.all([
+        (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.moveTable.file, { cacheName: CACHE_NAME, compressed: manifest.moveTable.compressed !== false }),
+        (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.pruningTable.file, { cacheName: CACHE_NAME, compressed: manifest.pruningTable.compressed !== false })
+    ]);
+    return {
+        moveTable: new Int32Array(moveTableBuffer),
+        pruning: new Uint8Array(pruningBuffer)
+    };
+}
+async function loadEdge3(baseUrl) {
+    const manifest = await fetchJson(baseUrl, "edge3-manifest.json");
+    const distancesBuffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.distances.file, { cacheName: CACHE_NAME, compressed: manifest.distances.compressed !== false });
+    const distances = new Uint8Array(distancesBuffer);
+    return { distances, distanceOfEdge: (0, edge3_js_1.edge3DistanceLookup)(distances) };
+}