@cubingcenter/scrambler 0.1.0

package/dist/puzzles/cube3/facelets.js

@@ -0,0 +1,89 @@
+const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const CORNER_PIECE_STICKERS = [
+    ["U", "R", "F"],
+    ["U", "F", "L"],
+    ["U", "L", "B"],
+    ["U", "B", "R"],
+    ["D", "F", "R"],
+    ["D", "L", "F"],
+    ["D", "B", "L"],
+    ["D", "R", "B"]
+];
+const CORNER_POSITION_SLOTS = [
+    [["U", 8], ["R", 0], ["F", 2]],
+    [["U", 6], ["F", 0], ["L", 2]],
+    [["U", 0], ["L", 0], ["B", 2]],
+    [["U", 2], ["B", 0], ["R", 2]],
+    [["D", 2], ["F", 8], ["R", 6]],
+    [["D", 0], ["L", 8], ["F", 6]],
+    [["D", 6], ["B", 8], ["L", 6]],
+    [["D", 8], ["R", 8], ["B", 6]]
+];
+const EDGE_PIECE_STICKERS = [
+    ["U", "R"],
+    ["U", "F"],
+    ["U", "L"],
+    ["U", "B"],
+    ["D", "R"],
+    ["D", "F"],
+    ["D", "L"],
+    ["D", "B"],
+    ["F", "R"],
+    ["F", "L"],
+    ["B", "L"],
+    ["B", "R"]
+];
+const EDGE_POSITION_SLOTS = [
+    [["U", 5], ["R", 1]],
+    [["U", 7], ["F", 1]],
+    [["U", 3], ["L", 1]],
+    [["U", 1], ["B", 1]],
+    [["D", 5], ["R", 7]],
+    [["D", 1], ["F", 7]],
+    [["D", 3], ["L", 7]],
+    [["D", 7], ["B", 7]],
+    [["F", 5], ["R", 3]],
+    [["F", 3], ["L", 5]],
+    [["B", 5], ["L", 3]],
+    [["B", 3], ["R", 5]]
+];
+export function toCube3Facelets(state) {
+    const facelets = createEmptyFacelets();
+    for (const face of FACE_ORDER) {
+        facelets[face][4] = face;
+    }
+    for (let position = 0; position < CORNER_POSITION_SLOTS.length; position += 1) {
+        const piece = state.corners.permutation[position];
+        const orientation = state.corners.orientation[position];
+        placeOrientedStickers(facelets, CORNER_POSITION_SLOTS[position], CORNER_PIECE_STICKERS[piece], orientation);
+    }
+    for (let position = 0; position < EDGE_POSITION_SLOTS.length; position += 1) {
+        const piece = state.edges.permutation[position];
+        const orientation = state.edges.orientation[position];
+        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+    }
+    return facelets;
+}
+export function formatCube3Facelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+export function getCube3FaceOrder() {
+    return FACE_ORDER;
+}
+function createEmptyFacelets() {
+    return {
+        U: Array(9).fill("U"),
+        R: Array(9).fill("R"),
+        F: Array(9).fill("F"),
+        D: Array(9).fill("D"),
+        L: Array(9).fill("L"),
+        B: Array(9).fill("B")
+    };
+}
+function placeOrientedStickers(facelets, slots, stickers, orientation) {
+    for (let index = 0; index < slots.length; index += 1) {
+        const [face, stickerIndex] = slots[index];
+        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
+        facelets[face][stickerIndex] = sticker;
+    }
+}

package/dist/puzzles/cube3/index.d.ts

@@ -0,0 +1,10 @@
+export { CUBE3_MOVES, CORNER_COUNT, EDGE_COUNT } from "./types.js";
+export { applyCube3Algorithm, applyCube3Move, formatCube3Algorithm, invertCube3Algorithm, invertCube3Move, parseCube3Algorithm, parseCube3Move } from "./moves.js";
+export { cloneCube3State, createSolvedCube3State, cube3StatesEqual, isSolvedCube3State } from "./state.js";
+export { isAllowedRandomCube3State, isOneMoveFromSolvedCube3State, permutationParity, validateCube3State } from "./validation.js";
+export { generateRandomCube3State } from "./random-state.js";
+export { cube3ScrambleGenerator, generateCube3Scramble } from "./scrambler.js";
+export { formatCube3Facelets, getCube3FaceOrder, toCube3Facelets } from "./facelets.js";
+export * as solver from "./solver/index.js";
+export type { Cube3Face, Cube3Facelets, Cube3Move, Cube3FaceMove, Cube3MoveSuffix, Cube3RandomStateOptions, Cube3Sticker, Cube3State, Cube3ValidationResult } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/puzzles/cube3/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACX,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,yBAAyB,EACzB,6BAA6B,EAC7B,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EAChB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,aAAa,EACb,eAAe,EACf,uBAAuB,EACvB,YAAY,EACZ,UAAU,EACV,qBAAqB,EACtB,MAAM,YAAY,CAAC"}

