@cubingcenter/scrambler 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/clock/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAUF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAoCzB"}

package/dist/puzzles/clock/scrambler.js

@@ -0,0 +1,50 @@
+export const clockScrambleGenerator = {
+    info: {
+        eventId: "clkwca",
+        name: "Clock",
+        puzzle: "clock",
+        quality: "random-state",
+        generator: "clock-random-moves",
+        description: "Generates standard WCA Clock scrambles."
+    },
+    generate(options = {}) {
+        return generateClockScramble(options);
+    }
+};
+function getRandomTurns() {
+    const value = Math.floor(Math.random() * 12) - 5; // -5 to +6
+    if (value >= 0) {
+        return `${value}+`;
+    }
+    return `${Math.abs(value)}-`;
+}
+export async function generateClockScramble(options = {}) {
+    const moves = [];
+    // Front face moves
+    const frontPins = ["UR", "DR", "DL", "UL", "U", "R", "D", "L", "ALL"];
+    for (const pin of frontPins) {
+        moves.push(`${pin}${getRandomTurns()}`);
+    }
+    // Flip
+    moves.push("y2");
+    // Back face moves
+    const backPins = ["U", "R", "D", "L", "ALL"];
+    for (const pin of backPins) {
+        moves.push(`${pin}${getRandomTurns()}`);
+    }
+    // Final pins state
+    const pins = ["UR", "DR", "DL", "UL"];
+    const finalPins = pins.filter(() => Math.random() < 0.5);
+    const finalPinsStr = finalPins.join(" ");
+    const scramble = [...moves, finalPinsStr].filter(Boolean).join(" ");
+    return {
+        eventId: "clkwca",
+        scramble,
+        moves, // For moves we return the steps without final pins as parsed moves, or just string array
+        quality: "random-state",
+        generator: "clock-random-moves",
+        metadata: {
+            finalPins
+        }
+    };
+}

package/dist/puzzles/cube2/facelets.d.ts

@@ -0,0 +1,5 @@
+import type { Cube2Face, Cube2Facelets, Cube2State } from "./types.js";
+export declare function toCube2Facelets(state: Cube2State): Cube2Facelets;
+export declare function formatCube2Facelets(facelets: Cube2Facelets): string;
+export declare function getCube2FaceOrder(): readonly Cube2Face[];
+//# sourceMappingURL=facelets.d.ts.map

package/dist/puzzles/cube2/facelets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AA4BrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAehE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,SAAS,EAAE,CAExD"}

package/dist/puzzles/cube2/facelets.js

