@cubingcenter/scrambler 0.6.3 → 0.8.0

package/dist/puzzles/cube3/validation.js

@@ -41,15 +41,23 @@ export function isAllowedRandomCube3State(state) {
         !isOneMoveFromSolvedCube3State(state);
 }
 export function permutationParity(permutation) {
-    let inversions = 0;
-    for (let left = 0; left < permutation.length; left += 1) {
-        for (let right = left + 1; right < permutation.length; right += 1) {
-            if (permutation[left] > permutation[right]) {
-                inversions += 1;
-            }
+    // Cycle-decomposition parity in O(n) instead of O(n²) inversion counting
+    // (identical result: parity = (n − cycles) mod 2).
+    const visited = new Array(permutation.length).fill(false);
+    let parity = 0;
+    for (let start = 0; start < permutation.length; start += 1) {
+        if (visited[start] || permutation[start] === start)
+            continue;
+        let length = 0;
+        let current = start;
+        while (!visited[current]) {
+            visited[current] = true;
+            current = permutation[current];
+            length += 1;
         }
+        parity ^= (length - 1) & 1;
     }
-    return (inversions % 2);
+    return parity;
 }
 function validatePermutation(label, permutation, length) {
     const errors = [];

package/dist/puzzles/cube4/browser-worker-pool.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Web Worker pool for 4x4 random-state scrambles — the browser counterpart
+ * of `worker-pool.ts` with the same protocol, lazy-spawn lifecycle, FIFO
+ * queue, typed error propagation and per-thread table reuse.
+ *
+ * Unlike the Node pool (which locates its own worker file), the browser
+ * pool REQUIRES the caller to pass `workerUrl`, because only the caller's
+ * file can host the static `new URL("./browser-worker.js", import.meta.url)`
+ * expression that bundlers (Vite, Webpack 5, Parcel) statically analyse to
+ * emit a separate worker chunk:
+ *
+ * ```ts
+ * const pool = new Cube4BrowserWorkerPool({
+ *   workerUrl: new URL("./browser-worker.js", import.meta.url)
+ * });
+ * const batch = await pool.generateBatch(8, { seed: "demo" });
+ * await pool.terminate();
+ * ```
+ *
+ * This file contains no `import.meta` and no static Node imports, so it
+ * also compiles in the CommonJS build (unlike a hard-coded
+ * `new URL(..., import.meta.url)` default).
+ *
+ * Errors crossing the worker boundary arrive as `Error` instances with the
+ * original `name`, `message` and `code` preserved (`worker-protocol.ts`).
+ */
+import type { ScrambleResult } from "../../core/types.js";
+import { type Cube4WorkerGenerationOptions } from "./worker-protocol.js";
+export interface Cube4BrowserWorkerPoolOptions {
+    /**
+     * URL of the worker entry, normally
+     * `new URL("./browser-worker.js", import.meta.url)` written in the
+     * consumer's module (statically analysable by bundlers).
+     */
+    workerUrl: string | URL;
+    /**
+     * Maximum number of Web Workers. Defaults to
+     * `navigator.hardwareConcurrency - 1` (min 1).
+     */
+    size?: number;
+}
+/** Typed rejection used for post-terminate operations and shutdown itself. */
+export declare class Cube4BrowserWorkerPoolClosedError extends Error {
+    readonly code: "cube4-browser-pool-closed";
+    constructor(action?: string);
+}
+/**
+ * Batch seed derivation — identical to core `generateScrambles` and to
+ * `deriveBatchCube4Options` in the Node pool.
+ */
+export declare function deriveBrowserBatchCube4Options(options: Cube4WorkerGenerationOptions, index: number, count: number): Cube4WorkerGenerationOptions;
+export declare class Cube4BrowserWorkerPool {
+    private readonly workers;
+    private readonly queue;
+    private readonly workerUrl;
+    private readonly maxSize;
+    private pumping;
+    private terminatePromise;
+    private nextId;
+    private terminated;
+    constructor(options: Cube4BrowserWorkerPoolOptions);
+    /** Threads spawned so far (lazily grown; 0 before the first job). */
+    get workerCount(): number;
+    get queuedCount(): number;
+    get busyCount(): number;
+    get closed(): boolean;
+    generate(options?: Cube4WorkerGenerationOptions): Promise<ScrambleResult>;
+    generateBatch(count: number, options?: Cube4WorkerGenerationOptions): Promise<ScrambleResult[]>;
+    /**
+     * Prompt shutdown: rejects queued/in-flight tasks and terminates every
+     * Web Worker synchronously (no threads to join in the browser).
+     * Idempotent.
+     */
+    terminate(): void;
+    private pump;
+    private runPump;
+    private spawnWorker;
+    private dispatch;
+    private handleResponse;
+    private handleWorkerGone;
+}
+//# sourceMappingURL=browser-worker-pool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser-worker-pool.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/browser-worker-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAEL,KAAK,4BAA4B,EAGlC,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,6BAA6B;IAC5C;;;;OAIG;IACH,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC;IACxB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,8EAA8E;AAC9E,qBAAa,iCAAkC,SAAQ,KAAK;IAC1D,QAAQ,CAAC,IAAI,EAAG,2BAA2B,CAAU;gBAEzC,MAAM,SAAc;CAIjC;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,4BAA4B,EACrC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,4BAA4B,CAK9B;AAqBD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,EAAE,6BAA6B;IAiBlD,qEAAqE;IACrE,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,QAAQ,CAAC,OAAO,GAAE,4BAAiC,GAAG,OAAO,CAAC,cAAc,CAAC;IAW7E,aAAa,CACX,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,cAAc,EAAE,CAAC;IAW5B;;;;OAIG;IACH,SAAS,IAAI,IAAI;IAoBjB,OAAO,CAAC,IAAI;YAUE,OAAO;IAerB,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,QAAQ;IAYhB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,gBAAgB;CAUzB"}

package/dist/puzzles/cube4/browser-worker-pool.js

@@ -0,0 +1,205 @@
+/**
+ * Web Worker pool for 4x4 random-state scrambles — the browser counterpart
+ * of `worker-pool.ts` with the same protocol, lazy-spawn lifecycle, FIFO
+ * queue, typed error propagation and per-thread table reuse.
+ *
+ * Unlike the Node pool (which locates its own worker file), the browser
+ * pool REQUIRES the caller to pass `workerUrl`, because only the caller's
+ * file can host the static `new URL("./browser-worker.js", import.meta.url)`
+ * expression that bundlers (Vite, Webpack 5, Parcel) statically analyse to
+ * emit a separate worker chunk:
+ *
+ * ```ts
+ * const pool = new Cube4BrowserWorkerPool({
+ *   workerUrl: new URL("./browser-worker.js", import.meta.url)
+ * });
+ * const batch = await pool.generateBatch(8, { seed: "demo" });
+ * await pool.terminate();
+ * ```
+ *
+ * This file contains no `import.meta` and no static Node imports, so it
+ * also compiles in the CommonJS build (unlike a hard-coded
+ * `new URL(..., import.meta.url)` default).
+ *
+ * Errors crossing the worker boundary arrive as `Error` instances with the
+ * original `name`, `message` and `code` preserved (`worker-protocol.ts`).
+ */
+import { deserializeCube4Error } from "./worker-protocol.js";
+/** Typed rejection used for post-terminate operations and shutdown itself. */
+export class Cube4BrowserWorkerPoolClosedError extends Error {
+    code = "cube4-browser-pool-closed";
+    constructor(action = "operation") {
+        super(`[cube4] browser worker pool is closed (${action} rejected).`);
+        this.name = "Cube4BrowserWorkerPoolClosedError";
+    }
+}
+/**
+ * Batch seed derivation — identical to core `generateScrambles` and to
+ * `deriveBatchCube4Options` in the Node pool.
+ */
+export function deriveBrowserBatchCube4Options(options, index, count) {
+    if (count === 1 || options.seed === undefined) {
+        return options;
+    }
+    return { ...options, seed: `${options.seed}:${index}` };
+}
+function defaultBrowserSize() {
+    if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) {
+        return Math.max(1, navigator.hardwareConcurrency - 1);
+    }
+    return 4;
+}
+export class Cube4BrowserWorkerPool {
+    workers = [];
+    queue = [];
+    workerUrl;
+    maxSize;
+    pumping = false;
+    terminatePromise;
+    nextId = 0;
+    terminated = false;
+    constructor(options) {
+        if (typeof Worker === "undefined") {
+            throw new Error("[cube4] Web Workers are not available in this environment; " +
+                "use generateCube4Scramble() directly for single-threaded generation.");
+        }
+        if (options.size !== undefined) {
+            if (!Number.isInteger(options.size) || options.size < 1) {
+                throw new RangeError(`[cube4] pool size must be an integer >= 1 (got ${options.size}).`);
+            }
+        }
+        this.workerUrl =
+            typeof options.workerUrl === "string" ? options.workerUrl : options.workerUrl.href;
+        this.maxSize = options.size ?? defaultBrowserSize();
+    }
+    /** Threads spawned so far (lazily grown; 0 before the first job). */
+    get workerCount() {
+        return this.workers.length;
+    }
+    get queuedCount() {
+        return this.queue.length;
+    }
+    get busyCount() {
+        return this.workers.reduce((n, rec) => n + (rec.task !== null ? 1 : 0), 0);
+    }
+    get closed() {
+        return this.terminated;
+    }
+    generate(options = {}) {
+        if (this.terminated) {
+            return Promise.reject(new Cube4BrowserWorkerPoolClosedError("generate"));
+        }
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.queue.push({ id, options, resolve, reject });
+            this.pump();
+        });
+    }
+    generateBatch(count, options = {}) {
+        if (!Number.isInteger(count) || count < 1) {
+            return Promise.reject(new RangeError(`count must be a positive integer (got ${count}).`));
+        }
+        return Promise.all(Array.from({ length: count }, (_, index) => this.generate(deriveBrowserBatchCube4Options(options, index, count))));
+    }
+    /**
+     * Prompt shutdown: rejects queued/in-flight tasks and terminates every
+     * Web Worker synchronously (no threads to join in the browser).
+     * Idempotent.
+     */
+    terminate() {
+        if (this.terminatePromise !== undefined)
+            return;
+        this.terminated = true;
+        const closed = () => new Cube4BrowserWorkerPoolClosedError();
+        for (const task of this.queue.splice(0))
+            task.reject(closed());
+        const records = this.workers.splice(0);
+        for (const rec of records) {
+            if (rec.task !== null) {
+                rec.task.reject(closed());
+                rec.task = null;
+            }
+            rec.worker.terminate();
+        }
+        this.terminatePromise = Promise.resolve();
+    }
+    // ── internals (same shape as the Node pool) ──────────────────────────
+    pump() {
+        if (this.pumping || this.terminated)
+            return;
+        this.pumping = true;
+        void this.runPump()
+            .catch(() => undefined)
+            .finally(() => {
+            this.pumping = false;
+        });
+    }
+    async runPump() {
+        while (!this.terminated && this.queue.length > 0) {
+            const idle = this.workers.find((rec) => rec.task === null);
+            if (idle !== undefined) {
+                this.dispatch(idle, this.queue.shift());
+                continue;
+            }
+            if (this.workers.length < this.maxSize) {
+                this.spawnWorker();
+                continue;
+            }
+            break;
+        }
+    }
+    spawnWorker() {
+        const worker = new Worker(this.workerUrl, { type: "module", name: "cubingcenter-444" });
+        const rec = { worker, task: null };
+        worker.onmessage = (event) => {
+            this.handleResponse(rec, event.data);
+        };
+        worker.onerror = (event) => {
+            this.handleWorkerGone(rec, event.error instanceof Error
+                ? event.error
+                : new Error(event.message || "[cube4] browser worker failed."));
+        };
+        this.workers.push(rec);
+        return rec;
+    }
+    dispatch(rec, task) {
+        rec.task = task;
+        const message = { id: task.id, options: task.options };
+        try {
+            rec.worker.postMessage(message);
+        }
+        catch (error) {
+            rec.task = null;
+            task.reject(error);
+            this.pump();
+        }
+    }
+    handleResponse(rec, response) {
+        const task = rec.task;
+        if (task === null || task.id !== response.id)
+            return;
+        rec.task = null;
+        if (this.terminated)
+            return;
+        if (response.ok)
+            task.resolve(response.result);
+        else
+            task.reject(deserializeCube4Error(response.error));
+        const next = this.queue.shift();
+        if (next !== undefined)
+            this.dispatch(rec, next);
+        this.pump();
+    }
+    handleWorkerGone(rec, error) {
+        const index = this.workers.indexOf(rec);
+        if (index === -1)
+            return;
+        this.workers.splice(index, 1);
+        const task = rec.task;
+        rec.task = null;
+        if (task !== null && !this.terminated)
+            task.reject(error);
+        if (!this.terminated)
+            this.pump();
+    }
+}

