@cubingcenter/scrambler 0.6.3 → 0.8.0

package/dist/puzzles/cube4/scramble-cache.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Background prefetch buffer for 4x4 scrambles — the Node-side analogue of
+ * TNoodle's `ScrambleCacher`.
+ *
+ * The cache keeps up to `size` scrambles generating AHEAD of consumption:
+ *  - `take()` shifts the OLDEST slot; if it is already settled it resolves
+ *    immediately (no waiting for later slots), otherwise it awaits only
+ *    that slot. Order is FIFO of START (not of completion), so a seeded
+ *    stream hands out `seed:0`, `seed:1`, … in order even when the
+ *    underlying generator finishes out of order (parallel pool).
+ *  - every shift triggers a refill, so the buffer repopulates in the
+ *    background — wire `generate: (o) => pool.generate(o)` and the refill
+ *    itself runs across worker threads (see the pool integration test).
+ *  - failures are FIRST-CLASS slots: a slot that rejects is delivered as a
+ *    rejection to the next `take()` (consumed exactly once) and the cache
+ *    keeps going with the following slots. Every slot promise is wrapped
+ *    at creation so a background failure can NEVER surface as an
+ *    unhandledRejection, and `take()` never hangs: slots always settle
+ *    (the generator contract is "settles eventually").
+ *  - `dispose()` stops refilling and drops buffered slots. In-flight
+ *    generations are left to settle silently (results discarded). There
+ *    are NO timers anywhere, so a disposed (or even forgotten) cache never
+ *    keeps a process alive.
+ *
+ * Seeding: when `options.seed` is defined, slot n is generated with
+ * `${seed}:${n}` — byte-identical to core `generateScrambles("444", …)`
+ * for any count > 1 (slot 0 ↔ item 0 of a batch). Without a seed every
+ * slot uses the base options unchanged (fresh randomness).
+ */
+import type { ScrambleResult } from "../../core/types.js";
+import type { Cube4ScrambleOptions } from "./scrambler.js";
+import type { ScrambleOptions } from "../../core/types.js";
+export type Cube4ScrambleGenerator = (options: ScrambleOptions & Cube4ScrambleOptions) => Promise<ScrambleResult>;
+export interface Cube4ScrambleCacheOptions {
+    /** Buffer capacity (number of ahead-of-consumption scrambles). Default 4. */
+    size?: number;
+    /** Base options; a defined `seed` becomes a `${seed}:${n}` stream. */
+    options?: ScrambleOptions & Cube4ScrambleOptions;
+    /**
+     * Generator used for prefetching. Defaults to the inline
+     * `generateCube4Scramble`; pass `(o) => pool.generate(o)` to refill
+     * across worker threads.
+     */
+    generate?: Cube4ScrambleGenerator;
+}
+/**
+ * Stream slot derivation (cache analogue of core's batch derivation).
+ * Exported for tests and for hosts that precompute the same sequence.
+ */
+export declare function deriveCube4StreamOptions(options: ScrambleOptions & Cube4ScrambleOptions, index: number): ScrambleOptions & Cube4ScrambleOptions;
+export declare class Cube4ScrambleCache {
+    private readonly capacity;
+    private readonly baseOptions;
+    private readonly generator;
+    /** FIFO of slots (start order); settled or still pending. */
+    private readonly slots;
+    private nextIndex;
+    private disposed;
+    constructor(options?: Cube4ScrambleCacheOptions);
+    /** Configured buffer capacity. */
+    get size(): number;
+    /** Slots currently buffered (settled + still generating). */
+    get buffered(): number;
+    /** Buffered slots that have already settled (ready for an instant take()). */
+    get ready(): number;
+    /** Slots currently generating in the background. */
+    get inFlight(): number;
+    get isDisposed(): boolean;
+    /**
+     * Resolves once the buffer holds `size` settled results (i.e. a
+     * subsequent `take()` is served instantly). Safe to call at any time;
+     * rejects only if called after `dispose()`.
+     */
+    warmup(): Promise<void>;
+    /**
+     * Next scramble in FIFO order. Instant when the front slot is settled;
+     * otherwise waits only for the front slot (never for later ones).
+     * A failed background generation surfaces here as a rejection — exactly
+     * once — and the cache continues with subsequent slots.
+     */
+    take(): Promise<ScrambleResult>;
+    /**
+     * Stops prefetching, drops buffered slots and ignores in-flight
+     * completions. No timers are involved, so nothing can keep a process
+     * alive afterwards. Idempotent.
+     */
+    dispose(): void;
+    private pump;
+    private generateNow;
+}
+/** Convenience factory mirroring the other cube4 constructors. */
+export declare function createCube4ScrambleCache(options?: Cube4ScrambleCacheOptions): Cube4ScrambleCache;
+//# sourceMappingURL=scramble-cache.d.ts.map