@@ -0,0 +1,53 @@
+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", 3], ["R", 0], ["F", 1]],
+    [["U", 2], ["F", 0], ["L", 1]],
+    [["U", 0], ["L", 0], ["B", 1]],
+    [["U", 1], ["B", 0], ["R", 1]],
+    [["D", 1], ["F", 3], ["R", 2]],
+    [["D", 0], ["L", 3], ["F", 2]],
+    [["D", 2], ["B", 3], ["L", 2]],
+    [["D", 3], ["R", 3], ["B", 2]]
+];
+export function toCube2Facelets(state) {
+    const facelets = createEmptyFacelets();
+    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);
+    }
+    return facelets;
+}
+export function formatCube2Facelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+export function getCube2FaceOrder() {
+    return FACE_ORDER;
+}
+function createEmptyFacelets() {
+    return {
+        U: Array(4).fill("U"),
+        R: Array(4).fill("R"),
+        F: Array(4).fill("F"),
+        D: Array(4).fill("D"),
+        L: Array(4).fill("L"),
+        B: Array(4).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/cube2/index.d.ts

@@ -0,0 +1,10 @@
+export { CUBE2_MOVES, CORNER_COUNT } from "./types.js";
+export type { Cube2Face, Cube2Facelets, Cube2Move, Cube2FaceMove, Cube2MoveSuffix, Cube2RandomStateOptions, Cube2State, Cube2ValidationResult } from "./types.js";
+export { applyCube2Algorithm, applyCube2Move, formatCube2Algorithm, invertCube2Algorithm, invertCube2Move, parseCube2Algorithm, parseCube2Move } from "./moves.js";
+export { cloneCube2State, createSolvedCube2State, cube2StatesEqual, isSolvedCube2State } from "./state.js";
+export { isAllowedRandomCube2State, isOneMoveFromSolvedCube2State, permutationParity, validateCube2State } from "./validation.js";
+export { generateRandomCube2State } from "./random-state.js";
+export { cube2ScrambleGenerator, generateCube2Scramble } from "./scrambler.js";
+export { formatCube2Facelets, getCube2FaceOrder, toCube2Facelets } from "./facelets.js";
+export * as solver from "./solver/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,YAAY,EACb,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,aAAa,EACb,eAAe,EACf,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACtB,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"}

package/dist/puzzles/cube2/index.js

@@ -0,0 +1,8 @@
+export { CUBE2_MOVES, CORNER_COUNT } from "./types.js";
+export { applyCube2Algorithm, applyCube2Move, formatCube2Algorithm, invertCube2Algorithm, invertCube2Move, parseCube2Algorithm, parseCube2Move } from "./moves.js";
+export { cloneCube2State, createSolvedCube2State, cube2StatesEqual, isSolvedCube2State } from "./state.js";
+export { isAllowedRandomCube2State, isOneMoveFromSolvedCube2State, permutationParity, validateCube2State } from "./validation.js";
+export { generateRandomCube2State } from "./random-state.js";
+export { cube2ScrambleGenerator, generateCube2Scramble } from "./scrambler.js";
+export { formatCube2Facelets, getCube2FaceOrder, toCube2Facelets } from "./facelets.js";
+export * as solver from "./solver/index.js";

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

@@ -0,0 +1,9 @@
+import type { Cube2Move, Cube2State } from "./types.js";
+export declare function applyCube2Move(state: Cube2State, move: Cube2Move): Cube2State;
+export declare function applyCube2Algorithm(state: Cube2State, moves: readonly Cube2Move[]): Cube2State;
+export declare function invertCube2Algorithm(moves: readonly Cube2Move[]): Cube2Move[];
+export declare function parseCube2Algorithm(algorithm: string): Cube2Move[];
+export declare function formatCube2Algorithm(moves: readonly Cube2Move[]): string;
+export declare function parseCube2Move(value: string): Cube2Move;
+export declare function invertCube2Move(move: Cube2Move): Cube2Move;
+//# sourceMappingURL=moves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/moves.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiB,SAAS,EAAmB,UAAU,EAAE,MAAM,YAAY,CAAC;AAmCxF,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,CAOlE;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/cube2/moves.js

@@ -0,0 +1,79 @@
+import { CUBE2_MOVES } from "./types.js";
+import { cloneCube2State } from "./state.js";
+const FACE_MOVE_TABLES = {
+    U: {
+        permutation: [3, 0, 1, 2, 4, 5, 6, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    D: {
+        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    R: {
+        permutation: [4, 1, 2, 0, 7, 5, 6, 3],
+        orientation: [2, 0, 0, 1, 1, 0, 0, 2]
+    },
+    L: {
+        permutation: [0, 2, 6, 3, 4, 1, 5, 7],
+        orientation: [0, 1, 2, 0, 0, 2, 1, 0]
+    },
+    F: {
+        permutation: [1, 5, 2, 3, 0, 4, 6, 7],
+        orientation: [1, 2, 0, 0, 2, 1, 0, 0]
+    },
+    B: {
+        permutation: [0, 1, 3, 7, 4, 5, 2, 6],
+        orientation: [0, 0, 1, 2, 0, 0, 2, 1]
+    }
+};
+export function applyCube2Move(state, move) {
+    const { face, turns } = parseMoveParts(move);
+    let next = cloneCube2State(state);
+    for (let index = 0; index < turns; index += 1) {
+        next = applyFaceMove(next, FACE_MOVE_TABLES[face]);
+    }
+    return next;
+}
+export function applyCube2Algorithm(state, moves) {
+    return moves.reduce((current, move) => applyCube2Move(current, move), state);
+}
+export function invertCube2Algorithm(moves) {
+    return [...moves].reverse().map(invertCube2Move);
+}
+export function parseCube2Algorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed.split(/\s+/).map(parseCube2Move);
+}
+export function formatCube2Algorithm(moves) {
+    return moves.join(" ");
+}
+export function parseCube2Move(value) {
+    if (CUBE2_MOVES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid 2x2 move: ${value}`);
+}
+export function invertCube2Move(move) {
+    const { face, suffix } = parseMoveParts(move);
+    if (suffix === "2") {
+        return move;
+    }
+    return `${face}${suffix === "'" ? "" : "'"}`;
+}
+function applyFaceMove(state, table) {
+    return {
+        corners: {
+            permutation: table.permutation.map((source) => state.corners.permutation[source]),
+            orientation: table.permutation.map((source, target) => ((state.corners.orientation[source] + table.orientation[target]) % 3))
+        }
+    };
+}
+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/cube2/random-state.d.ts

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

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

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

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

@@ -0,0 +1,51 @@
+import { createRandomSource } from "../../random/index.js";
+import { CORNER_COUNT } from "./types.js";
+import { isAllowedRandomCube2State } from "./validation.js";
+export function generateRandomCube2State(options = {}) {
+    const random = createRandomSource(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || isAllowedRandomCube2State(state)) {
+            return state;
+        }
+    }
+    throw new Error("Unable to generate a non-trivial random 2x2 state.");
+}
+function createLegalRandomState(random) {
+    const perm7 = shuffledRange(CORNER_COUNT - 1, random);
+    const mappedPerm = perm7.map((val) => (val >= 6 ? val + 1 : val));
+    mappedPerm.splice(6, 0, 6);
+    const orient7 = randomOrientations(CORNER_COUNT - 1, 3, random);
+    orient7.splice(6, 0, 0);
+    return {
+        corners: {
+            permutation: mappedPerm,
+            orientation: orient7
+        }
+    };
+}
+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/cube2/scrambler.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/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,CA0CzB"}

package/dist/puzzles/cube2/scrambler.js

@@ -0,0 +1,54 @@
+import { applyCube2Algorithm, formatCube2Algorithm, invertCube2Algorithm } from "./moves.js";
+import { generateRandomCube2State } from "./random-state.js";
+import { createSolvedCube2State, cube2StatesEqual, isSolvedCube2State } from "./state.js";
+import { formatCube2Facelets, toCube2Facelets } from "./facelets.js";
+import { solveCube2State } from "./solver/index.js";
+export const cube2ScrambleGenerator = {
+    info: {
+        eventId: "222",
+        name: "2x2x2 Cube",
+        puzzle: "cube-2x2",
+        quality: "random-state",
+        generator: "cube2-ida-star",
+        description: "Random-state 2x2 scramble generated by an optimal IDA* corner solver."
+    },
+    generate(options = {}) {
+        return generateCube2Scramble(options);
+    }
+};
+export async function generateCube2Scramble(options = {}) {
+    const state = generateRandomCube2State(options);
+    const solution = await solveCube2State(state);
+    const scrambleMoves = invertCube2Algorithm(solution.moves);
+    if (!options.skipValidation) {
+        const scrambledState = applyCube2Algorithm(createSolvedCube2State(), scrambleMoves);
+        if (!cube2StatesEqual(scrambledState, state)) {
+            throw new Error("Generated 2x2 scramble does not reproduce the target random state.");
+        }
+        if (!isSolvedCube2State(solution.state)) {
+            throw new Error("Generated 2x2 solution does not solve the target random state.");
+        }
+        if (scrambleMoves.length < 2) {
+            throw new Error("Generated 2x2 scramble is too short.");
+        }
+    }
+    const facelets = toCube2Facelets(state);
+    const result = {
+        eventId: "222",
+        scramble: formatCube2Algorithm(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "cube2-ida-star",
+        metadata: {
+            state,
+            facelets,
+            faceletString: formatCube2Facelets(facelets),
+            solutionMoves: solution.moves,
+            solutionDepth: solution.depth
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}

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

@@ -0,0 +1,12 @@
+export declare function getCachedBrowserTables(): {
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    distances: Uint8Array;
+} | undefined;
+export declare function clearCachedBrowserTables(): void;
+export declare function loadBrowserTables(baseUrl?: string): Promise<{
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    distances: Uint8Array;
+}>;
+//# sourceMappingURL=browser-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/browser-loader.ts"],"names":[],"mappings":"AAQA,wBAAgB,sBAAsB;sBALlB,WAAW;sBACX,WAAW;eAClB,UAAU;cAKtB;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAAC,CAqBD"}

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

@@ -0,0 +1,80 @@
+import { CUBE2_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+let cachedBrowserTables;
+export function getCachedBrowserTables() {
+    return cachedBrowserTables;
+}
+export function clearCachedBrowserTables() {
+    cachedBrowserTables = undefined;
+}
+export async function loadBrowserTables(baseUrl) {
+    if (cachedBrowserTables) {
+        return cachedBrowserTables;
+    }
+    const resolved = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolved);
+    const [permTable, orientTable, dist] = await Promise.all([
+        fetchUint16Table(resolved, manifest.files.permutationTable, CUBE2_SOLVER_TABLE_METADATA.permutationTable.entries),
+        fetchUint16Table(resolved, manifest.files.orientationTable, CUBE2_SOLVER_TABLE_METADATA.orientationTable.entries),
+        fetchUint8Table(resolved, manifest.files.distances, CUBE2_SOLVER_TABLE_METADATA.distances.entries)
+    ]);
+    cachedBrowserTables = {
+        permutationTable: permTable,
+        orientationTable: orientTable,
+        distances: dist
+    };
+    return cachedBrowserTables;
+}
+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 ".";
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/puzzles/cube2/solver/generated/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load cube2 solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const manifest = await response.json();
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported cube2 solver table manifest version: ${manifest.version}`);
+    }
+    return manifest;
+}
+async function fetchUint16Table(baseUrl, entry, expectedEntries) {
+    const url = `${baseUrl}/puzzles/cube2/solver/generated/${entry.file}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load ${entry.file}: ${response.status} ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength !== expectedEntries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(expectedEntries);
+    const view = new DataView(buffer);
+    for (let i = 0; i < values.length; i++) {
+        values[i] = view.getUint16(i * 2, true);
+    }
+    return values;
+}
+async function fetchUint8Table(baseUrl, entry, expectedEntries) {
+    const url = `${baseUrl}/puzzles/cube2/solver/generated/${entry.file}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load ${entry.file}: ${response.status} ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength !== expectedEntries) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    return new Uint8Array(buffer);
+}