package/dist/puzzles/cube4/browser-worker.d.ts

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

package/dist/puzzles/cube4/browser-worker.d.ts.map

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

package/dist/puzzles/cube4/browser-worker.js

@@ -0,0 +1,31 @@
+/// <reference lib="webworker" />
+/**
+ * Web Worker entry for 4x4 scramble generation (browser build).
+ *
+ * Mirror of `worker.ts`: no work at boot, tables loaded on the FIRST task
+ * and reused afterwards (the browser loader caches per worker via
+ * `scrambler.ts`'s promise-deduplicated `loadCube4Tables`), full options
+ * passed through verbatim, errors flattened through `worker-protocol.ts`.
+ *
+ * Bundlers pick this file up through the static
+ * `new Worker(new URL(..., import.meta.url))` pattern used by the pool's
+ * consumer — see `Cube4BrowserWorkerPool`'s `workerUrl` option.
+ */
+import { generateCube4Scramble } from "./scrambler.js";
+import { serializeCube4Error } from "./worker-protocol.js";
+const workerScope = self;
+workerScope.onmessage = (event) => {
+    const task = event.data;
+    void (async () => {
+        const response = await (async () => {
+            try {
+                const result = await generateCube4Scramble(task.options);
+                return { id: task.id, ok: true, result };
+            }
+            catch (error) {
+                return { id: task.id, ok: false, error: serializeCube4Error(error) };
+            }
+        })();
+        workerScope.postMessage(response);
+    })();
+};

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