package/dist/puzzles/cube4/scramble-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scramble-cache.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/scramble-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,MAAM,sBAAsB,GAAG,CACnC,OAAO,EAAE,eAAe,GAAG,oBAAoB,KAC5C,OAAO,CAAC,cAAc,CAAC,CAAC;AAE7B,MAAM,WAAW,yBAAyB;IACxC,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,OAAO,CAAC,EAAE,eAAe,GAAG,oBAAoB,CAAC;IACjD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,sBAAsB,CAAC;CACnC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,eAAe,GAAG,oBAAoB,EAC/C,KAAK,EAAE,MAAM,GACZ,eAAe,GAAG,oBAAoB,CAGxC;AAWD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoD;IAC1E,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,GAAE,yBAA8B;IAYnD,kCAAkC;IAClC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,6DAA6D;IAC7D,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,8EAA8E;IAC9E,IAAI,KAAK,IAAI,MAAM,CAIlB;IAED,oDAAoD;IACpD,IAAI,QAAQ,IAAI,MAAM,CAIrB;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAQvB;;;;;OAKG;IACH,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC;IAiB/B;;;;OAIG;IACH,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,IAAI;IAeZ,OAAO,CAAC,WAAW;CAIpB;AAED,kEAAkE;AAClE,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,yBAA8B,GACtC,kBAAkB,CAEpB"}

package/dist/puzzles/cube4/scramble-cache.js