package/dist/puzzles/cube3/index.js

@@ -0,0 +1,8 @@
+export { CUBE3_MOVES, CORNER_COUNT, EDGE_COUNT } from "./types.js";
+export { applyCube3Algorithm, applyCube3Move, formatCube3Algorithm, invertCube3Algorithm, invertCube3Move, parseCube3Algorithm, parseCube3Move } from "./moves.js";
+export { cloneCube3State, createSolvedCube3State, cube3StatesEqual, isSolvedCube3State } from "./state.js";
+export { isAllowedRandomCube3State, isOneMoveFromSolvedCube3State, permutationParity, validateCube3State } from "./validation.js";
+export { generateRandomCube3State } from "./random-state.js";
+export { cube3ScrambleGenerator, generateCube3Scramble } from "./scrambler.js";
+export { formatCube3Facelets, getCube3FaceOrder, toCube3Facelets } from "./facelets.js";
+export * as solver from "./solver/index.js";

package/dist/puzzles/cube3/moves.d.ts

@@ -0,0 +1,9 @@
+import type { Cube3Move, Cube3State } from "./types.js";
+export declare function applyCube3Move(state: Cube3State, move: Cube3Move): Cube3State;
+export declare function applyCube3Algorithm(state: Cube3State, moves: readonly Cube3Move[]): Cube3State;
+export declare function invertCube3Algorithm(moves: readonly Cube3Move[]): Cube3Move[];
+export declare function parseCube3Algorithm(algorithm: string): Cube3Move[];
+export declare function formatCube3Algorithm(moves: readonly Cube3Move[]): string;
+export declare function parseCube3Move(value: string): Cube3Move;
+export declare function invertCube3Move(move: Cube3Move): Cube3Move;
+//# sourceMappingURL=moves.d.ts.map

package/dist/puzzles/cube3/moves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/moves.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiB,SAAS,EAAmB,UAAU,EAAE,MAAM,YAAY,CAAC;AAyCxF,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAS7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CAE9F;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAoFlE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAMvD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAQ1D"}

package/dist/puzzles/cube3/moves.js

