@cubingcenter/scrambler 0.4.1 → 0.5.1

package/dist/puzzles/skewb/solver/table-metadata.d.ts

@@ -0,0 +1,27 @@
+export declare const SKEWB_SOLVER_TABLE_METADATA: {
+    readonly permutationTable: {
+        readonly entries: 40320;
+        readonly checksum: 3073532981;
+    };
+    readonly orientationTable: {
+        readonly entries: 17496;
+        readonly checksum: 2128852053;
+    };
+    readonly centersTable: {
+        readonly entries: 5760;
+        readonly checksum: 360885765;
+    };
+    readonly helpers: {
+        readonly evenCenterRankBytes: 1440;
+        readonly orientClassBytes: 2187;
+        readonly r7SetsEntries: 12960;
+        readonly entries: number;
+        readonly checksum: 4284555735;
+    };
+    readonly policyTable: {
+        readonly entries: 1180980;
+        readonly checksum: 1294485891;
+        readonly maxDepth: 11;
+    };
+};
+//# sourceMappingURL=table-metadata.d.ts.map

package/dist/puzzles/skewb/solver/table-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-metadata.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/table-metadata.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;CAyB9B,CAAC"}

package/dist/puzzles/skewb/solver/table-metadata.js

@@ -0,0 +1,26 @@
+export const SKEWB_SOLVER_TABLE_METADATA = {
+    permutationTable: {
+        entries: 40320, // PERMUTATION_COUNT (5040) * MOVE_COUNT (8)
+        checksum: 3073532981
+    },
+    orientationTable: {
+        entries: 17496, // ORIENTATION_COUNT (2187) * MOVE_COUNT (8)
+        checksum: 2128852053
+    },
+    centersTable: {
+        entries: 5760, // CENTER_COUNT (720) * MOVE_COUNT (8)
+        checksum: 360885765
+    },
+    helpers: {
+        evenCenterRankBytes: 1440, // 720 * 2 (Uint16, sentinel 65535)
+        orientClassBytes: 2187,
+        r7SetsEntries: 12960, // EVEN_CENTER_COUNT (360) * ORIENT_CLASS_COUNT (9) * PER_SET_SIZE (4)
+        entries: 1440 + 2187 + 12960 * 2,
+        checksum: 4284555735
+    },
+    policyTable: {
+        entries: 1180980, // ceil(STATE_COUNT (3_149_280) * 3 / 8)
+        checksum: 1294485891,
+        maxDepth: 11
+    }
+};

package/dist/puzzles/skewb/solver/tables.d.ts