@@ -0,0 +1,150 @@
+/**
+ * Background prefetch buffer for 4x4 scrambles — the Node-side analogue of
+ * TNoodle's `ScrambleCacher`.
+ *
+ * The cache keeps up to `size` scrambles generating AHEAD of consumption:
+ *  - `take()` shifts the OLDEST slot; if it is already settled it resolves
+ *    immediately (no waiting for later slots), otherwise it awaits only
+ *    that slot. Order is FIFO of START (not of completion), so a seeded
+ *    stream hands out `seed:0`, `seed:1`, … in order even when the
+ *    underlying generator finishes out of order (parallel pool).
+ *  - every shift triggers a refill, so the buffer repopulates in the
+ *    background — wire `generate: (o) => pool.generate(o)` and the refill
+ *    itself runs across worker threads (see the pool integration test).
+ *  - failures are FIRST-CLASS slots: a slot that rejects is delivered as a
+ *    rejection to the next `take()` (consumed exactly once) and the cache
+ *    keeps going with the following slots. Every slot promise is wrapped
+ *    at creation so a background failure can NEVER surface as an
+ *    unhandledRejection, and `take()` never hangs: slots always settle
+ *    (the generator contract is "settles eventually").
+ *  - `dispose()` stops refilling and drops buffered slots. In-flight
+ *    generations are left to settle silently (results discarded). There
+ *    are NO timers anywhere, so a disposed (or even forgotten) cache never
+ *    keeps a process alive.
+ *
+ * Seeding: when `options.seed` is defined, slot n is generated with
+ * `${seed}:${n}` — byte-identical to core `generateScrambles("444", …)`
+ * for any count > 1 (slot 0 ↔ item 0 of a batch). Without a seed every
+ * slot uses the base options unchanged (fresh randomness).
+ */
+import { generateCube4Scramble } from "./scrambler.js";
+/**
+ * Stream slot derivation (cache analogue of core's batch derivation).
+ * Exported for tests and for hosts that precompute the same sequence.
+ */
+export function deriveCube4StreamOptions(options, index) {
+    if (options.seed === undefined)
+        return options;
+    return { ...options, seed: `${options.seed}:${index}` };
+}
+export class Cube4ScrambleCache {
+    capacity;
+    baseOptions;
+    generator;
+    /** FIFO of slots (start order); settled or still pending. */
+    slots = [];
+    nextIndex = 0;
+    disposed = false;
+    constructor(options = {}) {
+        const size = options.size ?? 4;
+        if (!Number.isInteger(size) || size < 1) {
+            throw new RangeError(`[cube4] cache size must be an integer >= 1 (got ${size}).`);
+        }
+        this.capacity = size;
+        this.baseOptions = options.options ?? {};
+        this.generator = options.generate ?? generateCube4Scramble;
+        // Prefetch starts immediately: that is the point of constructing a cache.
+        this.pump();
+    }
+    /** Configured buffer capacity. */
+    get size() {
+        return this.capacity;
+    }
+    /** Slots currently buffered (settled + still generating). */
+    get buffered() {
+        return this.slots.length;
+    }
+    /** Buffered slots that have already settled (ready for an instant take()). */
+    get ready() {
+        let count = 0;
+        for (const carrier of this.slots)
+            if (carrier.slot !== undefined)
+                count++;
+        return count;
+    }
+    /** Slots currently generating in the background. */
+    get inFlight() {
+        let count = 0;
+        for (const carrier of this.slots)
+            if (carrier.slot === undefined)
+                count++;
+        return count;
+    }
+    get isDisposed() {
+        return this.disposed;
+    }
+    /**
+     * Resolves once the buffer holds `size` settled results (i.e. a
+     * subsequent `take()` is served instantly). Safe to call at any time;
+     * rejects only if called after `dispose()`.
+     */
+    warmup() {
+        if (this.disposed) {
+            return Promise.reject(new Error("[cube4] scramble cache is disposed (warmup)."));
+        }
+        this.pump();
+        return Promise.all(this.slots.map((carrier) => carrier.promise)).then(() => undefined);
+    }
+    /**
+     * Next scramble in FIFO order. Instant when the front slot is settled;
+     * otherwise waits only for the front slot (never for later ones).
+     * A failed background generation surfaces here as a rejection — exactly
+     * once — and the cache continues with subsequent slots.
+     */
+    take() {
+        if (this.disposed) {
+            return Promise.reject(new Error("[cube4] scramble cache is disposed (take)."));
+        }
+        const carrier = this.slots.shift();
+        this.pump(); // refill BEFORE awaiting, so generation overlaps consumption
+        if (carrier === undefined) {
+            // Only reachable when capacity was somehow drained concurrently;
+            // generate one on the spot rather than hang.
+            return this.generateNow();
+        }
+        return carrier.promise.then((slot) => {
+            if (slot.ok)
+                return slot.result;
+            throw slot.error;
+        });
+    }
+    /**
+     * Stops prefetching, drops buffered slots and ignores in-flight
+     * completions. No timers are involved, so nothing can keep a process
+     * alive afterwards. Idempotent.
+     */
+    dispose() {
+        this.disposed = true;
+        this.slots.length = 0;
+    }
+    // ── internals ────────────────────────────────────────────────────────
+    pump() {
+        while (!this.disposed && this.slots.length < this.capacity) {
+            const index = this.nextIndex++;
+            const promise = this.generator(deriveCube4StreamOptions(this.baseOptions, index)).then((result) => ({ ok: true, result }), (error) => ({ ok: false, error }));
+            const carrier = { promise, slot: undefined };
+            void promise.then((slot) => {
+                carrier.slot = slot;
+            });
+            this.slots.push(carrier);
+        }
+    }
+    generateNow() {
+        const index = this.nextIndex++;
+        return this.generator(deriveCube4StreamOptions(this.baseOptions, index));
+    }
+}
+/** Convenience factory mirroring the other cube4 constructors. */
+export function createCube4ScrambleCache(options = {}) {
+    return new Cube4ScrambleCache(options);
+}

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