@@ -1,8 +1,16 @@
 export { CORNER_COUNT, WING_COUNT, CENTER_COUNT, FACE_COUNT, CENTERS_PER_FACE, U, R, F, D, L, B, CUBE4_FACE_MOVES, CUBE4_ALL_MOVES, CUBE4_OUTER_MOVES } from "./types.js";
 export type { Cube4Face, Cube4FaceMove, Cube4Move, Cube4MoveSuffix, Cube4State, Cube4Sticker, Cube4Facelets, Cube4ValidationResult, Cube4RandomStateOptions } from "./types.js";
 export { createSolvedCube4State, cloneCube4State, cube4StatesEqual, isSolvedCube4State, areCentersReduced, areWingsPaired } from "./state.js";
-export { cube4ScrambleGenerator, generateCube4Scramble } from "./scrambler.js";
-export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
+export { Cube4FinishCapError, Cube4Phase2CapError, Cube4Phase3CapError } from "./reduction/solve.js";
+export { cube4ScrambleGenerator, generateCube4Scramble, generateCube4Attempt } from "./scrambler.js";
+export type { Cube4ScrambleOptions } from "./scrambler.js";
+export { Cube4WorkerPool, Cube4WorkerPoolClosedError, deriveBatchCube4Options, generateCube4ScrambleBatch, getDefaultCube4WorkerPool, closeDefaultCube4WorkerPool } from "./worker-pool.js";
+export type { Cube4WorkerPoolOptions } from "./worker-pool.js";
+export { Cube4BrowserWorkerPool, Cube4BrowserWorkerPoolClosedError, deriveBrowserBatchCube4Options } from "./browser-worker-pool.js";
+export type { Cube4BrowserWorkerPoolOptions } from "./browser-worker-pool.js";
+export { Cube4ScrambleCache, createCube4ScrambleCache, deriveCube4StreamOptions } from "./scramble-cache.js";
+export type { Cube4ScrambleCacheOptions, Cube4ScrambleGenerator } from "./scramble-cache.js";
+export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, simplifyCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
 export { generateRandomCube4State } from "./random-state.js";
 export { validateCube4State, isOneMoveFromSolvedCube4State, isTrivialCube4State, isAllowedRandomCube4State } from "./validation.js";
 export { toCube4Facelets, formatCube4Facelets, getCube4FaceOrder } from "./facelets.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,eAAe,EACf,UAAU,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,kBAAkB,EAClB,6BAA6B,EAC7B,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,eAAe,EACf,UAAU,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,uBAAuB,EACvB,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE/D,OAAO,EACL,sBAAsB,EACtB,iCAAiC,EACjC,8BAA8B,EAC/B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AAE9E,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,yBAAyB,EACzB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,kBAAkB,EAClB,6BAA6B,EAC7B,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/cube4/index.js