@@ -0,0 +1,210 @@
+import { CUBE3_MOVES } from "./types.js";
+import { cloneCube3State } from "./state.js";
+const FACE_MOVE_TABLES = {
+    U: {
+        corners: { permutation: [3, 0, 1, 2, 4, 5, 6, 7], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+        edges: { permutation: [3, 0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    D: {
+        corners: { permutation: [0, 1, 2, 3, 5, 6, 7, 4], orientation: [0, 0, 0, 0, 0, 0, 0, 0] },
+        edges: { permutation: [0, 1, 2, 3, 5, 6, 7, 4, 8, 9, 10, 11], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    R: {
+        corners: { permutation: [4, 1, 2, 0, 7, 5, 6, 3], orientation: [2, 0, 0, 1, 1, 0, 0, 2] },
+        edges: { permutation: [8, 1, 2, 3, 11, 5, 6, 7, 4, 9, 10, 0], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    L: {
+        corners: { permutation: [0, 2, 6, 3, 4, 1, 5, 7], orientation: [0, 1, 2, 0, 0, 2, 1, 0] },
+        edges: { permutation: [0, 1, 10, 3, 4, 5, 9, 7, 8, 2, 6, 11], orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
+    },
+    F: {
+        corners: { permutation: [1, 5, 2, 3, 0, 4, 6, 7], orientation: [1, 2, 0, 0, 2, 1, 0, 0] },
+        edges: { permutation: [0, 9, 2, 3, 4, 8, 6, 7, 1, 5, 10, 11], orientation: [0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0] }
+    },
+    B: {
+        corners: { permutation: [0, 1, 3, 7, 4, 5, 2, 6], orientation: [0, 0, 1, 2, 0, 0, 2, 1] },
+        edges: { permutation: [0, 1, 2, 11, 4, 5, 6, 10, 8, 9, 3, 7], orientation: [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1] }
+    }
+};
+export function applyCube3Move(state, move) {
+    const { face, turns } = parseMoveParts(move);
+    let next = cloneCube3State(state);
+    for (let index = 0; index < turns; index += 1) {
+        next = applyFaceMove(next, FACE_MOVE_TABLES[face]);
+    }
+    return next;
+}
+export function applyCube3Algorithm(state, moves) {
+    return moves.reduce((current, move) => applyCube3Move(current, move), state);
+}
+export function invertCube3Algorithm(moves) {
+    return [...moves].reverse().map(invertCube3Move);
+}
+export function parseCube3Algorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    const faces = { U: 'U', D: 'D', R: 'R', L: 'L', F: 'F', B: 'B' };
+    const rotateX = (times) => {
+        for (let i = 0; i < times; i++) {
+            const tempU = faces.U, tempF = faces.F, tempD = faces.D, tempB = faces.B;
+            faces.U = tempF;
+            faces.F = tempD;
+            faces.D = tempB;
+            faces.B = tempU;
+        }
+    };
+    const rotateY = (times) => {
+        for (let i = 0; i < times; i++) {
+            const tempF = faces.F, tempL = faces.L, tempB = faces.B, tempR = faces.R;
+            faces.F = tempR;
+            faces.R = tempB;
+            faces.B = tempL;
+            faces.L = tempF;
+        }
+    };
+    const rotateZ = (times) => {
+        for (let i = 0; i < times; i++) {
+            const tempU = faces.U, tempR = faces.R, tempD = faces.D, tempL = faces.L;
+            faces.U = tempL;
+            faces.L = tempD;
+            faces.D = tempR;
+            faces.R = tempU;
+        }
+    };
+    const result = [];
+    const tokens = trimmed.split(/\s+/).filter(Boolean);
+    for (const token of tokens) {
+        const base = token[0];
+        if (!base)
+            continue;
+        let isWide = false;
+        let isPrime = false;
+        let isDouble = false;
+        let moveName = base;
+        if (token.length > 1) {
+            if (token.includes('w')) {
+                isWide = true;
+                moveName = base.toUpperCase();
+            }
+            if (token.includes("'"))
+                isPrime = true;
+            if (token.includes("2"))
+                isDouble = true;
+        }
+        if (base >= 'a' && base <= 'z' && base !== 'x' && base !== 'y' && base !== 'z') {
+            isWide = true;
+            moveName = base.toUpperCase();
+        }
+        const suffix = isDouble ? "2" : isPrime ? "'" : "";
+        const oppSuffix = isDouble ? "2" : isPrime ? "" : "'";
+        const times = isDouble ? 2 : isPrime ? 3 : 1;
+        const emit = (f, suff) => result.push(`${faces[f]}${suff}`);
+        switch (moveName) {
+            case 'U':
+            case 'D':
+            case 'R':
+            case 'L':
+            case 'F':
+            case 'B':
+                if (isWide) {
+                    if (moveName === 'R') {
+                        emit('R', suffix);
+                        emit('L', oppSuffix);
+                        rotateX(times);
+                    }
+                    else if (moveName === 'L') {
+                        emit('L', suffix);
+                        emit('R', oppSuffix);
+                        rotateX((4 - times) % 4);
+                    }
+                    else if (moveName === 'U') {
+                        emit('U', suffix);
+                        emit('D', oppSuffix);
+                        rotateY(times);
+                    }
+                    else if (moveName === 'D') {
+                        emit('D', suffix);
+                        emit('U', oppSuffix);
+                        rotateY((4 - times) % 4);
+                    }
+                    else if (moveName === 'F') {
+                        emit('F', suffix);
+                        emit('B', oppSuffix);
+                        rotateZ(times);
+                    }
+                    else if (moveName === 'B') {
+                        emit('B', suffix);
+                        emit('F', oppSuffix);
+                        rotateZ((4 - times) % 4);
+                    }
+                }
+                else {
+                    emit(moveName, suffix);
+                }
+                break;
+            case 'M':
+                emit('L', suffix);
+                emit('R', oppSuffix);
+                rotateX((4 - times) % 4);
+                break;
+            case 'E':
+                emit('D', suffix);
+                emit('U', oppSuffix);
+                rotateY((4 - times) % 4);
+                break;
+            case 'S':
+                emit('F', suffix);
+                emit('B', oppSuffix);
+                rotateZ(times);
+                break;
+            case 'x':
+                rotateX(times);
+                break;
+            case 'y':
+                rotateY(times);
+                break;
+            case 'z':
+                rotateZ(times);
+                break;
+            default:
+                throw new Error(`Invalid 3x3 move: ${token}`);
+        }
+    }
+    return result;
+}
+export function formatCube3Algorithm(moves) {
+    return moves.join(" ");
+}
+export function parseCube3Move(value) {
+    if (CUBE3_MOVES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid 3x3 move: ${value}`);
+}
+export function invertCube3Move(move) {
+    const { face, suffix } = parseMoveParts(move);
+    if (suffix === "2") {
+        return move;
+    }
+    return `${face}${suffix === "'" ? "" : "'"}`;
+}
+function applyFaceMove(state, table) {
+    return {
+        corners: {
+            permutation: table.corners.permutation.map((source) => state.corners.permutation[source]),
+            orientation: table.corners.permutation.map((source, target) => ((state.corners.orientation[source] + table.corners.orientation[target]) % 3))
+        },
+        edges: {
+            permutation: table.edges.permutation.map((source) => state.edges.permutation[source]),
+            orientation: table.edges.permutation.map((source, target) => ((state.edges.orientation[source] + table.edges.orientation[target]) % 2))
+        }
+    };
+}
+function parseMoveParts(move) {
+    const face = move[0];
+    const suffix = move.slice(1);
+    const turns = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    return { face, suffix, turns };
+}

package/dist/puzzles/cube3/random-state.d.ts

@@ -0,0 +1,3 @@
+import type { Cube3RandomStateOptions, Cube3State } from "./types.js";
+export declare function generateRandomCube3State(options?: Cube3RandomStateOptions): Cube3State;
+//# sourceMappingURL=random-state.d.ts.map

package/dist/puzzles/cube3/random-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/random-state.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAItE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAiB1F"}

package/dist/puzzles/cube3/random-state.js

@@ -0,0 +1,59 @@
+import { createRandomSource } from "../../random/index.js";
+import { CORNER_COUNT, EDGE_COUNT } from "./types.js";
+import { isAllowedRandomCube3State, permutationParity } from "./validation.js";
+import { generateSubsetCube3State } from "./subset-state.js";
+export function generateRandomCube3State(options = {}) {
+    const random = createRandomSource(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    if (options.subset) {
+        return generateSubsetCube3State(options.subset, random);
+    }
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || isAllowedRandomCube3State(state)) {
+            return state;
+        }
+    }
+    throw new Error("Unable to generate a non-trivial random 3x3 state.");
+}
+function createLegalRandomState(random) {
+    const cornerPermutation = shuffledRange(CORNER_COUNT, random);
+    const edgePermutation = shuffledRange(EDGE_COUNT, random);
+    if (permutationParity(cornerPermutation) !== permutationParity(edgePermutation)) {
+        swap(edgePermutation, 0, 1);
+    }
+    return {
+        corners: {
+            permutation: cornerPermutation,
+            orientation: randomOrientations(CORNER_COUNT, 3, random)
+        },
+        edges: {
+            permutation: edgePermutation,
+            orientation: randomOrientations(EDGE_COUNT, 2, random)
+        }
+    };
+}
+function shuffledRange(length, random) {
+    const values = Array.from({ length }, (_, index) => index);
+    for (let index = values.length - 1; index > 0; index -= 1) {
+        const swapIndex = random.nextInt(index + 1);
+        swap(values, index, swapIndex);
+    }
+    return values;
+}
+function randomOrientations(length, modulo, random) {
+    const orientations = Array(length).fill(0);
+    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 swap(values, left, right) {
+    const temporary = values[left];
+    values[left] = values[right];
+    values[right] = temporary;
+}

package/dist/puzzles/cube3/scrambler.d.ts

@@ -0,0 +1,6 @@
+import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
+export declare const cube3ScrambleGenerator: ScrambleGenerator;
+export declare function generateCube3Scramble(options?: ScrambleOptions & {
+    skipValidation?: boolean;
+}): Promise<ScrambleResult>;
+//# sourceMappingURL=scrambler.d.ts.map

package/dist/puzzles/cube3/scrambler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAW9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CA+CzB"}

package/dist/puzzles/cube3/scrambler.js

@@ -0,0 +1,59 @@
+import { applyCube3Algorithm, formatCube3Algorithm, invertCube3Algorithm } from "./moves.js";
+import { generateRandomCube3State } from "./random-state.js";
+import { createSolvedCube3State, cube3StatesEqual, isSolvedCube3State } from "./state.js";
+import { formatCube3Facelets, toCube3Facelets } from "./facelets.js";
+import { solveCube3State } from "./solver/index.js";
+export const cube3ScrambleGenerator = {
+    info: {
+        eventId: "333",
+        name: "3x3x3 Cube",
+        puzzle: "cube-3x3",
+        quality: "random-state",
+        generator: "cube3-two-phase",
+        description: "Random-state 3x3 scramble generated by the CubingCenter two-phase solver."
+    },
+    generate(options = {}) {
+        return generateCube3Scramble(options);
+    }
+};
+export async function generateCube3Scramble(options = {}) {
+    const state = generateRandomCube3State(options);
+    const solution = await solveCube3State(state);
+    const scrambleMoves = invertCube3Algorithm(solution.moves);
+    if (!options.skipValidation) {
+        const scrambledState = applyCube3Algorithm(createSolvedCube3State(), scrambleMoves);
+        if (!cube3StatesEqual(scrambledState, state)) {
+            throw new Error("Generated 3x3 scramble does not reproduce the target random state.");
+        }
+        if (!isSolvedCube3State(solution.state)) {
+            throw new Error("Generated 3x3 solution does not solve the target random state.");
+        }
+        if (scrambleMoves.length < 2) {
+            throw new Error("Generated 3x3 scramble is too short.");
+        }
+    }
+    const facelets = toCube3Facelets(state);
+    const result = {
+        eventId: "333",
+        scramble: formatCube3Algorithm(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "cube3-two-phase",
+        metadata: {
+            generator: "cube3-two-phase",
+            generatorVersion: "1.0.0",
+            faceletString: formatCube3Facelets(facelets),
+            state: JSON.parse(JSON.stringify(state)),
+            solutionMoves: solution.moves,
+            solutionDepth: solution.depth,
+            phase1Depth: solution.phase1.depth,
+            phase2Depth: solution.phase2.depth,
+            visitedNodes: solution.visitedNodes,
+            ...options.metadata
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}

package/dist/puzzles/cube3/solver/browser-loader.d.ts

@@ -0,0 +1,5 @@
+import type { Cube3SolverTables } from "./tables.js";
+export declare function getCachedBrowserTables(): Cube3SolverTables | undefined;
+export declare function clearCachedBrowserTables(): void;
+export declare function loadBrowserTables(baseUrl?: string): Promise<Cube3SolverTables>;
+//# sourceMappingURL=browser-loader.d.ts.map

package/dist/puzzles/cube3/solver/browser-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/browser-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAKV,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAqCrB,wBAAgB,sBAAsB,IAAI,iBAAiB,GAAG,SAAS,CAEtE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA0CpF"}

package/dist/puzzles/cube3/solver/browser-loader.js

@@ -0,0 +1,134 @@
+let browserTables;
+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 ".";
+}
+export function getCachedBrowserTables() {
+    return browserTables;
+}
+export function clearCachedBrowserTables() {
+    browserTables = undefined;
+}
+export async function loadBrowserTables(baseUrl) {
+    if (browserTables) {
+        return browserTables;
+    }
+    const resolvedBase = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolvedBase);
+    browserTables = {
+        phase1Moves: manifest.phase1Moves,
+        phase2Moves: manifest.phase2Moves,
+        moveTables: {
+            cornerOrientation: await fetchMoveTable(resolvedBase, manifest.moveTables.cornerOrientation),
+            edgeOrientation: await fetchMoveTable(resolvedBase, manifest.moveTables.edgeOrientation),
+            udSlice: await fetchMoveTable(resolvedBase, manifest.moveTables.udSlice),
+            cornerPermutation: await fetchMoveTable(resolvedBase, manifest.moveTables.cornerPermutation),
+            udEdgePermutation: await fetchMoveTable(resolvedBase, manifest.moveTables.udEdgePermutation),
+            slicePermutation: await fetchMoveTable(resolvedBase, manifest.moveTables.slicePermutation)
+        },
+        pruningTables: {
+            cornerOrientation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerOrientation),
+            edgeOrientation: await fetchPruningTable(resolvedBase, manifest.pruningTables.edgeOrientation),
+            udSlice: await fetchPruningTable(resolvedBase, manifest.pruningTables.udSlice),
+            cornerOrientationEdgeOrientation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerOrientationEdgeOrientation),
+            cornerPermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerPermutation),
+            udEdgePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.udEdgePermutation),
+            slicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.slicePermutation),
+            cornerPermutationSlicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerPermutationSlicePermutation),
+            udEdgePermutationSlicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.udEdgePermutationSlicePermutation)
+        }
+    };
+    return browserTables;
+}
+const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
+async function cachedFetch(url) {
+    // Try Cache API first
+    if (typeof caches !== "undefined") {
+        try {
+            const cache = await caches.open(CACHE_NAME);
+            const cached = await cache.match(url);
+            if (cached) {
+                return cached.arrayBuffer();
+            }
+            const response = await fetch(url);
+            if (response.ok) {
+                // Clone before reading so we can store the clone
+                await cache.put(url, response.clone());
+            }
+            return response.arrayBuffer();
+        }
+        catch {
+            // Cache API failed (e.g. quota exceeded, private mode) — fall through
+        }
+    }
+    // Fallback: plain fetch
+    const response = await fetch(url);
+    return response.arrayBuffer();
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/puzzles/cube3/solver/generated/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const manifest = await response.json();
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported 3x3 solver table manifest version: ${manifest.version}`);
+    }
+    return manifest;
+}
+async function fetchMoveTable(baseUrl, entry) {
+    const url = `${baseUrl}/puzzles/cube3/solver/generated/${entry.file}`;
+    const buffer = await cachedFetch(url);
+    const expectedBytes = entry.range * entry.moves.length * 4;
+    if (buffer.byteLength !== expectedBytes) {
+        throw new Error(`Invalid byte size for ${entry.coordinate} move table.`);
+    }
+    const values = new Int32Array(entry.range * entry.moves.length);
+    const view = new DataView(buffer);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = view.getInt32(index * 4, true);
+    }
+    return {
+        coordinate: entry.coordinate,
+        moves: entry.moves,
+        range: entry.range,
+        solvedCoordinate: entry.solvedCoordinate,
+        values,
+        checksum: checksum(values)
+    };
+}
+async function fetchPruningTable(baseUrl, entry) {
+    const url = `${baseUrl}/puzzles/cube3/solver/generated/${entry.file}`;
+    const buffer = await cachedFetch(url);
+    const expectedBytes = Math.ceil(entry.range / 2);
+    if (buffer.byteLength !== expectedBytes) {
+        throw new Error(`Invalid byte size for ${entry.coordinate} pruning table.`);
+    }
+    const values = new Uint8Array(buffer);
+    return {
+        coordinate: entry.coordinate,
+        moves: entry.moves,
+        range: entry.range,
+        values,
+        checksum: checksum(values),
+        maxDepth: entry.maxDepth ?? 0
+    };
+}
+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/cube3/solver/browser-worker-pool.d.ts

@@ -0,0 +1,31 @@
+import type { ScrambleOptions, ScrambleResult } from "../../../core/types.js";
+/**
+ * Web Worker pool for browser environments.
+ *
+ * Each worker loads solver tables independently (~10 MB per worker).
+ * Best suited for batch generation on client devices with 2+ cores.
+ *
+ * Usage:
+ * ```ts
+ * const pool = new Cube3BrowserWorkerPool();
+ * const results = await pool.generateBatch(50, (i) => `seed-${i}`);
+ * pool.terminate();
+ * ```
+ */
+export declare class Cube3BrowserWorkerPool {
+    private workers;
+    private available;
+    private pending;
+    private queue;
+    private nextId;
+    private terminated;
+    constructor(size?: number);
+    generate(options?: ScrambleOptions & {
+        skipValidation?: boolean;
+    }): Promise<ScrambleResult>;
+    generateBatch(count: number, deriveSeed: (index: number) => string | number | undefined): Promise<ScrambleResult[]>;
+    terminate(): void;
+    private handleResponse;
+    private handleError;
+}
+//# sourceMappingURL=browser-worker-pool.d.ts.map

package/dist/puzzles/cube3/solver/browser-worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-worker-pool.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/browser-worker-pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAiC9E;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,UAAU,CAAS;gBAGzB,IAAI,GAAE,MAA2D;IA2BnE,QAAQ,CACN,OAAO,GAAE,eAAe,GAAG;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAC3D,OAAO,CAAC,cAAc,CAAC;IA0B1B,aAAa,CACX,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,GAAG,SAAS,GACzD,OAAO,CAAC,cAAc,EAAE,CAAC;IAQ5B,SAAS,IAAI,IAAI;IAajB,OAAO,CAAC,cAAc;IAwBtB,OAAO,CAAC,WAAW;CAIpB"}