@@ -1,15 +1,210 @@
 /**
  * The 4x4 scramble generator: sample a uniform random state, solve it with
- * the reduction solver (phases 1-4), and invert the solution. The scramble
- * always reproduces the sampled target state and facelets exactly.
+ * the reduction solver (phases 1-4), and invert the solution. The emitted
+ * scramble must reproduce the sampled target state EXACTLY — enforced by
+ * `assertCube4ScrambleReproducesTarget` on every generated result (unless
+ * `skipValidation` is set, which is only for the independent verification
+ * harness in `scripts/verify-scrambles.ts`).
  *
- * If the solver fails after 5 attempts it falls back to cubing.js
- * `randomScrambleForEvent("444")` (also random-state). If that also fails,
- * a WCA-compatible random-moves sequence (40 moves) is returned.
+ * On a target mismatch the error is retryable, so the existing retry loop
+ * re-runs the solve over the SAME sampled target (deep attempt) and throws
+ * once attempts are exhausted. Re-sampling a different target to "make it
+ * fit" and degrading to random moves are forbidden: failing loudly (WCA 4g)
+ * is strictly preferable to emitting a scramble that lies about its seed.
+ *
+ * ── Determinism contract: what defines the output ──────────────────────
+ * `generateCube4Scramble` / `generateCube4Attempt` are pure functions of
+ * (seed, complete options): the emitted `moves` do not depend on wall-clock
+ * time, CPU load, warm-up, batch order, or process identity. This holds
+ * because every budget that can change the search outcome is a
+ * deterministic work counter (nodes visited), never a wall deadline:
+ *   - reduction phases: node budgets inside `reduction/solve.ts`;
+ *   - the 3x3 finish: node caps below (`finish.phase2MaxNodes`,
+ *     `finish.improveMaxNodes`, per-candidate cap), which replace the old
+ *     150/50 ms wall budgets that made the same seed yield different move
+ *     counts under CPU contention.
+ * Options are PART of the key: `restarts`/`bestOf`, `threeAxes`, `deep`,
+ * the beam knobs and `finish.*` legitimately change the result for the same
+ * seed — the output is reproducible within each configuration (documented
+ * behavior, not nondeterminism).
+ *
+ * Residual wall-clock backstop (hang guard only; never observed to bind —
+ * max measured solve 36.5 s): the 90 s
+  * `Promise.race` below. It cannot preempt the synchronous search — it
+ * can only fire at an event-loop tick — so if one ever fired, that attempt
+ * fails loudly (as a retryable error) instead of hanging. Making that bound
+  * exact deadline support would require cooperative search checkpoints.
  */
 import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
+import type { Cube4Move, Cube4State } from "./types.js";
 export declare const cube4ScrambleGenerator: ScrambleGenerator;
