@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist-cjs/puzzles/sq1/solver/node-loader.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGeneratedSquare1SolverTables = readGeneratedSquare1SolverTables;
+exports.checksum = checksum;
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const table_metadata_js_1 = require("./table-metadata.js");
+const GENERATED_DIRECTORY = "puzzles/sq1/solver/generated";
+function readGeneratedSquare1SolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, "manifest.json"), "utf8"));
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported square1 solver table manifest version: ${manifest.version}`);
+    }
+    const shapeIdx = readInt32Table(assetDirectory, manifest.files.shapeIdx, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeIdx.checksum);
+    const shapePrun = readInt8Table(assetDirectory, manifest.files.shapePrun, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapePrun.checksum);
+    const shapeTopMove = readInt32Table(assetDirectory, manifest.files.shapeTopMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeTopMove.checksum);
+    const shapeBottomMove = readInt32Table(assetDirectory, manifest.files.shapeBottomMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeBottomMove.checksum);
+    const shapeTwistMove = readInt32Table(assetDirectory, manifest.files.shapeTwistMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeTwistMove.checksum);
+    const squareTwistMove = readUint16Table(assetDirectory, manifest.files.squareTwistMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.squareTwistMove.checksum);
+    const squareTopMove = readUint16Table(assetDirectory, manifest.files.squareTopMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.squareTopMove.checksum);
+    const squareBottomMove = readUint16Table(assetDirectory, manifest.files.squareBottomMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.squareBottomMove.checksum);
+    const squarePrun = readInt8Table(assetDirectory, manifest.files.squarePrun, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.squarePrun.checksum);
+    return {
+        shapeIdx,
+        shapePrun,
+        shapeTopMove,
+        shapeBottomMove,
+        shapeTwistMove,
+        squareTwistMove,
+        squareTopMove,
+        squareBottomMove,
+        squarePrun
+    };
+}
+function readInt32Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries * 4) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Int32Array(entry.entries);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = buffer.readInt32LE(index * 4);
+    }
+    if (expectedChecksum !== 0) {
+        assertChecksum(entry.file, checksum(values), expectedChecksum);
+    }
+    return values;
+}
+function readUint16Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(entry.entries);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = buffer.readUInt16LE(index * 2);
+    }
+    if (expectedChecksum !== 0) {
+        assertChecksum(entry.file, checksum(values), expectedChecksum);
+    }
+    return values;
+}
+function readInt8Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Int8Array(buffer);
+    if (expectedChecksum !== 0) {
+        assertChecksum(entry.file, checksum(values), expectedChecksum);
+    }
+    return values;
+}
+function resolveGeneratedAssetDirectory() {
+    const envDirectory = process.env.CUBINGCENTER_SCRAMBLER_TABLES_DIR;
+    if (envDirectory && (0, node_fs_1.existsSync)(node_path_1.default.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(candidate, "manifest.json"))) {
+            return candidate;
+        }
+    }
+    throw new Error("Unable to find generated Square-1 solver tables. Run pnpm sq1:tables.");
+}
+function getAssetDirectoryCandidates() {
+    const cwd = process.cwd();
+    const candidates = [
+        node_path_1.default.join(cwd, "src", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = (0, node_module_1.createRequire)(node_path_1.default.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(node_path_1.default.join(node_path_1.default.dirname(packageEntry), GENERATED_DIRECTORY));
+    }
+    catch {
+        // Source-tree usage is covered by the cwd candidates.
+    }
+    return candidates;
+}
+function assertChecksum(file, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Checksum mismatch for ${file}: expected ${expected}, received ${actual}.`);
+    }
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < values.length; index += 1) {
+        hash ^= values[index];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

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

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Square1Searcher = exports.INVERSE_SOLUTION = void 0;
+const full_cube_js_1 = require("./full-cube.js");
+const tables_js_1 = require("./tables.js");
+exports.INVERSE_SOLUTION = 0x2;
+class Square1Searcher {
+    tables;
+    move = new Array(100);
+    c = new full_cube_js_1.FullCube();
+    d = new full_cube_js_1.FullCube();
+    length1 = 0;
+    movelen1 = 0;
+    maxlen2 = 0;
+    verbose = 0;
+    solString = "";
+    solMoves = [];
+    constructor(tables) {
+        this.tables = tables || (0, tables_js_1.getSquare1SolverTablesSync)();
+    }
+    solution(c, verbose = 0) {
+        this.c.copy(c);
+        this.verbose = verbose;
+        this.solString = "";
+        this.solMoves = [];
+        const shape = c.getShapeIdx(this.tables.shapeIdx);
+        for (this.length1 = this.tables.shapePrun[shape]; this.length1 < 100; this.length1++) {
+            this.maxlen2 = Math.min(31 - this.length1, 17);
+            if (this.idaPhase1(shape, this.tables.shapePrun[shape], this.length1, 0, -1)) {
+                break;
+            }
+        }
+        return {
+            moves: this.solMoves,
+            scramble: this.solString,
+            depth: this.solMoves.length
+        };
+    }
+    idaPhase1(shape, prunvalue, maxl, depth, lm) {
+        if (prunvalue === 0 && maxl < 4) {
+            this.movelen1 = depth;
+            return maxl === 0 && this.initPhase2();
+        }
+        // try twist
+        if (lm !== 0) {
+            const shapex = this.tables.shapeTwistMove[shape];
+            const prun = this.tables.shapePrun[shapex];
+            if (prun < maxl) {
+                this.move[depth] = 0;
+                if (this.idaPhase1(shapex, prun, maxl - 1, depth + 1, 0)) {
+                    return true;
+                }
+            }
+        }
+        // try top layer
+        if (lm <= 0) {
+            let m = 0;
+            let shapex = shape;
+            while (true) {
+                const topVal = this.tables.shapeTopMove[shapex];
+                m += topVal & 0xf;
+                shapex = topVal >> 4;
+                if (m >= 12)
+                    break;
+                const prun = this.tables.shapePrun[shapex];
+                if (prun > maxl)
+                    break;
+                else if (prun < maxl) {
+                    this.move[depth] = m;
+                    if (this.idaPhase1(shapex, prun, maxl - 1, depth + 1, 1)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        // try bottom layer
+        if (lm <= 1) {
+            let m = 0;
+            let shapex = shape;
+            while (true) {
+                const botVal = this.tables.shapeBottomMove[shapex];
+                m += botVal & 0xf;
+                shapex = botVal >> 4;
+                if (m >= 6)
+                    break;
+                const prun = this.tables.shapePrun[shapex];
+                if (prun > maxl)
+                    break;
+                else if (prun < maxl) {
+                    this.move[depth] = -m;
+                    if (this.idaPhase1(shapex, prun, maxl - 1, depth + 1, 2)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    initPhase2() {
+        this.d.copy(this.c);
+        for (let i = 0; i < this.movelen1; i++) {
+            this.d.doMove(this.move[i]);
+        }
+        const sq = this.d.getSquare();
+        const prun = Math.max(this.tables.squarePrun[(sq.edgeperm << 1) | sq.ml], this.tables.squarePrun[(sq.cornperm << 1) | sq.ml]);
+        for (let i = prun; i < this.maxlen2; i++) {
+            if (this.idaPhase2(sq.edgeperm, sq.cornperm, sq.topEdgeFirst, sq.botEdgeFirst, sq.ml, i, this.movelen1, 0)) {
+                this.formatSolution(i + this.movelen1);
+                return true;
+            }
+        }
+        return false;
+    }
+    idaPhase2(edge, corner, topEdgeFirst, botEdgeFirst, ml, maxl, depth, lm) {
+        if (maxl === 0 && !topEdgeFirst && botEdgeFirst) {
+            return edge === 0 && corner === 0 && ml === 0;
+        }
+        // try twist
+        if (lm !== 0 && topEdgeFirst === botEdgeFirst) {
+            const edgex = this.tables.squareTwistMove[edge];
+            const cornerx = this.tables.squareTwistMove[corner];
+            if (this.tables.squarePrun[(edgex << 1) | (1 - ml)] < maxl &&
+                this.tables.squarePrun[(cornerx << 1) | (1 - ml)] < maxl) {
+                this.move[depth] = 0;
+                if (this.idaPhase2(edgex, cornerx, topEdgeFirst, botEdgeFirst, 1 - ml, maxl - 1, depth + 1, 0)) {
+                    return true;
+                }
+            }
+        }
+        // try top layer
+        if (lm <= 0) {
+            let topEdgeFirstx = !topEdgeFirst;
+            let edgex = topEdgeFirstx ? this.tables.squareTopMove[edge] : edge;
+            let cornerx = topEdgeFirstx ? corner : this.tables.squareTopMove[corner];
+            let m = topEdgeFirstx ? 1 : 2;
+            let prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+            let prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+            while (m < 12 && prun1 <= maxl && prun2 <= maxl) {
+                if (prun1 < maxl && prun2 < maxl) {
+                    this.move[depth] = m;
+                    if (this.idaPhase2(edgex, cornerx, topEdgeFirstx, botEdgeFirst, ml, maxl - 1, depth + 1, 1)) {
+                        return true;
+                    }
+                }
+                topEdgeFirstx = !topEdgeFirstx;
+                if (topEdgeFirstx) {
+                    edgex = this.tables.squareTopMove[edgex];
+                    prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+                    m += 1;
+                }
+                else {
+                    cornerx = this.tables.squareTopMove[cornerx];
+                    prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+                    m += 2;
+                }
+            }
+        }
+        // try bottom layer
+        if (lm <= 1) {
+            let botEdgeFirstx = !botEdgeFirst;
+            let edgex = botEdgeFirstx ? this.tables.squareBottomMove[edge] : edge;
+            let cornerx = botEdgeFirstx ? corner : this.tables.squareBottomMove[corner];
+            let m = botEdgeFirstx ? 1 : 2;
+            let prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+            let prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+            while (m < (maxl > 6 ? 6 : 12) && prun1 <= maxl && prun2 <= maxl) {
+                if (prun1 < maxl && prun2 < maxl) {
+                    this.move[depth] = -m;
+                    if (this.idaPhase2(edgex, cornerx, topEdgeFirst, botEdgeFirstx, ml, maxl - 1, depth + 1, 2)) {
+                        return true;
+                    }
+                }
+                botEdgeFirstx = !botEdgeFirstx;
+                if (botEdgeFirstx) {
+                    edgex = this.tables.squareBottomMove[edgex];
+                    prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+                    m += 1;
+                }
+                else {
+                    cornerx = this.tables.squareBottomMove[cornerx];
+                    prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+                    m += 2;
+                }
+            }
+        }
+        return false;
+    }
+    formatSolution(len) {
+        const outputMoves = new Array(len);
+        if ((this.verbose & exports.INVERSE_SOLUTION) !== 0) {
+            for (let i = len - 1; i >= 0; i--) {
+                const val = this.move[i];
+                outputMoves[len - 1 - i] = val > 0 ? 12 - val : val < 0 ? -12 - val : val;
+            }
+        }
+        else {
+            for (let i = 0; i < len; i++) {
+                outputMoves[i] = this.move[i];
+            }
+        }
+        const tokens = [];
+        let top = 0;
+        let bottom = 0;
+        for (let i = 0; i < len; i++) {
+            const val = outputMoves[i];
+            if (val > 0) {
+                top = val > 6 ? val - 12 : val;
+            }
+            else if (val < 0) {
+                bottom = -val > 6 ? -val - 12 : -val;
+            }
+            else {
+                tokens.push(`(${top}, ${bottom})`, "/");
+                top = 0;
+                bottom = 0;
+            }
+        }
+        if (top !== 0 || bottom !== 0) {
+            tokens.push(`(${top}, ${bottom})`);
+        }
+        // Clean up empty leading (0, 0)
+        if (tokens.length >= 2 && tokens[0] === "(0, 0)") {
+            tokens.shift();
+        }
+        this.solMoves = tokens;
+        this.solString = tokens.join(" ").replace(/\s*\/\s*/g, " / ").replace(/\s+/g, " ").trim();
+    }
+}
+exports.Square1Searcher = Square1Searcher;

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

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Shape tables and transitions for Square-1 (Phase 1).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShapeState = void 0;
+exports.bitCount = bitCount;
+exports.generateShapeTables = generateShapeTables;
+const halflayer = [
+    0x00, 0x03, 0x06, 0x0c, 0x0f, 0x18, 0x1b, 0x1e,
+    0x30, 0x33, 0x36, 0x3c, 0x3f
+];
+function bitCount(n) {
+    let count = 0;
+    let v = n >>> 0;
+    while (v > 0) {
+        count += v & 1;
+        v >>>= 1;
+    }
+    return count;
+}
+class ShapeState {
+    top = 0;
+    bottom = 0;
+    parity = 0;
+    getIdx(shapeIdx) {
+        const shp = ((this.top << 12) | this.bottom) >>> 0;
+        let low = 0;
+        let high = shapeIdx.length - 1;
+        while (low <= high) {
+            const mid = (low + high) >>> 1;
+            const midVal = shapeIdx[mid] >>> 0;
+            if (midVal < shp)
+                low = mid + 1;
+            else if (midVal > shp)
+                high = mid - 1;
+            else
+                return (mid << 1) | this.parity;
+        }
+        return 0;
+    }
+    setIdx(idx, shapeIdx) {
+        this.parity = idx & 1;
+        const val = shapeIdx[idx >> 1];
+        this.bottom = val & 0xfff;
+        this.top = (val >> 12) & 0xfff;
+    }
+    topMove() {
+        let move = 0;
+        let moveParity = 0;
+        do {
+            if ((this.top & 0x800) === 0) {
+                move += 1;
+                this.top = (this.top << 1) & 0xfff;
+            }
+            else {
+                move += 2;
+                this.top = ((this.top << 2) ^ 0x3003) & 0xfff;
+            }
+            moveParity = 1 - moveParity;
+        } while ((bitCount(this.top & 0x3f) & 1) !== 0);
+        if ((bitCount(this.top) & 2) === 0) {
+            this.parity ^= moveParity;
+        }
+        return move;
+    }
+    bottomMove() {
+        let move = 0;
+        let moveParity = 0;
+        do {
+            if ((this.bottom & 0x800) === 0) {
+                move += 1;
+                this.bottom = (this.bottom << 1) & 0xfff;
+            }
+            else {
+                move += 2;
+                this.bottom = ((this.bottom << 2) ^ 0x3003) & 0xfff;
+            }
+            moveParity = 1 - moveParity;
+        } while ((bitCount(this.bottom & 0x3f) & 1) !== 0);
+        if ((bitCount(this.bottom) & 2) === 0) {
+            this.parity ^= moveParity;
+        }
+        return move;
+    }
+    twistMove() {
+        const temp = this.top & 0x3f;
+        const p1 = bitCount(temp);
+        const p3 = bitCount(this.bottom & 0xfc0);
+        this.parity ^= 1 & ((p1 & p3) >> 1);
+        this.top = (this.top & 0xfc0) | ((this.bottom >> 6) & 0x3f);
+        this.bottom = (this.bottom & 0x3f) | (temp << 6);
+    }
+}
+exports.ShapeState = ShapeState;
+function generateShapeTables() {
+    const shapeIdx = new Int32Array(3678);
+    const shapePrun = new Int8Array(3678 * 2);
+    const shapeTopMove = new Int32Array(3678 * 2);
+    const shapeBottomMove = new Int32Array(3678 * 2);
+    const shapeTwistMove = new Int32Array(3678 * 2);
+    // 1. Build ShapeIdx
+    let count = 0;
+    for (let i = 0; i < 13 * 13 * 13 * 13; i++) {
+        const dr = halflayer[i % 13];
+        const dl = halflayer[Math.floor(i / 13) % 13];
+        const ur = halflayer[Math.floor(i / (13 * 13)) % 13];
+        const ul = halflayer[Math.floor(i / (13 * 13 * 13))];
+        const value = (ul << 18) | (ur << 12) | (dl << 6) | dr;
+        if (bitCount(value) === 16) {
+            shapeIdx[count++] = value;
+        }
+    }
+    // 2. Build Shape moves
+    const s = new ShapeState();
+    for (let i = 0; i < 3678 * 2; i++) {
+        s.setIdx(i, shapeIdx);
+        shapeTopMove[i] = s.topMove() | (s.getIdx(shapeIdx) << 4);
+        s.setIdx(i, shapeIdx);
+        shapeBottomMove[i] = s.bottomMove() | (s.getIdx(shapeIdx) << 4);
+        s.setIdx(i, shapeIdx);
+        s.twistMove();
+        shapeTwistMove[i] = s.getIdx(shapeIdx);
+    }
+    // 3. Build ShapePrun
+    shapePrun.fill(-1);
+    const getIdxForShape = (shp) => {
+        let low = 0;
+        let high = shapeIdx.length - 1;
+        const key = (shp & 0xffffff) >>> 0;
+        while (low <= high) {
+            const mid = (low + high) >>> 1;
+            const midVal = (shapeIdx[mid]) >>> 0;
+            if (midVal < key)
+                low = mid + 1;
+            else if (midVal > key)
+                high = mid - 1;
+            else
+                return (mid << 1) | (shp >>> 24);
+        }
+        return 0;
+    };
+    shapePrun[getIdxForShape(0x0db66db)] = 0;
+    shapePrun[getIdxForShape(0x1db6db6)] = 0;
+    shapePrun[getIdxForShape(0x16db6db)] = 0;
+    shapePrun[getIdxForShape(0x06dbdb6)] = 0;
+    let done = 4;
+    let done0 = 0;
+    let depth = -1;
+    while (done !== done0) {
+        done0 = done;
+        depth++;
+        for (let i = 0; i < 3678 * 2; i++) {
+            if (shapePrun[i] !== depth)
+                continue;
+            // twist
+            const idxTwist = shapeTwistMove[i];
+            if (shapePrun[idxTwist] === -1) {
+                done++;
+                shapePrun[idxTwist] = depth + 1;
+            }
+            // top moves
+            for (let m = 0, inc = 0, idx = i; m !== 12; m += inc) {
+                const topVal = shapeTopMove[idx];
+                inc = topVal & 0xf;
+                idx = topVal >> 4;
+                if (shapePrun[idx] === -1) {
+                    done++;
+                    shapePrun[idx] = depth + 1;
+                }
+            }
+            // bottom moves
+            for (let m = 0, inc = 0, idx = i; m !== 12; m += inc) {
+                const botVal = shapeBottomMove[idx];
+                inc = botVal & 0xf;
+                idx = botVal >> 4;
+                if (shapePrun[idx] === -1) {
+                    done++;
+                    shapePrun[idx] = depth + 1;
+                }
+            }
+        }
+    }
+    return {
+        shapeIdx,
+        shapePrun,
+        shapeTopMove,
+        shapeBottomMove,
+        shapeTwistMove
+    };
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Permutation tables and distance pruning for Square-1 in Cube/Cube shape (Phase 2).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSquareTables = generateSquareTables;
+const full_cube_js_1 = require("./full-cube.js");
+function generateSquareTables() {
+    const squarePrun = new Int8Array(40320 * 2);
+    const squareTwistMove = new Uint16Array(40320);
+    const squareTopMove = new Uint16Array(40320);
+    const squareBottomMove = new Uint16Array(40320);
+    const pos = new Uint8Array(8);
+    for (let i = 0; i < 40320; i++) {
+        // twist
+        (0, full_cube_js_1.set8Perm)(pos, i);
+        let temp = pos[2];
+        pos[2] = pos[4];
+        pos[4] = temp;
+        temp = pos[3];
+        pos[3] = pos[5];
+        pos[5] = temp;
+        squareTwistMove[i] = (0, full_cube_js_1.get8Perm)(pos);
+        // top layer turn
+        (0, full_cube_js_1.set8Perm)(pos, i);
+        temp = pos[0];
+        pos[0] = pos[1];
+        pos[1] = pos[2];
+        pos[2] = pos[3];
+        pos[3] = temp;
+        squareTopMove[i] = (0, full_cube_js_1.get8Perm)(pos);
+        // bottom layer turn
+        (0, full_cube_js_1.set8Perm)(pos, i);
+        temp = pos[4];
+        pos[4] = pos[5];
+        pos[5] = pos[6];
+        pos[6] = pos[7];
+        pos[7] = temp;
+        squareBottomMove[i] = (0, full_cube_js_1.get8Perm)(pos);
+    }
+    squarePrun.fill(-1);
+    squarePrun[0] = 0;
+    let sqDepth = 0;
+    let sqDone = 1;
+    while (sqDone < 40320 * 2) {
+        const inv = sqDepth >= 11;
+        const find = inv ? -1 : sqDepth;
+        const check = inv ? sqDepth : -1;
+        sqDepth++;
+        OUTER: for (let i = 0; i < 40320 * 2; i++) {
+            if (squarePrun[i] !== find)
+                continue;
+            let perm = i >> 1;
+            const ml = i & 1;
+            // twist
+            const idx = (squareTwistMove[perm] << 1) | (1 - ml);
+            if (squarePrun[idx] === check) {
+                sqDone++;
+                squarePrun[inv ? i : idx] = sqDepth;
+                if (inv)
+                    continue OUTER;
+            }
+            // top layer turns
+            for (let m = 0; m < 4; m++) {
+                perm = squareTopMove[perm];
+                const idxTop = (perm << 1) | ml;
+                if (squarePrun[idxTop] === check) {
+                    sqDone++;
+                    squarePrun[inv ? i : idxTop] = sqDepth;
+                    if (inv)
+                        continue OUTER;
+                }
+            }
+            // bottom layer turns
+            for (let m = 0; m < 4; m++) {
+                perm = squareBottomMove[perm];
+                const idxBot = (perm << 1) | ml;
+                if (squarePrun[idxBot] === check) {
+                    sqDone++;
+                    squarePrun[inv ? i : idxBot] = sqDepth;
+                    if (inv)
+                        continue OUTER;
+                }
+            }
+        }
+    }
+    return {
+        squarePrun,
+        squareTwistMove,
+        squareTopMove,
+        squareBottomMove
+    };
+}

package/dist-cjs/puzzles/sq1/solver/table-metadata.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQ1_SOLVER_TABLE_METADATA = void 0;
+exports.SQ1_SOLVER_TABLE_METADATA = {
+    shapeIdx: {
+        entries: 3678,
+        file: "shape-idx.bin",
+        checksum: 3187990008
+    },
+    shapePrun: {
+        entries: 7356,
+        file: "shape-prun.bin",
+        checksum: 2116325776
+    },
+    shapeTopMove: {
+        entries: 7356,
+        file: "shape-top-move.bin",
+        checksum: 4112891337
+    },
+    shapeBottomMove: {
+        entries: 7356,
+        file: "shape-bottom-move.bin",
+        checksum: 161984121
+    },
+    shapeTwistMove: {
+        entries: 7356,
+        file: "shape-twist-move.bin",
+        checksum: 694153781
+    },
+    squareTwistMove: {
+        entries: 40320,
+        file: "square-twist-move.bin",
+        checksum: 4150758597
+    },
+    squareTopMove: {
+        entries: 40320,
+        file: "square-top-move.bin",
+        checksum: 1003750981
+    },
+    squareBottomMove: {
+        entries: 40320,
+        file: "square-bottom-move.bin",
+        checksum: 2028613829
+    },
+    squarePrun: {
+        entries: 80640,
+        file: "square-prun.bin",
+        checksum: 1475475221
+    }
+};