@cubingcenter/scrambler 0.1.0

package/dist/puzzles/cube3/solver/browser-worker-pool.js

@@ -0,0 +1,118 @@
+function getHardwareConcurrency() {
+    if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) {
+        return navigator.hardwareConcurrency;
+    }
+    return 4;
+}
+function resolveWorkerUrl() {
+    // Standard ESM pattern: bundlers (Vite, Webpack 5, Parcel) detect
+    // new Worker(new URL('./file.js', import.meta.url)) and handle the worker
+    // as a separate chunk automatically.
+    return new URL("./browser-worker.js", import.meta.url).href;
+}
+/**
+ * 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 class Cube3BrowserWorkerPool {
+    workers = [];
+    available = [];
+    pending = new Map();
+    queue = [];
+    nextId = 0;
+    terminated = false;
+    constructor(size = Math.max(1, Math.min(8, getHardwareConcurrency()))) {
+        if (typeof Worker === "undefined") {
+            throw new Error("Web Workers are not available in this environment. " +
+                "Use generateScramble() directly for single-threaded generation.");
+        }
+        const workerUrl = resolveWorkerUrl();
+        for (let i = 0; i < size; i++) {
+            const worker = new Worker(workerUrl, { type: "module" });
+            worker.onmessage = (event) => {
+                this.handleResponse(worker, event.data);
+            };
+            worker.onerror = (error) => {
+                this.handleError(error);
+            };
+            this.workers.push(worker);
+            this.available.push(worker);
+        }
+    }
+    generate(options = {}) {
+        if (this.terminated) {
+            return Promise.reject(new Error("Worker pool has been terminated."));
+        }
+        const id = this.nextId++;
+        const task = {
+            id,
+            ...(options.seed !== undefined ? { seed: options.seed } : {}),
+            ...(options.skipValidation !== undefined
+                ? { skipValidation: options.skipValidation }
+                : {})
+        };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            if (this.available.length > 0) {
+                const worker = this.available.pop();
+                worker.postMessage(task);
+            }
+            else {
+                this.queue.push(task);
+            }
+        });
+    }
+    generateBatch(count, deriveSeed) {
+        const promises = Array.from({ length: count }, (_, index) => {
+            const seed = deriveSeed(index);
+            return this.generate(seed !== undefined ? { seed } : {});
+        });
+        return Promise.all(promises);
+    }
+    terminate() {
+        this.terminated = true;
+        this.queue = [];
+        this.pending.forEach(({ reject }) => {
+            reject(new Error("Worker pool terminated."));
+        });
+        this.pending.clear();
+        for (const worker of this.workers) {
+            worker.terminate();
+        }
+    }
+    handleResponse(worker, response) {
+        const pending = this.pending.get(response.id);
+        if (!pending)
+            return;
+        this.pending.delete(response.id);
+        if (response.error) {
+            pending.reject(new Error(response.error));
+        }
+        else if (response.result) {
+            pending.resolve(response.result);
+        }
+        else {
+            pending.reject(new Error("Worker returned empty response."));
+        }
+        if (this.queue.length > 0) {
+            const nextTask = this.queue.shift();
+            worker.postMessage(nextTask);
+        }
+        else {
+            this.available.push(worker);
+        }
+    }
+    handleError(error) {
+        this.pending.forEach(({ reject }) => reject(error.error));
+        this.pending.clear();
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=browser-worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser-worker.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/browser-worker.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,71 @@
+/// <reference lib="webworker" />
+import { generateRandomCube3State } from "../random-state.js";
+import { createSolvedCube3State, cube3StatesEqual, isSolvedCube3State } from "../state.js";
+import { applyCube3Algorithm, formatCube3Algorithm, invertCube3Algorithm } from "../moves.js";
+import { formatCube3Facelets, toCube3Facelets } from "../facelets.js";
+import { solveCube3State } from "./index.js";
+import { loadBrowserTables } from "./browser-loader.js";
+let tablesLoaded = false;
+async function ensureTables() {
+    if (tablesLoaded)
+        return;
+    await loadBrowserTables();
+    tablesLoaded = true;
+}
+async function generate(task) {
+    await ensureTables();
+    const options = {
+        ...(task.seed !== undefined ? { seed: task.seed } : {}),
+        ...(task.skipValidation !== undefined ? { skipValidation: task.skipValidation } : {})
+    };
+    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: {
+            state,
+            facelets,
+            faceletString: formatCube3Facelets(facelets),
+            solutionMoves: solution.moves,
+            solutionDepth: solution.depth,
+            phase1Depth: solution.phase1.depth,
+            phase2Depth: solution.phase2.depth,
+            visitedNodes: solution.visitedNodes
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+self.onmessage = async (event) => {
+    const task = event.data;
+    try {
+        const result = await generate(task);
+        const response = { id: task.id, result };
+        self.postMessage(response);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const response = { id: task.id, error: message };
+        self.postMessage(response);
+    }
+};

package/dist/puzzles/cube3/solver/coordinates.d.ts

@@ -0,0 +1,34 @@
+import type { Cube3Move, Cube3State } from "../types.js";
+export declare const CUBE3_COORDINATE_RANGES: {
+    readonly cornerOrientation: 2187;
+    readonly edgeOrientation: 2048;
+    readonly udSlice: 495;
+    readonly cornerPermutation: 40320;
+    readonly udEdgePermutation: 40320;
+    readonly slicePermutation: 24;
+};
+export interface Cube3CoordinateState {
+    cornerOrientation: number;
+    edgeOrientation: number;
+    udSlice: number;
+    cornerPermutation: number;
+    udEdgePermutation: number;
+    slicePermutation: number;
+}
+export declare function encodeCube3Coordinates(state: Cube3State): Cube3CoordinateState;
+export declare function encodeCube3Coordinate(coordinateName: keyof Cube3CoordinateState, state: Cube3State): number;
+export declare function encodeCornerOrientation(state: Cube3State): number;
+export declare function decodeCornerOrientation(coordinate: number): number[];
+export declare function encodeEdgeOrientation(state: Cube3State): number;
+export declare function decodeEdgeOrientation(coordinate: number): number[];
+export declare function encodeUdSlice(state: Cube3State): number;
+export declare function decodeUdSlice(coordinate: number): number[];
+export declare function encodeUdEdgePermutation(state: Cube3State): number;
+export declare function decodeUdEdgePermutation(coordinate: number): number[];
+export declare function encodeSlicePermutation(state: Cube3State): number;
+export declare function decodeSlicePermutation(coordinate: number): number[];
+export declare function decodePermutation(coordinate: number, length: number): number[];
+export declare function encodePermutation(permutation: readonly number[]): number;
+export declare function createRepresentativeStateForCoordinate(coordinateName: keyof Cube3CoordinateState, coordinate: number): Cube3State;
+export declare function moveCoordinate(coordinateName: keyof Cube3CoordinateState, coordinate: number, move: Cube3Move): number;
+//# sourceMappingURL=coordinates.d.ts.map

package/dist/puzzles/cube3/solver/coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinates.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube3/solver/coordinates.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,uBAAuB;;;;;;;CAO1B,CAAC;AAEX,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAUD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,oBAAoB,CAS9E;AAED,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,oBAAoB,EAC1C,KAAK,EAAE,UAAU,GAChB,MAAM,CAsBR;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAWjE;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBpE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAW/D;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBlE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAoBvD;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAG1D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CASjE;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAWhE;AAED,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAEnE;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAe9E;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAcxE;AAED,wBAAgB,sCAAsC,CACpD,cAAc,EAAE,MAAM,oBAAoB,EAC1C,UAAU,EAAE,MAAM,GACjB,UAAU,CAiDZ;AAED,wBAAgB,cAAc,CAC5B,cAAc,EAAE,MAAM,oBAAoB,EAC1C,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,SAAS,GACd,MAAM,CAIR"}

package/dist/puzzles/cube3/solver/coordinates.js

@@ -0,0 +1,266 @@
+import { applyCube3Move } from "../moves.js";
+import { createSolvedCube3State } from "../state.js";
+import { CORNER_COUNT, EDGE_COUNT } from "../types.js";
+export const CUBE3_COORDINATE_RANGES = {
+    cornerOrientation: 2187,
+    edgeOrientation: 2048,
+    udSlice: 495,
+    cornerPermutation: 40320,
+    udEdgePermutation: 40320,
+    slicePermutation: 24
+};
+const SLICE_EDGE_START = 8;
+const UD_EDGE_COUNT = 8;
+const SLICE_EDGE_COUNT = 4;
+const UD_SLICE_COMBINATIONS = createCombinations(EDGE_COUNT, SLICE_EDGE_COUNT);
+const UD_SLICE_INDEX_BY_KEY = new Map(UD_SLICE_COMBINATIONS.map((combination, index) => [combination.join(","), index]));
+export function encodeCube3Coordinates(state) {
+    return {
+        cornerOrientation: encodeCornerOrientation(state),
+        edgeOrientation: encodeEdgeOrientation(state),
+        udSlice: encodeUdSlice(state),
+        cornerPermutation: encodePermutation(state.corners.permutation),
+        udEdgePermutation: encodeUdEdgePermutation(state),
+        slicePermutation: encodeSlicePermutation(state)
+    };
+}
+export function encodeCube3Coordinate(coordinateName, state) {
+    if (coordinateName === "cornerOrientation") {
+        return encodeCornerOrientation(state);
+    }
+    if (coordinateName === "edgeOrientation") {
+        return encodeEdgeOrientation(state);
+    }
+    if (coordinateName === "udSlice") {
+        return encodeUdSlice(state);
+    }
+    if (coordinateName === "cornerPermutation") {
+        return encodePermutation(state.corners.permutation);
+    }
+    if (coordinateName === "udEdgePermutation") {
+        return encodeUdEdgePermutation(state);
+    }
+    return encodeSlicePermutation(state);
+}
+export function encodeCornerOrientation(state) {
+    assertLength(state.corners.orientation, CORNER_COUNT, "corner orientation");
+    let coordinate = 0;
+    for (let index = 0; index < CORNER_COUNT - 1; index += 1) {
+        const orientation = state.corners.orientation[index];
+        assertRange(orientation, 0, 2, "corner orientation");
+        coordinate = coordinate * 3 + orientation;
+    }
+    return coordinate;
+}
+export function decodeCornerOrientation(coordinate) {
+    assertCoordinate(coordinate, CUBE3_COORDINATE_RANGES.cornerOrientation, "corner orientation");
+    const orientations = Array(CORNER_COUNT).fill(0);
+    let remaining = coordinate;
+    let total = 0;
+    for (let index = CORNER_COUNT - 2; index >= 0; index -= 1) {
+        const orientation = remaining % 3;
+        orientations[index] = orientation;
+        total += orientation;
+        remaining = Math.floor(remaining / 3);
+    }
+    orientations[CORNER_COUNT - 1] = (3 - (total % 3)) % 3;
+    return orientations;
+}
+export function encodeEdgeOrientation(state) {
+    assertLength(state.edges.orientation, EDGE_COUNT, "edge orientation");
+    let coordinate = 0;
+    for (let index = 0; index < EDGE_COUNT - 1; index += 1) {
+        const orientation = state.edges.orientation[index];
+        assertRange(orientation, 0, 1, "edge orientation");
+        coordinate = coordinate * 2 + orientation;
+    }
+    return coordinate;
+}
+export function decodeEdgeOrientation(coordinate) {
+    assertCoordinate(coordinate, CUBE3_COORDINATE_RANGES.edgeOrientation, "edge orientation");
+    const orientations = Array(EDGE_COUNT).fill(0);
+    let remaining = coordinate;
+    let total = 0;
+    for (let index = EDGE_COUNT - 2; index >= 0; index -= 1) {
+        const orientation = remaining % 2;
+        orientations[index] = orientation;
+        total += orientation;
+        remaining = Math.floor(remaining / 2);
+    }
+    orientations[EDGE_COUNT - 1] = total % 2;
+    return orientations;
+}
+export function encodeUdSlice(state) {
+    assertLength(state.edges.permutation, EDGE_COUNT, "edge permutation");
+    const positions = state.edges.permutation
+        .map((piece, position) => ({ piece, position }))
+        .filter(({ piece }) => piece >= SLICE_EDGE_START)
+        .map(({ position }) => position);
+    if (positions.length !== SLICE_EDGE_COUNT) {
+        throw new RangeError("UD slice coordinate requires exactly four slice edges.");
+    }
+    const key = positions.join(",");
+    const coordinate = UD_SLICE_INDEX_BY_KEY.get(key);
+    if (coordinate === undefined) {
+        throw new RangeError(`Invalid UD slice positions: ${key}`);
+    }
+    return coordinate;
+}
+export function decodeUdSlice(coordinate) {
+    assertCoordinate(coordinate, CUBE3_COORDINATE_RANGES.udSlice, "UD slice");
+    return [...UD_SLICE_COMBINATIONS[coordinate]];
+}
+export function encodeUdEdgePermutation(state) {
+    assertLength(state.edges.permutation, EDGE_COUNT, "edge permutation");
+    const permutation = state.edges.permutation.slice(0, UD_EDGE_COUNT);
+    if (permutation.some((piece) => piece < 0 || piece >= UD_EDGE_COUNT)) {
+        throw new RangeError("UD edge permutation requires UD edges in UD edge positions.");
+    }
+    return encodePermutation(permutation);
+}
+export function decodeUdEdgePermutation(coordinate) {
+    return decodePermutation(coordinate, UD_EDGE_COUNT);
+}
+export function encodeSlicePermutation(state) {
+    assertLength(state.edges.permutation, EDGE_COUNT, "edge permutation");
+    const permutation = state.edges.permutation
+        .slice(SLICE_EDGE_START)
+        .map((piece) => piece - SLICE_EDGE_START);
+    if (permutation.some((piece) => piece < 0 || piece >= SLICE_EDGE_COUNT)) {
+        throw new RangeError("Slice permutation requires slice edges in slice positions.");
+    }
+    return encodePermutation(permutation);
+}
+export function decodeSlicePermutation(coordinate) {
+    return decodePermutation(coordinate, SLICE_EDGE_COUNT).map((piece) => piece + SLICE_EDGE_START);
+}
+export function decodePermutation(coordinate, length) {
+    assertCoordinate(coordinate, factorial(length), `permutation length ${length}`);
+    const available = Array.from({ length }, (_, index) => index);
+    const permutation = [];
+    let remaining = coordinate;
+    for (let index = length; index > 0; index -= 1) {
+        const placeValue = factorial(index - 1);
+        const selected = Math.floor(remaining / placeValue);
+        permutation.push(available.splice(selected, 1)[0]);
+        remaining %= placeValue;
+    }
+    return permutation;
+}
+export function encodePermutation(permutation) {
+    validatePermutation(permutation);
+    const available = Array.from({ length: permutation.length }, (_, index) => index);
+    let coordinate = 0;
+    for (let index = 0; index < permutation.length; index += 1) {
+        const value = permutation[index];
+        const selected = available.indexOf(value);
+        coordinate += selected * factorial(permutation.length - index - 1);
+        available.splice(selected, 1);
+    }
+    return coordinate;
+}
+export function createRepresentativeStateForCoordinate(coordinateName, coordinate) {
+    const state = createSolvedCube3State();
+    if (coordinateName === "cornerOrientation") {
+        state.corners.orientation = decodeCornerOrientation(coordinate);
+    }
+    else if (coordinateName === "edgeOrientation") {
+        state.edges.orientation = decodeEdgeOrientation(coordinate);
+    }
+    else if (coordinateName === "udSlice") {
+        const slicePositions = new Set(decodeUdSlice(coordinate));
+        const edgePermutation = Array(EDGE_COUNT).fill(-1);
+        let udEdge = 0;
+        let sliceEdge = SLICE_EDGE_START;
+        for (let position = 0; position < EDGE_COUNT; position += 1) {
+            if (slicePositions.has(position)) {
+                edgePermutation[position] = sliceEdge;
+                sliceEdge += 1;
+            }
+            else {
+                edgePermutation[position] = udEdge;
+                udEdge += 1;
+            }
+        }
+        state.edges.permutation = edgePermutation;
+    }
+    else if (coordinateName === "cornerPermutation") {
+        state.corners.permutation = decodePermutation(coordinate, CORNER_COUNT);
+    }
+    else if (coordinateName === "udEdgePermutation") {
+        state.edges.permutation = [
+            ...decodeUdEdgePermutation(coordinate),
+            8,
+            9,
+            10,
+            11
+        ];
+    }
+    else {
+        state.edges.permutation = [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            ...decodeSlicePermutation(coordinate)
+        ];
+    }
+    return state;
+}
+export function moveCoordinate(coordinateName, coordinate, move) {
+    const state = createRepresentativeStateForCoordinate(coordinateName, coordinate);
+    const moved = applyCube3Move(state, move);
+    return encodeCube3Coordinate(coordinateName, moved);
+}
+function createCombinations(size, selected) {
+    const combinations = [];
+    function visit(start, current) {
+        if (current.length === selected) {
+            combinations.push([...current]);
+            return;
+        }
+        for (let value = start; value <= size - (selected - current.length); value += 1) {
+            current.push(value);
+            visit(value + 1, current);
+            current.pop();
+        }
+    }
+    visit(0, []);
+    return combinations;
+}
+function validatePermutation(permutation) {
+    const seen = new Set();
+    for (const value of permutation) {
+        assertRange(value, 0, permutation.length - 1, "permutation value");
+        if (seen.has(value)) {
+            throw new RangeError(`Permutation contains duplicate value: ${value}`);
+        }
+        seen.add(value);
+    }
+}
+function assertLength(values, expected, label) {
+    if (values.length !== expected) {
+        throw new RangeError(`${label} must contain ${expected} values.`);
+    }
+}
+function assertRange(value, min, max, label) {
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new RangeError(`${label} must be an integer between ${min} and ${max}. Received: ${value}`);
+    }
+}
+function assertCoordinate(value, range, label) {
+    if (!Number.isInteger(value) || value < 0 || value >= range) {
+        throw new RangeError(`${label} coordinate must be between 0 and ${range - 1}. Received: ${value}`);
+    }
+}
+function factorial(value) {
+    let result = 1;
+    for (let factor = 2; factor <= value; factor += 1) {
+        result *= factor;
+    }
+    return result;
+}