-export declare function generateCube4Scramble(options?: ScrambleOptions & {
+/**
+ * 444-specific scramble options (pass-through; extra keys are ignored by
+ * the generic `generateScramble` API surface).
+ */
+export interface Cube4ScrambleOptions {
+    /**
+     * Number of reduction passes to run on the SAME sampled state (alias for `restarts`).
+     * `1` (default): single deterministic pass.
+     * Higher values reshuffle the search traversal order on the same physical cube,
+     * returning the shortest valid scramble while strictly preserving uniform random-state
+     * distribution (WCA compliant).
+     */
+    bestOf?: number;
+    /**
+     * Last-resort effort for hard states: widens every solver work cap
+     * (phase-2 depth/nodes, phase-3 budgets/lengths, pool caps).
+     * Default false — the fast caps solve essentially everything at the
+     * same length (measured: identical totals on 54 states, ~-19% time),
+     * and a failed fast attempt automatically retries with `deep: true`
+     * (bestOf 1), so hard states still resolve.
+     */
+    deep?: boolean;
+    /**
+     * Search all 3 axial views (UD, RL, FB) of the same physical cube.
+     * The winning solution is mapped back by prepending the physical rotation
+     * sequence before the exact-target gate. This option costs roughly 2x time.
+     */
+    threeAxes?: boolean;
+    /**
+     * Phase-4 attempts among valid reductions (default centersBeam * edgesPerCenter, i.e. 5).
+     * Passed through to the reduction solver: the first N reductions each get a 3x3
+     * finish and the shortest simplified total wins.
+     */
+    finishTries?: number;
+    /**
+     * Number of distinct center candidates from phase 2 to explore in phase 3
+     * (default 1). Part of hierarchical beam search.
+     */
+    centersBeam?: number;
+    /**
+     * Maximum number of distinct edge pairings to collect per center candidate
+     * in phase 3 (default 5). Part of hierarchical beam search.
+     */
+    edgesPerCenter?: number;
+    /**
+     * F1 enumeration slack beyond the per-axis optimum (default 3) and
+     * collection cap (default 60). Passed through to the reduction
+     * solver. Reversible A/B knob for the diversity-vs-length trade-off
+     * of phase 1.
+     */
+    phase1ExtraDepths?: number;
+    phase1Cap?: number;
+    /**
+     * Phase-2 wide move set: search all 28 center2 moves (adds
+     * Dw2/Lw/Lw2/Lw'/Bw2) instead of the default 23. Default false
+     * (measured ~-0.2 moves for ~+15% time on typical states; opt-in).
+     * Caution: on some hard states the wider branching can blow a single
+     * attempt past 100 s (no in-search cancellation), delaying every later
+     * bestOf job — prefer `restarts` for length.
+     */
+    center2Wide?: boolean;
+    /**
+     * Deep multi-candidate polish pass in phase 3 (top-3 reductions).
+     * Defaults to the value of `threeAxes`.
+     */
+    deepPolish?: boolean;
+    /**
+     * Maximum whole-cube rotation fix (rotMoves, before placement) accepted
+     * on a phase-3 goal end (default 4 = no filter). The phase-3 goal is
+     * scheme-agnostic, so goal ends land 0/2/4 wide moves from the standard
+     * color scheme; the solver then places the fix where it cancels against
+     * the reduction's wide moves, which made filtering unprofitable.
+     */
+    maxFixMoves?: number;
+    /**
+     * Full-pipeline restarts over the SAME sampled state (default 1).
+     * Passed through to the reduction solver: each restart reshuffles the
+     * search order deterministically and the shortest total wins.
+     * Same-state diversity (uniformity-preserving), unlike `bestOf`.
+     */
+    restarts?: number;
+    /**
+     * Tuning for the 3x3 finish (cube3 two-phase solver). All fields fall
+     * back to the production defaults, which prioritize short finishes:
+     * `orientations: 3`, `phase1ExtraDepth: 1`, `phase1SolutionLimit: 24`,
+     * `targetLength: 20`, and the deterministic work caps
+     * `phase2MaxNodes: 90_000`, `improveMaxNodes: 260_000` (per-candidate
+     * phase-2 cap defaults to `phase2MaxNodes`); one retry doubles every cap.
+     * A cheaper finish (e.g. `orientations: 1`, `phase1SolutionLimit: 8`)
+     * is much faster per call at a small length cost — the finish runs
+     * several times per attempt, so this dominates attempt latency.
+     *
+     * The former wall-clock fields (`timeoutMs`, `phase2TimeoutMs`,
+     * `retryTimeoutMs`, `retryPhase2TimeoutMs`) were REMOVED: wall deadlines
+     * made the emitted scramble depend on CPU load (measured: the same seed
+     * changed move count under contention). The finish now runs under node
+     * counters only, restoring the (seed, options) purity contract.
+     */
+    finish?: {
+        /**
+         * Finish implementation (default `continuous`): the deterministic
+         * continuous two-phase search in `reduction/finish3.ts` (3 axes ×
+         * inverse views). `legacy` is the older batch two-phase solver, also used
+         * as the fallback if the continuous search exhausts its node cap.
+         */
+        mode?: "legacy" | "continuous";
+        /** Views for continuous mode: 1, 2 (+inverse) or 6 (3 axes × inverse, default). */
+        continuousViews?: 1 | 2 | 6;
+        /** Continuous phase-1+phase-2 node budget (default 200,000). */
+        continuousMaxNodes?: number;
+        /** Continuous screening budget per candidate reduction (default 30,000). */
+        continuousScreenNodes?: number;
+        /** Candidates re-finished at full budget after screening (default 0 = no screening). */
+        screenTop?: number;
+        /** Absolute continuous node cap (default 20,000,000). */
+        continuousHardMaxNodes?: number;
+        /** Maximum phase-2 segment in continuous mode (default 12). */
+        continuousMaxPhase2Length?: number;
+        orientations?: number;
+        phase1ExtraDepth?: number;
+        phase1SolutionLimit?: number;
+        targetLength?: number;
+        /** Phase-2 search node cap per finish call (default 90_000). */
+        phase2MaxNodes?: number;
+        /** Improvement-loop node budget per finish call (default 260_000). */
+        improveMaxNodes?: number;
+        /** Per-candidate phase-2 node cap in the improvement loop (default: `phase2MaxNodes`). */
+        improvePhase2MaxNodes?: number;
+    };
+}
+/**
+ * Thrown by the target gate when the emitted scramble does not reproduce
+ * the independently sampled state. Retryable: the retry loop re-solves the
+ * SAME sampled target (deep attempt) — never re-samples.
+ */
+export declare class Cube4TargetMismatchError extends Error {
+    readonly code: "cube4-target-mismatch";
+    constructor(message: string);
+}
+/** Thrown by the 90 s hang guard (wall-clock, fires only at a tick). */
+export declare class Cube4WallTimeoutError extends Error {
+    readonly code: "cube4-wall-timeout";
+    constructor(message: string);
+}
+/**
+ * The real random-state contract for 444 (non-tautological): replaying the
+ * emitted scramble on the solved cube must reproduce the exact state that
+ * was sampled for the seed — the reference the sampler produced, never a
+ * state derived from the scramble itself. Throws when it does not.
+ *
+ * Used by the production validation path in `solveCube4Attempt` and
+ * exported so tests can prove the gate rejects corrupted scrambles.
+ */
+export declare function assertCube4ScrambleReproducesTarget(scrambleMoves: readonly Cube4Move[], targetState: Cube4State, seed?: string | number): void;
+export declare function generateCube4Scramble(options?: ScrambleOptions & Cube4ScrambleOptions & {
+    skipValidation?: boolean;
+}): Promise<ScrambleResult>;
+/**
+ * Single-attempt 444 solve: samples ONE state (from `options.seed`) and
+ * solves it with the reduction solver. Throws on failure — including a
+ * target mismatch ("scramble does not reproduce the sampled target state")
+ * — no resampling; hosts may retry with the same seed, which re-uses the
+ * same target.
+ * Fan-out primitive for hosts: run with seeds `seed`, `seed:bestN`, ...
+ * across workers and keep the shortest valid result.
+ */
+export declare function generateCube4Attempt(tables: any, pairTables: any, options?: ScrambleOptions & Cube4ScrambleOptions & {
     skipValidation?: boolean;
 }): Promise<ScrambleResult>;
 //# sourceMappingURL=scrambler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/scrambler.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAmJ9F,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,CAiGzB"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/scrambler.ts"],"names":[],"mappings":"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"}