@@ -0,0 +1,69 @@
+import type { SkewbMove, SkewbState } from "../types.js";
+export declare function getPermutationIndex(perm: readonly number[]): number;
+export declare function getPermutationFromIndex(index: number, n: number): number[];
+export declare function getOrientationIndex(orient: readonly number[]): number;
+export declare function getOrientationFromIndex(index: number): number[];
+export declare function getCenterIndex(centers: readonly number[]): number;
+export declare function getCenterFromIndex(index: number): number[];
+export declare function getStateIndex(state: SkewbState): number;
+export declare function getStateFromIndex(index: number): SkewbState;
+export declare const PERMUTATION_COUNT = 5040;
+export declare const ORIENTATION_COUNT = 2187;
+export declare const CENTER_COUNT = 720;
+export declare const EVEN_CENTER_COUNT = 360;
+export declare const ORIENT_CLASS_COUNT = 9;
+export declare const PER_SET_SIZE = 4;
+export declare const MOVE_COUNT = 8;
+export declare const STATE_COUNT: number;
+export declare const POLICY_PACKED_ENTRIES: number;
+export declare const SKEWB_MOVES: readonly SkewbMove[];
+export declare function getPerm7Index(perm: readonly number[]): number;
+export declare function getPerm7FromIndex(index: number): number[];
+export declare let PERMUTATION_TABLE: Uint16Array | null;
+export declare let ORIENTATION_TABLE: Uint16Array | null;
+export declare let CENTERS_TABLE: Uint16Array | null;
+export declare let POLICY_TABLE: Uint8Array | null;
+export declare let EVEN_CENTER_RANK: Uint16Array | null;
+export declare let EVEN_CENTER_FULL: Uint16Array | null;
+export declare let ORIENT_CLASS: Uint8Array | null;
+export declare let R7_SETS: Uint16Array | null;
+export declare let PERM7_UNRANK: Uint8Array | null;
+export declare let CENTER_UNRANK: Uint8Array | null;
+export declare let SOLVED_RANK: number;
+export declare function ensureTablesLoaded(): Promise<void>;
+export declare function areSkewbTablesLoaded(): boolean;
+export declare function assignTables(tables: {
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    centersTable: Uint16Array;
+    policyTable: Uint8Array;
+    evenCenterRank: Uint16Array;
+    orientClass: Uint8Array;
+    r7Sets: Uint16Array;
+}): void;
+export declare function resetTablesForTests(): void;
+export declare function rankFromComponents(r7: number, rO: number, rC: number): number;
+export declare function getStateRank(state: SkewbState): number;
+export declare function getStateFromRank(rank: number): SkewbState;
+export declare function getPolicyMoveFromPacked(packed: Uint8Array, stateRank: number): number;
+export declare function getPolicyMove(stateRank: number): number;
+export declare function getPermutationTransition(permIdx: number, move: number): number;
+export declare function getOrientationTransition(orientIdx: number, move: number): number;
+export declare function getCentersTransition(centerIdx: number, move: number): number;
+export declare function generatePermutationTable(): Uint16Array;
+export declare function generateOrientationTable(): Uint16Array;
+export declare function generateCentersTable(): Uint16Array;
+export declare function permutationParity(perm: readonly number[]): number;
+export interface SkewbHelperTables {
+    evenCenterRank: Uint16Array;
+    orientClass: Uint8Array;
+    r7Sets: Uint16Array;
+    evenCenterFull: Uint16Array;
+}
+export declare function generateHelperTables(permTable: Uint16Array, orientTable: Uint16Array, centersTable: Uint16Array): SkewbHelperTables;
+export declare function generatePolicyTable(permTable: Uint16Array, orientTable: Uint16Array, centersTable: Uint16Array, helpers: SkewbHelperTables): {
+    packed: Uint8Array;
+    maxDepth: number;
+};
+export declare function checksum(values: ArrayLike<number>): number;
+//# sourceMappingURL=tables.d.ts.map

