@cubingcenter/scrambler 0.5.3 → 0.6.0

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

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areSquare1TablesLoaded = areSquare1TablesLoaded;
+exports.getSquare1SolverTablesSync = getSquare1SolverTablesSync;
+exports.ensureSquare1TablesLoaded = ensureSquare1TablesLoaded;
+exports.generateSquare1SolverTables = generateSquare1SolverTables;
+exports.setCachedSquare1Tables = setCachedSquare1Tables;
+const shape_js_1 = require("./shape.js");
+const square_js_1 = require("./square.js");
+let cachedTables;
+let tableLoadPromise;
+function areSquare1TablesLoaded() {
+    return cachedTables !== undefined;
+}
+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;
+}
+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 Promise.resolve().then(() => __importStar(require("./browser-loader.js")));
+                cachedTables = await loadBrowserTables(baseUrl);
+                return cachedTables;
+            }
+            catch {
+                // Fall back to on-the-fly generation
+            }
+        }
+        cachedTables = getSquare1SolverTablesSync();
+        return cachedTables;
+    })();
+    return tableLoadPromise;
+}
+function generateSquare1SolverTables() {
+    const shape = (0, shape_js_1.generateShapeTables)();
+    const square = (0, square_js_1.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
+    };
+}
+function setCachedSquare1Tables(tables) {
+    cachedTables = tables;
+}

package/dist-cjs/puzzles/sq1/state.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEDGE_DEFS = void 0;
+exports.createSolvedSquare1State = createSolvedSquare1State;
+exports.cloneSquare1State = cloneSquare1State;
+exports.statesEqual = statesEqual;
+exports.isSolvedSquare1State = isSolvedSquare1State;
+exports.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.
+ */
+function createSolvedSquare1State() {
+    const top = Array.from({ length: 12 }, (_, i) => ({ ...exports.WEDGE_DEFS[i] }));
+    const bottom = Array.from({ length: 12 }, (_, i) => ({ ...exports.WEDGE_DEFS[12 + i] }));
+    return {
+        top,
+        bottom,
+        middle: 0,
+    };
+}
+function cloneSquare1State(state) {
+    return {
+        top: state.top.map((s) => ({ ...s })),
+        bottom: state.bottom.map((s) => ({ ...s })),
+        middle: state.middle,
+    };
+}
+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;
+}
+function isSolvedSquare1State(state) {
+    const solved = createSolvedSquare1State();
+    return statesEqual(state, solved);
+}

package/dist-cjs/puzzles/sq1/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/puzzles/sq1/validation.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSquare1State = validateSquare1State;
+exports.isTrivialSquare1State = isTrivialSquare1State;
+const state_js_1 = require("./state.js");
+/**
+ * Validates whether a given Square-1 state is physically and mathematically legal.
+ */
+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: [] };
+}
+function isTrivialSquare1State(state) {
+    return (0, state_js_1.isSolvedSquare1State)(state);
+}

package/dist-cjs/random/prng.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRandomSource = createRandomSource;
-const node_crypto_1 = require("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
@@ -19,10 +18,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 = (0, node_crypto_1.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/package.json

@@ -1,10 +1,32 @@
 {
   "name": "@cubingcenter/scrambler",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Extensible scramble generation toolkit for CubingCenter projects.",
   "type": "module",
   "license": "MIT",
   "author": "CubingCenter",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diegoagdiaz/cubingcenter-scrambler.git"
+  },
+  "homepage": "https://github.com/diegoagdiaz/cubingcenter-scrambler#readme",
+  "bugs": {
+    "url": "https://github.com/diegoagdiaz/cubingcenter-scrambler/issues"
+  },
+  "keywords": [
+    "cubing",
+    "scrambler",
+    "wca",
+    "rubiks-cube",
+    "speedcubing",
+    "rubiks",
+    "puzzle"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "bin": {
     "cubingcenter-scrambler": "./dist/cli/index.js"
   },
@@ -29,12 +51,18 @@
     "examples",
     "README.md"
   ],
+  "devDependencies": {
+    "@cubingcenter/viz": "link:../cubingcenter-viz",
+    "@types/node": "^24.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0"
+  },
   "scripts": {
     "build": "node scripts/clean.cjs && tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node scripts/write-cjs-package.cjs && node scripts/copy-assets.cjs",
     "test": "node --test --import tsx test/*.test.ts",
     "lint": "tsc -p tsconfig.json --noEmit",
     "package:check": "pnpm build && node scripts/check-package.cjs",
-    "verify": "pnpm lint && pnpm test && pnpm build && pnpm cube3:tables:check && pnpm cube2:tables:check && pnpm pyraminx:tables:check && pnpm skewb:tables:check && pnpm package:check",
+    "verify": "pnpm lint && pnpm test && pnpm build && pnpm cube3:tables:check && pnpm cube2:tables:check && pnpm pyraminx:tables:check && pnpm skewb:tables:check && pnpm sq1:tables:check && pnpm package:check",
     "dev": "tsx src/cli/index.ts",
     "cube3:tables": "node --import tsx scripts/generate-cube3-solver-tables.ts",
     "cube3:tables:check": "node --import tsx scripts/check-cube3-solver-tables.ts",
@@ -44,6 +72,16 @@
     "pyraminx:tables:check": "node --import tsx scripts/check-pyraminx-solver-tables.ts",
     "skewb:tables": "node --import tsx scripts/generate-skewb-solver-tables.ts",
     "skewb:tables:check": "node --import tsx scripts/check-skewb-solver-tables.ts",
+    "sq1:tables": "node --import tsx scripts/generate-sq1-solver-tables.ts",
+    "sq1:tables:check": "node --import tsx scripts/check-sq1-solver-tables.ts",
+    "cube4:center1:tables": "node --import tsx scripts/generate-center1-solver-tables.ts",
+    "cube4:center1:tables:check": "node --import tsx scripts/check-center1-solver-tables.ts",
+    "cube4:center2:tables": "node --import tsx scripts/generate-center2-solver-tables.ts",
+    "cube4:center2:tables:check": "node --import tsx scripts/check-center2-solver-tables.ts",
+    "cube4:center3:tables": "node --import tsx scripts/generate-center3-solver-tables.ts",
+    "cube4:center3:tables:check": "node --import tsx scripts/check-center3-solver-tables.ts",
+    "cube4:edge3:tables": "node --import tsx scripts/generate-edge3-solver-tables.ts",
+    "cube4:edge3:tables:check": "node --import tsx scripts/check-edge3-solver-tables.ts",
     "tables:web:sync": "node --import tsx scripts/sync-web-tables.ts",
     "verify:scrambles": "node --import tsx scripts/verify-scrambles.ts",
     "verify:pyraminx:exhaustive": "node --import tsx scripts/verify-pyraminx-exhaustive.ts",
@@ -52,16 +90,7 @@
     "bench:cube3": "node --import tsx bench-cube3.ts",
     "bench:skewb": "node --import tsx bench-skewb.ts",
     "bench:pyraminx": "node --import tsx bench-pyraminx.ts",
-    "bench:phases": "node --import tsx bench-phases.ts"
-  },
-  "devDependencies": {
-    "@cubingcenter/viz": "link:../cubingcenter-viz",
-    "@types/node": "^24.0.0",
-    "tsx": "^4.20.0",
-    "typescript": "^5.9.0"
-  },
-  "packageManager": "pnpm@10.33.0",
-  "dependencies": {
-    "cubing": "^0.63.3"
+    "bench:phases": "node --import tsx bench-phases.ts",
+    "bench:uniformity": "node --import tsx bench-uniformity.ts"
   }
-}
+}