@cubingcenter/scrambler 0.3.0 → 0.4.1

package/dist/puzzles/megaminx/scrambler.js

@@ -2,7 +2,7 @@ import { createRandomSource } from "../../random/index.js";
 import { MEGAMINX_R_MOVES, MEGAMINX_D_MOVES, SCRAMBLE_LINES, MOVES_PER_LINE } from "./types.js";
 export const megaminxScrambleGenerator = {
     info: {
-        eventId: "mega",
+        eventId: "mgmx",
         name: "Megaminx",
         puzzle: "megaminx",
         quality: "random-move",
@@ -29,7 +29,7 @@ export function generateMegaminxScramble(options = {}) {
     }
     const scramble = formatMegaminxScramble(moves);
     const result = {
-        eventId: "mega",
+        eventId: "mgmx",
         scramble,
         moves,
         quality: "random-move",

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

@@ -7,5 +7,7 @@ export { generateRandomPyraminxState } from "./random-state.js";
 export { pyraminxScrambleGenerator, generatePyraminxScramble } from "./scrambler.js";
 export { createSolvedPyraminxFacelets, formatPyraminxFacelets, getPyraminxFaceOrder, toPyraminxFacelets } from "./facelets.js";
 export type { PyraminxFacelets } from "./facelets.js";
-export { solvePyraminx } from "./solver.js";
+export { solvePyraminx, solvePyraminxWithInfo } from "./solver/index.js";
+export * as solver from "./solver/index.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,2BAA2B,EAC5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,4BAA4B,EAC5B,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACd,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,mBAAmB,EACnB,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,2BAA2B,EAC5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,4BAA4B,EAC5B,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/pyraminx/index.js

@@ -1,3 +1,6 @@
+import { registerScrambleGenerator } from "../../core/index.js";
+import { pyraminxScrambleGenerator } from "./scrambler.js";
+registerScrambleGenerator(pyraminxScrambleGenerator);
 export { PYRAMINX_CORE_MOVES, PYRAMINX_TIPS } from "./types.js";
 export { applyPyraminxAlgorithm, applyPyraminxMove, formatPyraminxAlgorithm, invertPyraminxAlgorithm, invertPyraminxMove, parsePyraminxAlgorithm, parsePyraminxMove } from "./moves.js";
 export { clonePyraminxState, createSolvedPyraminxState, pyraminxStatesEqual, isSolvedPyraminxState } from "./state.js";
@@ -5,4 +8,6 @@ export { permutationParity, validatePyraminxState, isAllowedRandomPyraminxState
 export { generateRandomPyraminxState } from "./random-state.js";
 export { pyraminxScrambleGenerator, generatePyraminxScramble } from "./scrambler.js";
 export { createSolvedPyraminxFacelets, formatPyraminxFacelets, getPyraminxFaceOrder, toPyraminxFacelets } from "./facelets.js";
-export { solvePyraminx } from "./solver.js";
+export { solvePyraminx, solvePyraminxWithInfo } from "./solver/index.js";
+export * as solver from "./solver/index.js";
+export { generateScramble, generateScrambles, getEventInfo, getSupportedEvents, initializeScrambler } from "../../core/index.js";

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

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

package/dist/puzzles/pyraminx/scrambler.js

@@ -1,16 +1,18 @@
 import { generateRandomPyraminxState } from "./random-state.js";
-import { createSolvedPyraminxState } from "./state.js";
-import { applyPyraminxAlgorithm, invertPyraminxAlgorithm } from "./moves.js";
-import { solvePyraminx } from "./solver.js";
+import { invertPyraminxAlgorithm } from "./moves.js";
+import { solvePyraminx, verifyPyraminxScramble } from "./solver/index.js";
 import { formatPyraminxFacelets, toPyraminxFacelets } from "./facelets.js";
+import { PYRAMINX_TIPS } from "./types.js";
+// Face -> tip index (U,L,R,B order, same as PYRAMINX_TIPS).
+const FACE_TIP_INDEX = { U: 0, L: 1, R: 2, B: 3 };
 export const pyraminxScrambleGenerator = {
     info: {
-        eventId: "pyra",
+        eventId: "pymx",
         name: "Pyraminx",
         puzzle: "pyraminx",
         quality: "random-state",
-        generator: "pyraminx-ida-star",
-        description: "Random-state Pyraminx scramble generated by an optimal bidirectional BFS solver."
+        generator: "pyraminx-optimal",
+        description: "Random-state Pyraminx scramble generated by an optimal solver with precalculated tables."
     },
     generate(options = {}) {
         return generatePyraminxScramble(options);
@@ -19,38 +21,40 @@ export const pyraminxScrambleGenerator = {
 export async function generatePyraminxScramble(options = {}) {
     const state = generateRandomPyraminxState(options);
     // Solve the core edges and centers
-    const solution = solvePyraminx(state);
+    const solution = await solvePyraminx(state);
     const scrambleMoves = invertPyraminxAlgorithm(solution);
     // Append tips: layer moves already rotate tips, so we need the delta
     // between the target tips and the tips produced by the core scramble.
-    const coreState = applyPyraminxAlgorithm(createSolvedPyraminxState(), scrambleMoves);
+    // Computed arithmetically from the move sequence (no state replay).
+    const coreTips = [0, 0, 0, 0];
+    for (const move of scrambleMoves) {
+        const isInverse = move.endsWith("'");
+        const face = isInverse ? move.slice(0, -1) : move;
+        const tipIndex = FACE_TIP_INDEX[face];
+        if (tipIndex !== undefined) {
+            coreTips[tipIndex] = (coreTips[tipIndex] + (isInverse ? 2 : 1)) % 3;
+        }
+    }
     const finalMoves = [...scrambleMoves];
-    const tipsNotation = ["u", "l", "r", "b"];
     for (let i = 0; i < 4; i++) {
-        const delta = (state.tips[i] - coreState.tips[i] + 3) % 3;
+        const delta = (state.tips[i] - coreTips[i] + 3) % 3;
         if (delta === 1) {
-            finalMoves.push(tipsNotation[i]);
+            finalMoves.push(PYRAMINX_TIPS[i]);
         }
         else if (delta === 2) {
-            finalMoves.push(`${tipsNotation[i]}'`);
+            finalMoves.push(`${PYRAMINX_TIPS[i]}'`);
         }
     }
-    if (!options.skipValidation) {
-        const scrambledState = applyPyraminxAlgorithm(createSolvedPyraminxState(), finalMoves);
-        if (scrambledState.edgesPerm.toString() !== state.edgesPerm.toString() ||
-            scrambledState.edgesOrient.toString() !== state.edgesOrient.toString() ||
-            scrambledState.centers.toString() !== state.centers.toString() ||
-            scrambledState.tips.toString() !== state.tips.toString()) {
-            throw new Error("Generated Pyraminx scramble does not reproduce the target random state.");
-        }
+    if (!options.skipValidation && !verifyPyraminxScramble(state, finalMoves)) {
+        throw new Error("Generated Pyraminx scramble does not reproduce the target random state.");
     }
     const facelets = toPyraminxFacelets(state);
     return {
-        eventId: "pyra",
+        eventId: "pymx",
         scramble: finalMoves.join(" "),
         moves: finalMoves,
         quality: "random-state",
-        generator: "pyraminx-ida-star",
+        generator: "pyraminx-optimal",
         metadata: {
             state,
             facelets,

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/browser-loader.ts"],"names":[],"mappings":"AAUA,wBAAgB,sBAAsB;kBANtB,UAAU;sBACN,WAAW;sBACX,UAAU;iBACf,UAAU;cAKxB;AACD,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,YAAY,EAAE,UAAU,CAAC;IACzB,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,UAAU,CAAC;IAC7B,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAYD"}

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

@@ -0,0 +1,63 @@
+import { PYRAMINX_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+import { fetchTableBuffer as fetchCompressedTableBuffer } from "../../shared/compressed-fetch.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 [centersTable, permutationTable, orientationTable, policyTable] = await Promise.all([
+        fetchUint8Table(resolved, manifest.files.centersTable, PYRAMINX_SOLVER_TABLE_METADATA.centersTable.entries),
+        fetchUint16Table(resolved, manifest.files.permutationTable, PYRAMINX_SOLVER_TABLE_METADATA.permutationTable.entries),
+        fetchUint8Table(resolved, manifest.files.orientationTable, PYRAMINX_SOLVER_TABLE_METADATA.orientationTable.entries),
+        fetchUint8Table(resolved, manifest.files.policyTable, PYRAMINX_SOLVER_TABLE_METADATA.policyTable.entries)
+    ]);
+    cachedBrowserTables = { centersTable, permutationTable, orientationTable, policyTable };
+    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/pyraminx/solver/generated/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to load pyraminx solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    const manifest = (await response.json());
+    if (manifest.version !== 1)
+        throw new Error(`Unsupported pyraminx solver table manifest version: ${manifest.version}`);
+    return manifest;
+}
+const TABLES_DIR = "puzzles/pyraminx/solver/generated";
+const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
+async function fetchUint8Table(baseUrl, entry, expectedEntries) {
+    const buffer = await fetchCompressedTableBuffer(baseUrl, TABLES_DIR, entry.file, { cacheName: CACHE_NAME, compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries)
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    return new Uint8Array(buffer);
+}
+async function fetchUint16Table(baseUrl, entry, expectedEntries) {
+    const buffer = await fetchCompressedTableBuffer(baseUrl, TABLES_DIR, entry.file, { cacheName: CACHE_NAME, compressed: entry.compressed !== false });
+    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;
+}

package/dist/puzzles/pyraminx/solver/generated/manifest.json

@@ -0,0 +1,26 @@
+{
+  "version": 1,
+  "files": {
+    "centersTable": {
+      "file": "centers-table.bin",
+      "entries": 648,
+      "checksum": 4058180805
+    },
+    "permutationTable": {
+      "file": "permutation-table.bin",
+      "entries": 2880,
+      "checksum": 4161414597
+    },
+    "orientationTable": {
+      "file": "orientation-table.bin",
+      "entries": 256,
+      "checksum": 3608176069
+    },
+    "policyTable": {
+      "file": "policy.bin",
+      "entries": 349920,
+      "checksum": 4047562730,
+      "maxDepth": 11
+    }
+  }
+}

package/dist/puzzles/pyraminx/solver/generated-assets.d.ts

@@ -0,0 +1,7 @@
+export declare function loadGeneratedPyraminxSolverTables(): Promise<{
+    centersTable: Uint8Array;
+    permutationTable: Uint16Array;
+    orientationTable: Uint8Array;
+    policyTable: Uint8Array;
+}>;
+//# sourceMappingURL=generated-assets.d.ts.map

package/dist/puzzles/pyraminx/solver/generated-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/generated-assets.ts"],"names":[],"mappings":"AAaA,wBAAsB,iCAAiC,IAAI,OAAO,CAAC;IACjE,YAAY,EAAE,UAAU,CAAC;IACzB,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,UAAU,CAAC;IAC7B,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAYD"}

package/dist/puzzles/pyraminx/solver/generated-assets.js

@@ -0,0 +1,24 @@
+import { getCachedBrowserTables } from "./browser-loader.js";
+let cachedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+export async function loadGeneratedPyraminxSolverTables() {
+    if (isBrowser()) {
+        const browserTables = getCachedBrowserTables();
+        if (browserTables)
+            return browserTables;
+        throw new Error("Pyraminx solver tables are not loaded. " +
+            "In browser environments, call `initializeScrambler(baseUrl)` " +
+            "before generating scrambles.");
+    }
+    cachedTables ??= await loadNodeTables();
+    return cachedTables;
+}
+async function loadNodeTables() {
+    const loader = await import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./node-loader.js");
+    return loader.readGeneratedPyraminxSolverTables();
+}

package/dist/puzzles/pyraminx/solver/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./tables.js";
+export * from "./search.js";
+export { PYRAMINX_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+export { loadGeneratedPyraminxSolverTables } from "./generated-assets.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/puzzles/pyraminx/solver/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,iCAAiC,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/puzzles/pyraminx/solver/index.js

@@ -0,0 +1,4 @@
+export * from "./tables.js";
+export * from "./search.js";
+export { PYRAMINX_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+export { loadGeneratedPyraminxSolverTables } from "./generated-assets.js";

package/dist/puzzles/pyraminx/solver/node-loader.d.ts

@@ -0,0 +1,7 @@
+export declare function readGeneratedPyraminxSolverTables(): {
+    centersTable: Uint8Array;
+    permutationTable: Uint16Array;
+    orientationTable: Uint8Array;
+    policyTable: Uint8Array;
+};
+//# sourceMappingURL=node-loader.d.ts.map

package/dist/puzzles/pyraminx/solver/node-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/node-loader.ts"],"names":[],"mappings":"AAiBA,wBAAgB,iCAAiC,IAAI;IACnD,YAAY,EAAE,UAAU,CAAC;IACzB,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,UAAU,CAAC;IAC7B,WAAW,EAAE,UAAU,CAAC;CACzB,CAaA"}

package/dist/puzzles/pyraminx/solver/node-loader.js

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { PYRAMINX_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+const GENERATED_DIRECTORY = "puzzles/pyraminx/solver/generated";
+export function readGeneratedPyraminxSolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = JSON.parse(readFileSync(path.join(assetDirectory, "manifest.json"), "utf8"));
+    if (manifest.version !== 1)
+        throw new Error(`Unsupported pyraminx solver table manifest version: ${manifest.version}`);
+    const centersTable = readUint8Table(assetDirectory, manifest.files.centersTable, PYRAMINX_SOLVER_TABLE_METADATA.centersTable.checksum);
+    const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, PYRAMINX_SOLVER_TABLE_METADATA.permutationTable.checksum);
+    const orientationTable = readUint8Table(assetDirectory, manifest.files.orientationTable, PYRAMINX_SOLVER_TABLE_METADATA.orientationTable.checksum);
+    const policyTable = readUint8Table(assetDirectory, manifest.files.policyTable, PYRAMINX_SOLVER_TABLE_METADATA.policyTable.checksum);
+    return { centersTable, permutationTable, orientationTable, policyTable };
+}
+function readUint8Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = readFileSync(path.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries)
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    const values = new Uint8Array(buffer);
+    assertChecksum(entry.file, checksum(values), expectedChecksum);
+    return values;
+}
+function readUint16Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = readFileSync(path.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries * 2)
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    const values = new Uint16Array(entry.entries);
+    for (let i = 0; i < values.length; i++)
+        values[i] = buffer.readUInt16LE(i * 2);
+    assertChecksum(entry.file, checksum(values), expectedChecksum);
+    return values;
+}
+function resolveGeneratedAssetDirectory() {
+    const envDirectory = process.env.CUBINGCENTER_SCRAMBLER_TABLES_DIR;
+    if (envDirectory && existsSync(path.join(envDirectory, "manifest.json")))
+        return envDirectory;
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if (existsSync(path.join(candidate, "manifest.json")))
+            return candidate;
+    }
+    throw new Error("Unable to find generated pyraminx solver tables. Run pnpm pyraminx:tables.");
+}
+function getAssetDirectoryCandidates() {
+    const cwd = process.cwd();
+    const candidates = [
+        path.join(cwd, "src", GENERATED_DIRECTORY),
+        path.join(cwd, "dist", GENERATED_DIRECTORY),
+        path.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = createRequire(path.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(path.join(path.dirname(packageEntry), GENERATED_DIRECTORY));
+    }
+    catch {
+        // source-tree
+    }
+    return candidates;
+}
+function assertChecksum(file, actual, expected) {
+    if (actual !== expected)
+        throw new Error(`Checksum mismatch for ${file}: expected ${expected}, received ${actual}.`);
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < values.length; i++) {
+        hash ^= values[i];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

package/dist/puzzles/pyraminx/solver/search.d.ts

@@ -0,0 +1,10 @@
+import type { PyraminxMove, PyraminxState } from "../types.js";
+export interface PyraminxSolution {
+    moves: PyraminxMove[];
+    depth: number;
+}
+export declare function solvePyraminx(state: PyraminxState): Promise<PyraminxMove[]>;
+export declare function solvePyraminxWithInfo(state: PyraminxState): Promise<PyraminxSolution>;
+export declare function solvePyraminxSync(state: PyraminxState): PyraminxMove[];
+export declare function verifyPyraminxScramble(state: PyraminxState, finalMoves: readonly PyraminxMove[]): boolean;
+//# sourceMappingURL=search.d.ts.map

package/dist/puzzles/pyraminx/solver/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAgB/D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAGjF;AAED,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAG3F;AA8BD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,EAAE,CAGtE;AAaD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAsCzG"}

package/dist/puzzles/pyraminx/solver/search.js

@@ -0,0 +1,82 @@
+import { POLICY_TABLE, CENTERS_TABLE, PERMUTATION_TABLE, ORIENTATION_TABLE, PYRAMINX_MOVES, MOVE_COUNT, PERMUTATION_COUNT, getCentersIndex, getOrientationIndex, getPermutationCompactIndex, getPolicyMoveFromPacked, ensureTablesLoaded } from "./tables.js";
+export async function solvePyraminx(state) {
+    await ensureTablesLoaded();
+    return solveWithTables(state).moves;
+}
+export async function solvePyraminxWithInfo(state) {
+    await ensureTablesLoaded();
+    return solveWithTables(state);
+}
+function solveWithTables(state) {
+    const centersTable = CENTERS_TABLE;
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    const policy = POLICY_TABLE;
+    let c = getCentersIndex(state.centers);
+    let p = getPermutationCompactIndex(state.edgesPerm);
+    let o = getOrientationIndex(state.edgesOrient);
+    let stateIndex = c + 81 * (p + PERMUTATION_COUNT * o);
+    if (stateIndex === 0)
+        return { moves: [], depth: 0 };
+    const moves = [];
+    while (stateIndex !== 0) {
+        const m = getPolicyMoveFromPacked(policy, stateIndex);
+        moves.push(PYRAMINX_MOVES[m]);
+        c = centersTable[c * MOVE_COUNT + m];
+        p = permTable[p * MOVE_COUNT + m];
+        o = orientTable[o * MOVE_COUNT + m];
+        stateIndex = c + 81 * (p + PERMUTATION_COUNT * o);
+    }
+    return { moves, depth: moves.length };
+}
+// Synchronous variant for scripts that have already ensured tables are loaded
+export function solvePyraminxSync(state) {
+    if (!POLICY_TABLE)
+        throw new Error("Pyraminx tables not loaded");
+    return solveWithTables(state).moves;
+}
+const MOVE_INDEX = {
+    "U": 0, "U'": 1,
+    "L": 2, "L'": 3,
+    "R": 4, "R'": 5,
+    "B": 6, "B'": 7
+};
+const FACE_TIP = { U: 0, L: 1, R: 2, B: 3 };
+const TIP_MOVE = { u: 0, l: 1, r: 2, b: 3 };
+// Applies a full scramble (core + tips) over compact coordinate indexes and
+// compares against the target state. No full state clones; runs in O(moves).
+export function verifyPyraminxScramble(state, finalMoves) {
+    const centersTable = CENTERS_TABLE;
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    if (!centersTable || !permTable || !orientTable) {
+        throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let c = 0;
+    let p = 0;
+    let o = 0;
+    const tips = [0, 0, 0, 0];
+    for (const move of finalMoves) {
+        const isInverse = move.endsWith("'");
+        const base = isInverse ? move.slice(0, -1) : move;
+        const faceTip = FACE_TIP[base];
+        if (faceTip !== undefined) {
+            const m = MOVE_INDEX[move];
+            c = centersTable[c * MOVE_COUNT + m];
+            p = permTable[p * MOVE_COUNT + m];
+            o = orientTable[o * MOVE_COUNT + m];
+            tips[faceTip] = (tips[faceTip] + (isInverse ? 2 : 1)) % 3;
+        }
+        else {
+            const tipIndex = TIP_MOVE[base];
+            tips[tipIndex] = (tips[tipIndex] + (isInverse ? 2 : 1)) % 3;
+        }
+    }
+    return (c === getCentersIndex(state.centers) &&
+        p === getPermutationCompactIndex(state.edgesPerm) &&
+        o === getOrientationIndex(state.edgesOrient) &&
+        tips[0] === state.tips[0] &&
+        tips[1] === state.tips[1] &&
+        tips[2] === state.tips[2] &&
+        tips[3] === state.tips[3]);
+}

package/dist/puzzles/pyraminx/solver/table-metadata.d.ts

@@ -0,0 +1,20 @@
+export declare const PYRAMINX_SOLVER_TABLE_METADATA: {
+    readonly centersTable: {
+        readonly entries: 648;
+        readonly checksum: 4058180805;
+    };
+    readonly permutationTable: {
+        readonly entries: 2880;
+        readonly checksum: 4161414597;
+    };
+    readonly orientationTable: {
+        readonly entries: 256;
+        readonly checksum: 3608176069;
+    };
+    readonly policyTable: {
+        readonly entries: 349920;
+        readonly checksum: 4047562730;
+        readonly maxDepth: 11;
+    };
+};
+//# sourceMappingURL=table-metadata.d.ts.map

package/dist/puzzles/pyraminx/solver/table-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-metadata.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/table-metadata.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;CAkBjC,CAAC"}

package/dist/puzzles/pyraminx/solver/table-metadata.js

@@ -0,0 +1,19 @@
+export const PYRAMINX_SOLVER_TABLE_METADATA = {
+    centersTable: {
+        entries: 648,
+        checksum: 4058180805
+    },
+    permutationTable: {
+        entries: 2880,
+        checksum: 4161414597
+    },
+    orientationTable: {
+        entries: 256,
+        checksum: 3608176069
+    },
+    policyTable: {
+        entries: 349920,
+        checksum: 4047562730,
+        maxDepth: 11
+    }
+};

package/dist/puzzles/pyraminx/solver/tables.d.ts

@@ -0,0 +1,43 @@
+import type { PyraminxMove, PyraminxState } from "../types.js";
+export declare function getPermutationIndex(perm: readonly number[]): number;
+export declare function getPermutationFromIndex(index: number, n: number): number[];
+export declare function getOrientationIndex(orient: readonly number[]): number;
+export declare function getOrientationFromIndex(index: number): number[];
+export declare function getCentersIndex(centers: readonly number[]): number;
+export declare function getCentersFromIndex(index: number): number[];
+export declare function permutationParity(perm: readonly number[]): number;
+export declare const PERMUTATION_FULL_COUNT = 720;
+export declare const PERMUTATION_COUNT = 360;
+export declare const PERM_720_TO_360: Int16Array<ArrayBuffer>;
+export declare const PERM_360_TO_720: Uint16Array<ArrayBuffer>;
+export declare function getPermutationCompactIndex(perm: readonly number[]): number;
+export declare function getPermutationCompactFromFull(full: number): number;
+export declare function getPermutationFullFromCompact(compact: number): number;
+export declare function getStateIndex(state: PyraminxState): number;
+export declare function getPyraminxStateFromIndex(index: number): PyraminxState;
+export declare const CENTERS_COUNT = 81;
+export declare const ORIENTATION_COUNT = 32;
+export declare const MOVE_COUNT = 8;
+export declare const STATE_COUNT: number;
+export declare const POLICY_PACKED_ENTRIES: number;
+export declare function getPolicyMoveFromPacked(packed: Uint8Array, stateIndex: number): number;
+export declare const PYRAMINX_MOVES: readonly PyraminxMove[];
+export declare function generateCentersTable(): Uint8Array;
+export declare function generatePermutationTable(): Uint16Array;
+export declare function generateOrientationTable(): Uint8Array;
+export declare function generatePolicyTable(centersTable: Uint8Array, permTable: Uint16Array, orientTable: Uint8Array): {
+    packed: Uint8Array;
+    maxDepth: number;
+};
+export declare function checksum(values: ArrayLike<number>): number;
+export declare let CENTERS_TABLE: Uint8Array | null;
+export declare let PERMUTATION_TABLE: Uint16Array | null;
+export declare let ORIENTATION_TABLE: Uint8Array | null;
+export declare let POLICY_TABLE: Uint8Array | null;
+export declare function ensureTablesLoaded(): Promise<void>;
+export declare function getPolicyMove(stateIndex: number): number;
+export declare function getCentersTransition(centerIdx: number, move: number): number;
+export declare function getPermutationTransition(permIdx: number, move: number): number;
+export declare function getOrientationTransition(orientIdx: number, move: number): number;
+export declare function resetTablesForTests(): void;
+//# sourceMappingURL=tables.d.ts.map

package/dist/puzzles/pyraminx/solver/tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/tables.ts"],"names":[],"mappings":"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"}