package/dist/puzzles/skewb/solver/tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/tables.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,511 @@
+import { applySkewbMove } from "../moves.js";
+import { loadGeneratedSkewbSolverTables } from "./generated-assets.js";
+// ---------------------------------------------------------------------------
+// Coordinate encoding / decoding (kept from the original solver.ts)
+// ---------------------------------------------------------------------------
+const FACT = [1, 1, 2, 6, 24, 120, 720, 5040, 40320];
+// Popcount lookup (0..255) for the allocation-free Lehmer encoders below.
+const POPCOUNT = new Uint8Array(256);
+for (let i = 1; i < 256; i++)
+    POPCOUNT[i] = POPCOUNT[i >> 1] + (i & 1);
+export function getPermutationIndex(perm) {
+    // perm length 8, but pos0 is always 0 for WCA reachable states.
+    // We encode full 8-perm via Lehmer code (0..40319), but for fixed corner it will be in subset.
+    let index = 0;
+    let used = 0;
+    const n = perm.length;
+    for (let i = 0; i < n; i++) {
+        const v = perm[i];
+        const digit = v - POPCOUNT[used & ((1 << v) - 1)];
+        used |= 1 << v;
+        index += digit * FACT[n - 1 - i];
+    }
+    return index;
+}
+export function getPermutationFromIndex(index, n) {
+    const perm = Array(n).fill(0);
+    const temp = Array.from({ length: n }, (_, i) => i);
+    let val = index;
+    for (let i = 0; i < n; i++) {
+        const f = FACT[n - 1 - i];
+        const choice = Math.floor(val / f);
+        val %= f;
+        perm[i] = temp[choice];
+        temp.splice(choice, 1);
+    }
+    return perm;
+}
+export function getOrientationIndex(orient) {
+    // orient length 8, index 0 is fixed 0, encode remaining 7 base3
+    let index = 0;
+    for (let i = 7; i >= 1; i--) {
+        index = index * 3 + orient[i];
+    }
+    return index;
+}
+export function getOrientationFromIndex(index) {
+    const orient = Array(8).fill(0);
+    orient[0] = 0;
+    let val = index;
+    for (let i = 1; i < 8; i++) {
+        orient[i] = val % 3;
+        val = Math.floor(val / 3);
+    }
+    return orient;
+}
+export function getCenterIndex(centers) {
+    let index = 0;
+    let used = 0;
+    const n = centers.length;
+    for (let i = 0; i < n; i++) {
+        const v = centers[i];
+        const digit = v - POPCOUNT[used & ((1 << v) - 1)];
+        used |= 1 << v;
+        index += digit * FACT[n - 1 - i];
+    }
+    return index;
+}
+export function getCenterFromIndex(index) {
+    return getPermutationFromIndex(index, 6);
+}
+export function getStateIndex(state) {
+    const p = getPermutationIndex(state.corners.permutation);
+    const c = getCenterIndex(state.centers);
+    const o = getOrientationIndex(state.corners.orientation);
+    // p in 0..40319, c in 0..719, o in 0..2186
+    // Combine: ((p * 720 + c) * 2187 + o) -> up to 63B fits in JS number (53-bit)
+    return ((p * 720 + c) * 2187 + o);
+}
+export function getStateFromIndex(index) {
+    const o = index % 2187;
+    let val = Math.floor(index / 2187);
+    const c = val % 720;
+    const p = Math.floor(val / 720);
+    return {
+        corners: {
+            permutation: getPermutationFromIndex(p, 8),
+            orientation: getOrientationFromIndex(o),
+        },
+        centers: getCenterFromIndex(c),
+    };
+}
+// ---------------------------------------------------------------------------
+// Compact encoding over the WCA-reachable group (3,149,280 states)
+// ---------------------------------------------------------------------------
+// With the UFR corner fixed (position 0, orientation 0), the reachable group
+// factors as:
+//   rC: even center permutations only  -> 360
+//   rO: orientations of corners 1..7   -> 2187, partitioned into 9 classes
+//   r7: corner permutations of 1..7    -> exactly 4 values per (rC, rO-class)
+// so rank = (rC_even * 2187 + rO) * 4 + k is a bijection over the reachable set.
+export const PERMUTATION_COUNT = 5040; // r7: corners 1..7 Lehmer
+export const ORIENTATION_COUNT = 2187; // rO: corners 1..7 base-3
+export const CENTER_COUNT = 720; // rC: centers Lehmer
+export const EVEN_CENTER_COUNT = 360; // reachable center arrangements
+export const ORIENT_CLASS_COUNT = 9; // orientation classes
+export const PER_SET_SIZE = 4; // corner permutations per (rC, rO-class)
+export const MOVE_COUNT = 8;
+export const STATE_COUNT = EVEN_CENTER_COUNT * ORIENTATION_COUNT * PER_SET_SIZE; // 3_149_280
+export const POLICY_PACKED_ENTRIES = Math.ceil((STATE_COUNT * 3) / 8);
+export const SKEWB_MOVES = ["R", "R'", "U", "U'", "L", "L'", "B", "B'"];
+export function getPerm7Index(perm) {
+    // Lehmer rank of the positions 1..7 (values 1..7, offset by -1).
+    // Allocation-free: digit = count of unused values below the current one,
+    // computed with a used-bitmask and a popcount lookup.
+    let index = 0;
+    let used = 0;
+    for (let i = 1; i < 8; i++) {
+        const v = perm[i] - 1;
+        const digit = v - POPCOUNT[used & ((1 << v) - 1)];
+        used |= 1 << v;
+        index += digit * FACT[7 - i];
+    }
+    return index;
+}
+export function getPerm7FromIndex(index) {
+    const perm = Array(8).fill(0);
+    const available = [1, 2, 3, 4, 5, 6, 7];
+    let val = index;
+    for (let i = 1; i < 8; i++) {
+        const f = FACT[7 - i];
+        const choice = Math.floor(val / f);
+        val %= f;
+        perm[i] = available[choice];
+        available.splice(choice, 1);
+    }
+    return perm;
+}
+// ---------------------------------------------------------------------------
+// Table loading / runtime state
+// ---------------------------------------------------------------------------
+let tablesLoaded = false;
+export let PERMUTATION_TABLE = null; // r7 * MOVE_COUNT + m
+export let ORIENTATION_TABLE = null; // rO * MOVE_COUNT + m
+export let CENTERS_TABLE = null; // rC * MOVE_COUNT + m
+export let POLICY_TABLE = null; // optimal move per rank, 3-bit packed
+export let EVEN_CENTER_RANK = null; // rC -> compact 0..359 (65535 = odd)
+export let EVEN_CENTER_FULL = null; // compact 0..359 -> rC (derived at load)
+export let ORIENT_CLASS = null; // rO -> class 0..8
+export let R7_SETS = null; // (rC_even * 9 + class) * 4 + i
+export let PERM7_UNRANK = null; // r7 * 7 + i -> piece at corner i+1 (derived at load)
+export let CENTER_UNRANK = null; // rC * 6 + i -> center piece (derived at load)
+export let SOLVED_RANK = 0;
+export async function ensureTablesLoaded() {
+    if (tablesLoaded)
+        return;
+    const tables = await loadGeneratedSkewbSolverTables();
+    assignTables(tables);
+}
+export function areSkewbTablesLoaded() {
+    return tablesLoaded;
+}
+export function assignTables(tables) {
+    PERMUTATION_TABLE = tables.permutationTable;
+    ORIENTATION_TABLE = tables.orientationTable;
+    CENTERS_TABLE = tables.centersTable;
+    POLICY_TABLE = tables.policyTable;
+    EVEN_CENTER_RANK = tables.evenCenterRank;
+    ORIENT_CLASS = tables.orientClass;
+    R7_SETS = tables.r7Sets;
+    EVEN_CENTER_FULL = new Uint16Array(EVEN_CENTER_COUNT);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const compactIdx = tables.evenCenterRank[rC];
+        if (compactIdx !== 65535)
+            EVEN_CENTER_FULL[compactIdx] = rC;
+    }
+    PERM7_UNRANK = new Uint8Array(PERMUTATION_COUNT * 7);
+    for (let r7 = 0; r7 < PERMUTATION_COUNT; r7++) {
+        const perm = getPerm7FromIndex(r7);
+        for (let i = 0; i < 7; i++)
+            PERM7_UNRANK[r7 * 7 + i] = perm[i + 1];
+    }
+    CENTER_UNRANK = new Uint8Array(CENTER_COUNT * 6);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const centers = getCenterFromIndex(rC);
+        for (let i = 0; i < 6; i++)
+            CENTER_UNRANK[rC * 6 + i] = centers[i];
+    }
+    SOLVED_RANK = rankFromComponents(0, 0, 0);
+    tablesLoaded = true;
+}
+export function resetTablesForTests() {
+    tablesLoaded = false;
+    PERMUTATION_TABLE = null;
+    ORIENTATION_TABLE = null;
+    CENTERS_TABLE = null;
+    POLICY_TABLE = null;
+    EVEN_CENTER_RANK = null;
+    EVEN_CENTER_FULL = null;
+    ORIENT_CLASS = null;
+    R7_SETS = null;
+    PERM7_UNRANK = null;
+    CENTER_UNRANK = null;
+}
+// ---------------------------------------------------------------------------
+// Compact rank helpers
+// ---------------------------------------------------------------------------
+export function rankFromComponents(r7, rO, rC) {
+    const evenRank = EVEN_CENTER_RANK[rC];
+    if (evenRank === 65535) {
+        throw new Error("Unreachable Skewb state: odd center permutation parity.");
+    }
+    const cls = ORIENT_CLASS[rO];
+    const set = R7_SETS;
+    const base = (evenRank * ORIENT_CLASS_COUNT + cls) * PER_SET_SIZE;
+    for (let i = 0; i < PER_SET_SIZE; i++) {
+        if (set[base + i] === r7) {
+            return (evenRank * ORIENTATION_COUNT + rO) * PER_SET_SIZE + i;
+        }
+    }
+    throw new Error("Unreachable Skewb state: corner permutation not in reachable set.");
+}
+export function getStateRank(state) {
+    if (state.corners.permutation[0] !== 0) {
+        throw new Error("The Skewb solver requires the UFR corner (index 0) to be fixed " +
+            "as the frame of reference. Please normalize the state before solving.");
+    }
+    const r7 = getPerm7Index(state.corners.permutation);
+    const rO = getOrientationIndex(state.corners.orientation);
+    const rC = getCenterIndex(state.centers);
+    return rankFromComponents(r7, rO, rC);
+}
+// Inverse of getStateRank: decodes a reachable rank (0..3_149_279) back into
+// a full state. Used for exact uniform random-state sampling.
+export function getStateFromRank(rank) {
+    const even = Math.floor(rank / (ORIENTATION_COUNT * PER_SET_SIZE));
+    const rest = rank % (ORIENTATION_COUNT * PER_SET_SIZE);
+    const rO = Math.floor(rest / PER_SET_SIZE);
+    const k = rest % PER_SET_SIZE;
+    const cls = ORIENT_CLASS[rO];
+    const r7 = R7_SETS[(even * ORIENT_CLASS_COUNT + cls) * PER_SET_SIZE + k];
+    const perm = new Array(8);
+    perm[0] = 0;
+    const permBase = r7 * 7;
+    for (let i = 0; i < 7; i++)
+        perm[i + 1] = PERM7_UNRANK[permBase + i];
+    const orient = new Array(8);
+    orient[0] = 0;
+    let val = rO;
+    for (let i = 1; i < 8; i++) {
+        orient[i] = val % 3;
+        val = Math.floor(val / 3);
+    }
+    const centers = new Array(6);
+    const centerBase = EVEN_CENTER_FULL[even] * 6;
+    for (let i = 0; i < 6; i++)
+        centers[i] = CENTER_UNRANK[centerBase + i];
+    return { corners: { permutation: perm, orientation: orient }, centers };
+}
+// 3-bit little-endian unpacking of the packed policy table.
+export function getPolicyMoveFromPacked(packed, stateRank) {
+    const bits = stateRank * 3;
+    const byteIndex = bits >> 3;
+    const offset = bits & 7;
+    const word = (packed[byteIndex] | ((packed[byteIndex + 1] ?? 0) << 8)) >> offset;
+    return word & 0x07;
+}
+export function getPolicyMove(stateRank) {
+    if (!POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return getPolicyMoveFromPacked(POLICY_TABLE, stateRank);
+}
+export function getPermutationTransition(permIdx, move) {
+    if (!PERMUTATION_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return PERMUTATION_TABLE[permIdx * MOVE_COUNT + move];
+}
+export function getOrientationTransition(orientIdx, move) {
+    if (!ORIENTATION_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return ORIENTATION_TABLE[orientIdx * MOVE_COUNT + move];
+}
+export function getCentersTransition(centerIdx, move) {
+    if (!CENTERS_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return CENTERS_TABLE[centerIdx * MOVE_COUNT + move];
+}
+// ---------------------------------------------------------------------------
+// Table generation (used by the generate script)
+// ---------------------------------------------------------------------------
+export function generatePermutationTable() {
+    const table = new Uint16Array(PERMUTATION_COUNT * MOVE_COUNT);
+    for (let r7 = 0; r7 < PERMUTATION_COUNT; r7++) {
+        const perm = getPerm7FromIndex(r7);
+        for (let m = 0; m < MOVE_COUNT; m++) {
+            const state = {
+                corners: { permutation: [...perm], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+                centers: [0, 1, 2, 3, 4, 5],
+            };
+            const next = applySkewbMove(state, SKEWB_MOVES[m]);
+            table[r7 * MOVE_COUNT + m] = getPerm7Index(next.corners.permutation);
+        }
+    }
+    return table;
+}
+export function generateOrientationTable() {
+    const table = new Uint16Array(ORIENTATION_COUNT * MOVE_COUNT);
+    for (let rO = 0; rO < ORIENTATION_COUNT; rO++) {
+        const orient = getOrientationFromIndex(rO);
+        for (let m = 0; m < MOVE_COUNT; m++) {
+            const state = {
+                corners: { permutation: [0, 1, 2, 3, 4, 5, 6, 7], orientation: [...orient] },
+                centers: [0, 1, 2, 3, 4, 5],
+            };
+            const next = applySkewbMove(state, SKEWB_MOVES[m]);
+            table[rO * MOVE_COUNT + m] = getOrientationIndex(next.corners.orientation);
+        }
+    }
+    return table;
+}
+export function generateCentersTable() {
+    const table = new Uint16Array(CENTER_COUNT * MOVE_COUNT);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const centers = getCenterFromIndex(rC);
+        for (let m = 0; m < MOVE_COUNT; m++) {
+            const state = {
+                corners: { permutation: [0, 1, 2, 3, 4, 5, 6, 7], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+                centers: [...centers],
+            };
+            const next = applySkewbMove(state, SKEWB_MOVES[m]);
+            table[rC * MOVE_COUNT + m] = getCenterIndex(next.centers);
+        }
+    }
+    return table;
+}
+export function permutationParity(perm) {
+    let inversions = 0;
+    for (let i = 0; i < perm.length; i++) {
+        for (let j = i + 1; j < perm.length; j++) {
+            if (perm[i] > perm[j])
+                inversions++;
+        }
+    }
+    return inversions % 2;
+}
+// Discovers the reachable-state structure with a BFS over the full product
+// coordinate (r7, rO, rC) and derives the compact-rank helper tables:
+//   - even center permutations only (360 of 720)
+//   - rO partitioned into 9 classes by the 4-corner-permutation sets
+export function generateHelperTables(permTable, orientTable, centersTable) {
+    const evenCenterRank = new Uint16Array(CENTER_COUNT).fill(65535);
+    const evenCenterFull = new Uint16Array(EVEN_CENTER_COUNT);
+    let compact = 0;
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        if (permutationParity(getCenterFromIndex(rC)) === 0) {
+            evenCenterRank[rC] = compact;
+            evenCenterFull[compact] = rC;
+            compact++;
+        }
+    }
+    if (compact !== EVEN_CENTER_COUNT) {
+        throw new Error(`Expected ${EVEN_CENTER_COUNT} even center permutations, found ${compact}.`);
+    }
+    const pack = (r7, rO, rC) => (r7 * ORIENTATION_COUNT + rO) * CENTER_COUNT + rC;
+    const pairSets = new Map();
+    const seen = new Set([0]);
+    const queue = [0];
+    let head = 0;
+    while (head < queue.length) {
+        const cur = queue[head++];
+        const rC = cur % CENTER_COUNT;
+        const rest = Math.floor(cur / CENTER_COUNT);
+        const rO = rest % ORIENTATION_COUNT;
+        const r7 = Math.floor(rest / ORIENTATION_COUNT);
+        const pairKey = rC * ORIENTATION_COUNT + rO;
+        let set = pairSets.get(pairKey);
+        if (!set) {
+            set = new Set();
+            pairSets.set(pairKey, set);
+        }
+        set.add(r7);
+        for (let m = 0; m < MOVE_COUNT; m++) {
+            const n7 = permTable[r7 * MOVE_COUNT + m];
+            const nO = orientTable[rO * MOVE_COUNT + m];
+            const nC = centersTable[rC * MOVE_COUNT + m];
+            const next = pack(n7, nO, nC);
+            if (!seen.has(next)) {
+                seen.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    if (seen.size !== STATE_COUNT) {
+        throw new Error(`Reachability BFS covered ${seen.size} states, expected ${STATE_COUNT}.`);
+    }
+    const setKey = (values) => [...values].sort((a, b) => a - b).join(",");
+    // Reference partition from rC = 0 (verified identical for all even rC).
+    const orientClass = new Uint8Array(ORIENTATION_COUNT);
+    const classOfSet = new Map();
+    for (let rO = 0; rO < ORIENTATION_COUNT; rO++) {
+        const set = pairSets.get(rO);
+        const key = setKey(set);
+        if (!classOfSet.has(key)) {
+            classOfSet.set(key, classOfSet.size);
+        }
+        orientClass[rO] = classOfSet.get(key);
+    }
+    if (classOfSet.size !== ORIENT_CLASS_COUNT) {
+        throw new Error(`Expected ${ORIENT_CLASS_COUNT} orientation classes, found ${classOfSet.size}.`);
+    }
+    // Verify the partition is identical for every even rC and that each
+    // (rC, class) has exactly PER_SET_SIZE corner permutations.
+    const r7Sets = new Uint16Array(EVEN_CENTER_COUNT * ORIENT_CLASS_COUNT * PER_SET_SIZE);
+    for (let rC = 0; rC < CENTER_COUNT; rC++) {
+        const rCCompact = evenCenterRank[rC];
+        if (rCCompact === 65535)
+            continue;
+        for (let rO = 0; rO < ORIENTATION_COUNT; rO++) {
+            const set = pairSets.get(rC * ORIENTATION_COUNT + rO);
+            if (set.size !== PER_SET_SIZE) {
+                throw new Error(`Expected ${PER_SET_SIZE} permutations for (rC=${rC}, rO=${rO}), found ${set.size}.`);
+            }
+            const cls = orientClass[rO];
+            if (classOfSet.get(setKey(set)) !== cls) {
+                throw new Error(`Orientation class partition differs at rC=${rC}, rO=${rO}.`);
+            }
+            const stored = [...set].sort((a, b) => a - b);
+            const base = (rCCompact * ORIENT_CLASS_COUNT + cls) * PER_SET_SIZE;
+            for (let i = 0; i < PER_SET_SIZE; i++)
+                r7Sets[base + i] = stored[i];
+        }
+    }
+    return { evenCenterRank, orientClass, r7Sets, evenCenterFull };
+}
+// BFS from solved stores, for each state, the inverse of the move that first
+// discovered it: an optimal move toward solved. Packed 3 bits per state
+// (8 moves; the solved entry is never read, the solve loop exits first).
+export function generatePolicyTable(permTable, orientTable, centersTable, helpers) {
+    // Install the compact-rank tables for the duration of the build.
+    const saved = { evenCenterRank: EVEN_CENTER_RANK, orientClass: ORIENT_CLASS, r7Sets: R7_SETS };
+    EVEN_CENTER_RANK = helpers.evenCenterRank;
+    ORIENT_CLASS = helpers.orientClass;
+    R7_SETS = helpers.r7Sets;
+    try {
+        const solvedRank = rankFromComponents(0, 0, 0);
+        const distances = new Uint8Array(STATE_COUNT).fill(255);
+        const policy = new Uint8Array(STATE_COUNT);
+        distances[solvedRank] = 0;
+        const queue = new Uint32Array(STATE_COUNT);
+        let read = 0;
+        let write = 1;
+        queue[0] = solvedRank;
+        let maxDepth = 0;
+        while (read < write) {
+            const curr = queue[read++];
+            const dist = distances[curr];
+            const even = Math.floor(curr / (ORIENTATION_COUNT * PER_SET_SIZE));
+            const rest = curr % (ORIENTATION_COUNT * PER_SET_SIZE);
+            const rO = Math.floor(rest / PER_SET_SIZE);
+            const k = rest % PER_SET_SIZE;
+            const cls = ORIENT_CLASS[rO];
+            const r7 = R7_SETS[(even * ORIENT_CLASS_COUNT + cls) * PER_SET_SIZE + k];
+            const rC = helpers.evenCenterFull[even];
+            const nextDist = dist + 1;
+            for (let m = 0; m < MOVE_COUNT; m++) {
+                const n7 = permTable[r7 * MOVE_COUNT + m];
+                const nO = orientTable[rO * MOVE_COUNT + m];
+                const nC = centersTable[rC * MOVE_COUNT + m];
+                const next = rankFromComponents(n7, nO, nC);
+                if (distances[next] === 255) {
+                    distances[next] = nextDist;
+                    policy[next] = m ^ 1; // inverse move of the discovery edge
+                    if (nextDist > maxDepth)
+                        maxDepth = nextDist;
+                    queue[write++] = next;
+                }
+            }
+        }
+        if (write !== STATE_COUNT) {
+            throw new Error(`Policy BFS covered ${write} states, expected ${STATE_COUNT}.`);
+        }
+        const packed = new Uint8Array(POLICY_PACKED_ENTRIES);
+        for (let i = 0; i < STATE_COUNT; i++) {
+            const bits = i * 3;
+            const byteIndex = bits >> 3;
+            const offset = bits & 7;
+            const value = policy[i] & 0x07;
+            packed[byteIndex] |= (value << offset) & 0xff;
+            if (offset > 5) {
+                packed[byteIndex + 1] |= value >> (8 - offset);
+            }
+        }
+        return { packed, maxDepth };
+    }
+    finally {
+        EVEN_CENTER_RANK = saved.evenCenterRank;
+        ORIENT_CLASS = saved.orientClass;
+        R7_SETS = saved.r7Sets;
+    }
+}
+export function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < values.length; i++) {
+        hash ^= values[i];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"prng.d.ts","sourceRoot":"","sources":["../../src/random/prng.ts"],"names":[],"mappings":"AAEA,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,CAMvE"}
+{"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"}