@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist/puzzles/sq1/solver/full-cube.js

@@ -0,0 +1,281 @@
+import { createSolvedSquare1State } from "../state.js";
+/**
+ * Low-level bitwise representation of Square-1 state.
+ *
+ * Each layer is split into left and right 6-slot halves (24 bits per half, 4 bits per slot):
+ *  - `ul`: top left (slots 0..5)
+ *  - `ur`: top right (slots 6..11)
+ *  - `dl`: bottom right / left (slots 0..5 of bottom)
+ *  - `dr`: bottom left / right (slots 6..11 of bottom)
+ *  - `ml`: middle layer state (0 = solved, 1 = flipped)
+ *
+ * Piece encoding in 4-bit values:
+ *  - Corners: values with LSB 1 (1, 3, 5, 7, 9, 11, 13, 15) -> pieceId = (val >> 1) in [0..7]
+ *  - Edges: values with LSB 0 (0, 2, 4, 6, 8, 10, 12, 14) -> pieceId = (val >> 1) + 8 in [8..15]
+ */
+export class FullCube {
+    ul = 0x011233;
+    ur = 0x455677;
+    dl = 0x998bba;
+    dr = 0xddcffe;
+    ml = 0;
+    copy(c) {
+        this.ul = c.ul;
+        this.ur = c.ur;
+        this.dl = c.dl;
+        this.dr = c.dr;
+        this.ml = c.ml;
+    }
+    isSolved() {
+        return (this.ul === 0x011233 &&
+            this.ur === 0x455677 &&
+            this.dl === 0x998bba &&
+            this.dr === 0xddcffe &&
+            this.ml === 0);
+    }
+    /**
+     * Applies move token:
+     *  - 0: slice /
+     *  - >0: top layer turn
+     *  - <0: bottom layer turn
+     */
+    doMove(move) {
+        let m = move << 2;
+        if (m > 24) {
+            m = 48 - m;
+            const temp = this.ul;
+            this.ul = ((this.ul >> m) | (this.ur << (24 - m))) & 0xffffff;
+            this.ur = ((this.ur >> m) | (temp << (24 - m))) & 0xffffff;
+        }
+        else if (m > 0) {
+            const temp = this.ul;
+            this.ul = ((this.ul << m) | (this.ur >> (24 - m))) & 0xffffff;
+            this.ur = ((this.ur << m) | (temp >> (24 - m))) & 0xffffff;
+        }
+        else if (m === 0) {
+            const temp = this.ur;
+            this.ur = this.dl;
+            this.dl = temp;
+            this.ml = 1 - this.ml;
+        }
+        else if (m >= -24) {
+            m = -m;
+            const temp = this.dl;
+            this.dl = ((this.dl << m) | (this.dr >> (24 - m))) & 0xffffff;
+            this.dr = ((this.dr << m) | (temp >> (24 - m))) & 0xffffff;
+        }
+        else if (m < -24) {
+            m = 48 + m;
+            const temp = this.dl;
+            this.dl = ((this.dl >> m) | (this.dr << (24 - m))) & 0xffffff;
+            this.dr = ((this.dr >> m) | (temp << (24 - m))) & 0xffffff;
+        }
+    }
+    pieceAt(idx) {
+        let ret;
+        if (idx < 6) {
+            ret = this.ul >> ((5 - idx) << 2);
+        }
+        else if (idx < 12) {
+            ret = this.ur >> ((11 - idx) << 2);
+        }
+        else if (idx < 18) {
+            ret = this.dl >> ((17 - idx) << 2);
+        }
+        else {
+            ret = this.dr >> ((23 - idx) << 2);
+        }
+        return ret & 0x0f;
+    }
+    setPiece(idx, value) {
+        const shift = idx < 6
+            ? (5 - idx) << 2
+            : idx < 12
+                ? (11 - idx) << 2
+                : idx < 18
+                    ? (17 - idx) << 2
+                    : (23 - idx) << 2;
+        if (idx < 6) {
+            this.ul = (this.ul & ~(0xf << shift)) | (value << shift);
+        }
+        else if (idx < 12) {
+            this.ur = (this.ur & ~(0xf << shift)) | (value << shift);
+        }
+        else if (idx < 18) {
+            this.dl = (this.dl & ~(0xf << shift)) | (value << shift);
+        }
+        else if (idx < 24) {
+            this.dr = (this.dr & ~(0xf << shift)) | (value << shift);
+        }
+    }
+    getParity() {
+        const arr = new Array(16);
+        let cnt = 0;
+        arr[0] = this.pieceAt(0);
+        for (let i = 1; i < 24; i++) {
+            const p = this.pieceAt(i);
+            if (p !== arr[cnt]) {
+                arr[++cnt] = p;
+            }
+        }
+        let p = 0;
+        for (let a = 0; a < 16; a++) {
+            for (let b = a + 1; b < 16; b++) {
+                if (arr[a] > arr[b]) {
+                    p ^= 1;
+                }
+            }
+        }
+        return p;
+    }
+    getShapeIdx(shapeIdxTable) {
+        let urx = this.ur & 0x111111;
+        urx |= urx >> 3;
+        urx |= urx >> 6;
+        urx = (urx & 0xf) | ((urx >> 12) & 0x30);
+        let ulx = this.ul & 0x111111;
+        ulx |= ulx >> 3;
+        ulx |= ulx >> 6;
+        ulx = (ulx & 0xf) | ((ulx >> 12) & 0x30);
+        let drx = this.dr & 0x111111;
+        drx |= drx >> 3;
+        drx |= drx >> 6;
+        drx = (drx & 0xf) | ((drx >> 12) & 0x30);
+        let dlx = this.dl & 0x111111;
+        dlx |= dlx >> 3;
+        dlx |= dlx >> 6;
+        dlx = (dlx & 0xf) | ((dlx >> 12) & 0x30);
+        const key = ((this.getParity() << 24) | (ulx << 18) | (urx << 12) | (dlx << 6) | drx) >>> 0;
+        return getShape2Idx(shapeIdxTable, key);
+    }
+    getSquare() {
+        const prm = new Uint8Array(8);
+        for (let a = 0; a < 8; a++) {
+            prm[a] = this.pieceAt(a * 3 + 1) >> 1;
+        }
+        const cornperm = get8Perm(prm);
+        const topEdgeFirst = this.pieceAt(0) === this.pieceAt(1);
+        let a = topEdgeFirst ? 2 : 0;
+        let b = 0;
+        for (; b < 4; a += 3, b++) {
+            prm[b] = this.pieceAt(a) >> 1;
+        }
+        const botEdgeFirst = this.pieceAt(12) === this.pieceAt(13);
+        a = botEdgeFirst ? 14 : 12;
+        for (; b < 8; a += 3, b++) {
+            prm[b] = this.pieceAt(a) >> 1;
+        }
+        const edgeperm = get8Perm(prm);
+        return { edgeperm, cornperm, topEdgeFirst, botEdgeFirst, ml: this.ml };
+    }
+}
+function getShape2Idx(shapeIdxTable, shp) {
+    let low = 0;
+    let high = shapeIdxTable.length - 1;
+    const key = (shp & 0xffffff) >>> 0;
+    while (low <= high) {
+        const mid = (low + high) >>> 1;
+        const midVal = (shapeIdxTable[mid]) >>> 0;
+        if (midVal < key)
+            low = mid + 1;
+        else if (midVal > key)
+            high = mid - 1;
+        else
+            return (mid << 1) | (shp >>> 24);
+    }
+    return 0;
+}
+const fact = [1, 1, 2, 6, 24, 120, 720, 5040];
+export function get8Perm(arr) {
+    let idx = 0;
+    let val = 0x76543210;
+    for (let i = 0; i < 7; i++) {
+        const v = arr[i] << 2;
+        idx = (8 - i) * idx + ((val >> v) & 7);
+        val -= 0x11111110 << v;
+    }
+    return idx;
+}
+export function set8Perm(arr, idx) {
+    let val = 0x76543210;
+    for (let i = 0; i < 7; i++) {
+        const p = fact[7 - i];
+        const v = Math.floor(idx / p);
+        idx -= v * p;
+        const shift = v << 2;
+        arr[i] = (val >> shift) & 7;
+        const m = (1 << shift) - 1;
+        val = (val & m) + ((val >> 4) & ~m);
+    }
+    arr[7] = val & 7;
+}
+/**
+ * Converts a FullCube instance to a high-level Square1State.
+ */
+export function fullCubeToState(cube) {
+    const solved = createSolvedSquare1State();
+    const allSlots = [...solved.top, ...solved.bottom];
+    const getSlotDef = (pieceId, isCorner, partIndex) => {
+        const def = allSlots.find((s) => s.pieceId === pieceId && s.partIndex === partIndex);
+        return def || { faceColor: (pieceId < 8 ? "U" : "D"), sideColor: "F" };
+    };
+    const top = Array.from({ length: 12 }, (_, i) => {
+        const raw = cube.pieceAt(i);
+        const isCorner = (raw & 1) === 1;
+        const pieceId = isCorner ? (raw >> 1) : ((raw >> 1) + 8);
+        let partIndex = 0;
+        if (isCorner) {
+            const prevRaw = cube.pieceAt((i - 1 + 12) % 12);
+            if (prevRaw === raw)
+                partIndex = 1;
+            else
+                partIndex = 0;
+        }
+        const def = getSlotDef(pieceId, isCorner, partIndex);
+        return {
+            pieceId,
+            isCorner,
+            partIndex,
+            faceColor: "U",
+            sideColor: def.sideColor
+        };
+    });
+    const bottom = Array.from({ length: 12 }, (_, i) => {
+        const raw = cube.pieceAt(12 + i);
+        const isCorner = (raw & 1) === 1;
+        const pieceId = isCorner ? (raw >> 1) : ((raw >> 1) + 8);
+        let partIndex = 0;
+        if (isCorner) {
+            const prevRaw = cube.pieceAt(12 + ((i - 1 + 12) % 12));
+            if (prevRaw === raw)
+                partIndex = 1;
+            else
+                partIndex = 0;
+        }
+        const def = getSlotDef(pieceId, isCorner, partIndex);
+        return {
+            pieceId,
+            isCorner,
+            partIndex,
+            faceColor: "D",
+            sideColor: def.sideColor
+        };
+    });
+    return { top, bottom, middle: cube.ml };
+}
+/**
+ * Converts a high-level Square1State to a FullCube.
+ */
+export function stateToFullCube(state) {
+    const cube = new FullCube();
+    cube.ml = state.middle;
+    for (let i = 0; i < 12; i++) {
+        const s = state.top[i];
+        const raw = s.isCorner ? ((s.pieceId << 1) | 1) : ((s.pieceId - 8) << 1);
+        cube.setPiece(i, raw);
+        const sb = state.bottom[i];
+        const rawB = sb.isCorner ? ((sb.pieceId << 1) | 1) : ((sb.pieceId - 8) << 1);
+        cube.setPiece(12 + i, rawB);
+    }
+    return cube;
+}