@@ -6,8 +6,12 @@ import { cube4ScrambleGenerator } from "./scrambler.js";
 registerScrambleGenerator(cube4ScrambleGenerator);
 export { CORNER_COUNT, WING_COUNT, CENTER_COUNT, FACE_COUNT, CENTERS_PER_FACE, U, R, F, D, L, B, CUBE4_FACE_MOVES, CUBE4_ALL_MOVES, CUBE4_OUTER_MOVES } from "./types.js";
 export { createSolvedCube4State, cloneCube4State, cube4StatesEqual, isSolvedCube4State, areCentersReduced, areWingsPaired } from "./state.js";
-export { cube4ScrambleGenerator, generateCube4Scramble } from "./scrambler.js";
-export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
+export { Cube4FinishCapError, Cube4Phase2CapError, Cube4Phase3CapError } from "./reduction/solve.js";
+export { cube4ScrambleGenerator, generateCube4Scramble, generateCube4Attempt } from "./scrambler.js";
+export { Cube4WorkerPool, Cube4WorkerPoolClosedError, deriveBatchCube4Options, generateCube4ScrambleBatch, getDefaultCube4WorkerPool, closeDefaultCube4WorkerPool } from "./worker-pool.js";
+export { Cube4BrowserWorkerPool, Cube4BrowserWorkerPoolClosedError, deriveBrowserBatchCube4Options } from "./browser-worker-pool.js";
+export { Cube4ScrambleCache, createCube4ScrambleCache, deriveCube4StreamOptions } from "./scramble-cache.js";
+export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, simplifyCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
 export { generateRandomCube4State } from "./random-state.js";
 export { validateCube4State, isOneMoveFromSolvedCube4State, isTrivialCube4State, isAllowedRandomCube4State } from "./validation.js";
 export { toCube4Facelets, formatCube4Facelets, getCube4FaceOrder } from "./facelets.js";

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

@@ -33,5 +33,10 @@ export declare function invertCube4Algorithm(moves: readonly Cube4Move[]): Cube4
 export declare function formatCube4Algorithm(moves: readonly Cube4Move[]): string;
 export declare function parseCube4Algorithm(algorithm: string): Cube4Move[];
 export declare function parseCube4Move(value: string): Cube4Move;
+/**
+ * Simplifies a 4x4 algorithm by canceling inverse moves and merging redundant
+ * turns on the same face or across commuting parallel faces.
+ */
+export declare function simplifyCube4Algorithm(moves: readonly Cube4Move[]): Cube4Move[];
 export { FACE_MOVE_EFFECTS };
 //# sourceMappingURL=moves.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/moves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAQxF,UAAU,UAAU;IAClB,+DAA+D;IAC/D,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,yDAAyD;IACzD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,kFAAkF;IAClF,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oDAAoD;IACpD,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AA0KD,QAAA,MAAM,iBAAiB,EAAE,MAAM,CAAC,aAAa,EAAE,UAAU,CAGxD,CAAC;AA0BF,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAc1G;AAED,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,CAM9F;AAMD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAI1D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAIlE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAMvD;AAMD,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/moves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAOxF,UAAU,UAAU;IAClB,+DAA+D;IAC/D,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,yDAAyD;IACzD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,kFAAkF;IAClF,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oDAAoD;IACpD,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AA0KD,QAAA,MAAM,iBAAiB,EAAE,MAAM,CAAC,aAAa,EAAE,UAAU,CAGxD,CAAC;AAuDF,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAc1G;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAK7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CA4C9F;AAKD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAI1D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAIlE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAMvD;AA+HD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAsC/E;AAMD,OAAO,EAAE,iBAAiB,EAAE,CAAC"}