package/dist/puzzles/sq1/solver/generated/manifest.json

@@ -0,0 +1,50 @@
+{
+  "version": 1,
+  "files": {
+    "shapeIdx": {
+      "file": "shape-idx.bin",
+      "entries": 3678,
+      "checksum": 3187990008
+    },
+    "shapePrun": {
+      "file": "shape-prun.bin",
+      "entries": 7356,
+      "checksum": 2116325776
+    },
+    "shapeTopMove": {
+      "file": "shape-top-move.bin",
+      "entries": 7356,
+      "checksum": 4112891337
+    },
+    "shapeBottomMove": {
+      "file": "shape-bottom-move.bin",
+      "entries": 7356,
+      "checksum": 161984121
+    },
+    "shapeTwistMove": {
+      "file": "shape-twist-move.bin",
+      "entries": 7356,
+      "checksum": 694153781
+    },
+    "squareTwistMove": {
+      "file": "square-twist-move.bin",
+      "entries": 40320,
+      "checksum": 4150758597
+    },
+    "squareTopMove": {
+      "file": "square-top-move.bin",
+      "entries": 40320,
+      "checksum": 1003750981
+    },
+    "squareBottomMove": {
+      "file": "square-bottom-move.bin",
+      "entries": 40320,
+      "checksum": 2028613829
+    },
+    "squarePrun": {
+      "file": "square-prun.bin",
+      "entries": 80640,
+      "checksum": 1475475221
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+export { FullCube, fullCubeToState, stateToFullCube } from "./full-cube.js";
+export { areSquare1TablesLoaded, ensureSquare1TablesLoaded, getSquare1SolverTablesSync, generateSquare1SolverTables, setCachedSquare1Tables, type Square1SolverTables } from "./tables.js";
+export { Square1Searcher, INVERSE_SOLUTION, type Square1Solution } from "./search.js";
+export { SQ1_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,sBAAsB,EACtB,KAAK,mBAAmB,EACzB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC"}

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

@@ -0,0 +1,4 @@
+export { FullCube, fullCubeToState, stateToFullCube } from "./full-cube.js";
+export { areSquare1TablesLoaded, ensureSquare1TablesLoaded, getSquare1SolverTablesSync, generateSquare1SolverTables, setCachedSquare1Tables } from "./tables.js";
+export { Square1Searcher, INVERSE_SOLUTION } from "./search.js";
+export { SQ1_SOLVER_TABLE_METADATA } from "./table-metadata.js";

package/dist/puzzles/sq1/solver/node-loader.d.ts

@@ -0,0 +1,4 @@
+import type { Square1SolverTables } from "./tables.js";
+export declare function readGeneratedSquare1SolverTables(): Square1SolverTables;
+export declare function checksum(values: ArrayLike<number>): number;
+//# sourceMappingURL=node-loader.d.ts.map

package/dist/puzzles/sq1/solver/node-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/node-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAmBvD,wBAAgB,gCAAgC,IAAI,mBAAmB,CAgCtE;AAqGD,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAO1D"}

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

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { SQ1_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+const GENERATED_DIRECTORY = "puzzles/sq1/solver/generated";
+export function readGeneratedSquare1SolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = JSON.parse(readFileSync(path.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, SQ1_SOLVER_TABLE_METADATA.shapeIdx.checksum);
+    const shapePrun = readInt8Table(assetDirectory, manifest.files.shapePrun, SQ1_SOLVER_TABLE_METADATA.shapePrun.checksum);
+    const shapeTopMove = readInt32Table(assetDirectory, manifest.files.shapeTopMove, SQ1_SOLVER_TABLE_METADATA.shapeTopMove.checksum);
+    const shapeBottomMove = readInt32Table(assetDirectory, manifest.files.shapeBottomMove, SQ1_SOLVER_TABLE_METADATA.shapeBottomMove.checksum);
+    const shapeTwistMove = readInt32Table(assetDirectory, manifest.files.shapeTwistMove, SQ1_SOLVER_TABLE_METADATA.shapeTwistMove.checksum);
+    const squareTwistMove = readUint16Table(assetDirectory, manifest.files.squareTwistMove, SQ1_SOLVER_TABLE_METADATA.squareTwistMove.checksum);
+    const squareTopMove = readUint16Table(assetDirectory, manifest.files.squareTopMove, SQ1_SOLVER_TABLE_METADATA.squareTopMove.checksum);
+    const squareBottomMove = readUint16Table(assetDirectory, manifest.files.squareBottomMove, SQ1_SOLVER_TABLE_METADATA.squareBottomMove.checksum);
+    const squarePrun = readInt8Table(assetDirectory, manifest.files.squarePrun, SQ1_SOLVER_TABLE_METADATA.squarePrun.checksum);
+    return {
+        shapeIdx,
+        shapePrun,
+        shapeTopMove,
+        shapeBottomMove,
+        shapeTwistMove,
+        squareTwistMove,
+        squareTopMove,
+        squareBottomMove,
+        squarePrun
+    };
+}
+function readInt32Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = readFileSync(path.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 = readFileSync(path.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 = readFileSync(path.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 && existsSync(path.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if (existsSync(path.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 = [
+        path.join(cwd, "src", GENERATED_DIRECTORY),
+        path.join(cwd, "dist", GENERATED_DIRECTORY),
+        path.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = createRequire(path.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(path.join(path.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}.`);
+    }
+}
+export 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/puzzles/sq1/solver/search.d.ts

@@ -0,0 +1,27 @@
+import { FullCube } from "./full-cube.js";
+import { type Square1SolverTables } from "./tables.js";
+export declare const INVERSE_SOLUTION = 2;
+export interface Square1Solution {
+    moves: string[];
+    scramble: string;
+    depth: number;
+}
+export declare class Square1Searcher {
+    private tables;
+    private move;
+    private c;
+    private d;
+    private length1;
+    private movelen1;
+    private maxlen2;
+    private verbose;
+    private solString;
+    private solMoves;
+    constructor(tables?: Square1SolverTables);
+    solution(c: FullCube, verbose?: number): Square1Solution;
+    private idaPhase1;
+    private initPhase2;
+    private idaPhase2;
+    private formatSolution;
+}
+//# sourceMappingURL=search.d.ts.map

package/dist/puzzles/sq1/solver/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAA8B,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEnF,eAAO,MAAM,gBAAgB,IAAM,CAAC;AAEpC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,IAAI,CAA4B;IACxC,OAAO,CAAC,CAAC,CAA4B;IACrC,OAAO,CAAC,CAAC,CAA4B;IACrC,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAAgB;gBAEpB,MAAM,CAAC,EAAE,mBAAmB;IAIxC,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAE,MAAU,GAAG,eAAe;IAqB3D,OAAO,CAAC,SAAS;IA6DjB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,SAAS;IA2FjB,OAAO,CAAC,cAAc;CA0CvB"}