@cubingcenter/scrambler 0.5.2 → 0.5.3

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

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

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

@@ -1,6 +1,5 @@
 import { createRandomSource } from "../../random/index.js";
-import { isTrivialSamplingCube2State } from "./validation.js";
-import { encodePermutation, encodeOrientation } from "./solver/tables.js";
+import { isTrivialCube2State } from "./validation.js";
 export function generateRandomCube2State(options = {}) {
     const random = createRandomSource(options.seed);
     const rejectTrivial = options.rejectTrivial ?? true;
@@ -8,15 +7,10 @@ export function generateRandomCube2State(options = {}) {
         // The state is legal by construction (DBL corner fixed, even
         // permutation, orientation sum divisible by 3, values in range), so the
         // only meaningful rejection is the trivial set: solved + the 18
-        // single-move states (scrambles shorter than 2 moves). Coordinates are
-        // encoded once for both checks.
+        // single-move states (scrambles shorter than 2 moves), compared by
+        // arrays — no coordinate encodings in this hot path.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial) {
-            return state;
-        }
-        const p = encodePermutation(state.corners.permutation);
-        const o = encodeOrientation(state.corners.orientation);
-        if (!isTrivialSamplingCube2State(p, o)) {
+        if (!rejectTrivial || !isTrivialCube2State(state)) {
             return state;
         }
     }

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/browser-loader.ts"],"names":[],"mappings":"AAWA,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"}
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/browser-loader.ts"],"names":[],"mappings":"AAWA,wBAAgB,sBAAsB;sBALlB,WAAW;sBACX,WAAW;iBAChB,UAAU;cAKxB;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,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAqBD"}

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

@@ -17,12 +17,12 @@ export async function loadBrowserTables(baseUrl) {
     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)
+        fetchUint8Table(resolved, manifest.files.policy, CUBE2_SOLVER_TABLE_METADATA.policy.entries)
     ]);
     cachedBrowserTables = {
         permutationTable: permTable,
         orientationTable: orientTable,
-        distances: dist
+        policyTable: dist
     };
     return cachedBrowserTables;
 }

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

@@ -11,10 +11,10 @@
       "entries": 6561,
       "checksum": 1566738619
     },
-    "distances": {
-      "file": "distances.bin",
+    "policy": {
+      "file": "policy.bin",
       "entries": 1837080,
-      "checksum": 2959532459,
+      "checksum": 2042005723,
       "maxDepth": 11
     }
   }

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/generated-assets.ts"],"names":[],"mappings":"AAYA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAAC,CAeD"}
+{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/generated-assets.ts"],"names":[],"mappings":"AAYA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAeD"}

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

@@ -1,4 +1,4 @@
 export { solveCube2State, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2Scramble, verifyCube2Solution, verifyCube2SolutionIndices } from "./search.js";
 export type { Cube2Solution } from "./search.js";
-export { areCube2TablesLoaded, BFS_MOVES, DISTANCES, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";
+export { areCube2TablesLoaded, BFS_MOVES, POLICY_TABLE, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,wBAAwB,EACxB,wBAAwB,EACxB,UAAU,EACV,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,wBAAwB,EACxB,wBAAwB,EACxB,UAAU,EACV,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC"}

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

@@ -1,2 +1,2 @@
 export { solveCube2State, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2Scramble, verifyCube2Solution, verifyCube2SolutionIndices } from "./search.js";
-export { areCube2TablesLoaded, BFS_MOVES, DISTANCES, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";
+export { areCube2TablesLoaded, BFS_MOVES, POLICY_TABLE, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/node-loader.ts"],"names":[],"mappings":"AAgBA,wBAAgB,8BAA8B,IAAI;IAChD,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAmBA"}
+{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/node-loader.ts"],"names":[],"mappings":"AAgBA,wBAAgB,8BAA8B,IAAI;IAChD,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB,CAmBA"}

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

@@ -11,11 +11,11 @@ export function readGeneratedCube2SolverTables() {
     }
     const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, CUBE2_SOLVER_TABLE_METADATA.permutationTable.checksum);
     const orientationTable = readUint16Table(assetDirectory, manifest.files.orientationTable, CUBE2_SOLVER_TABLE_METADATA.orientationTable.checksum);
-    const distances = readUint8Table(assetDirectory, manifest.files.distances, CUBE2_SOLVER_TABLE_METADATA.distances.checksum);
+    const policyTable = readUint8Table(assetDirectory, manifest.files.policy, CUBE2_SOLVER_TABLE_METADATA.policy.checksum);
     return {
         permutationTable,
         orientationTable,
-        distances
+        policyTable
     };
 }
 function readUint16Table(assetDirectory, entry, expectedChecksum) {

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

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAQ/E;AAKD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKtE;AA6ED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAMD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAclG"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAQ/E;AAKD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKtE;AAoDD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAMD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAclG"}

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

@@ -1,5 +1,5 @@
 import { createSolvedCube2State } from "../state.js";
-import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, DISTANCES, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
+import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, POLICY_TABLE, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
 export async function solveCube2State(state) {
     await ensureTablesLoaded();
     const indices = solveWithTablesIndices(state);
@@ -17,7 +17,7 @@ export async function solveCube2StateIndices(state) {
     return solveWithTablesIndices(state);
 }
 export function solveCube2StateIndicesSync(state) {
-    if (!DISTANCES) {
+    if (!POLICY_TABLE) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
     return solveWithTablesIndices(state);
@@ -29,39 +29,19 @@ function solveWithTablesIndices(state) {
     }
     const permTable = PERMUTATION_TABLE;
     const orientTable = ORIENTATION_TABLE;
-    const distances = DISTANCES;
+    const policy = POLICY_TABLE;
     let permIndex = encodePermutation(state.corners.permutation);
     let orientIndex = encodeOrientation(state.corners.orientation);
     const moves = [];
-    // High-performance branchless inlined lookup
-    const initialCombined = permIndex * ORIENTATION_COUNT + orientIndex;
-    let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
-    if (distance === 0) {
-        return moves;
-    }
-    while (distance > 0) {
-        let foundNext = false;
-        const permOffset = permIndex * MOVE_COUNT;
-        const orientOffset = orientIndex * MOVE_COUNT;
-        const nextDistance = distance - 1;
-        for (let m = 0; m < BFS_MOVES.length; m++) {
-            const nextPerm = permTable[permOffset + m];
-            const nextOrient = orientTable[orientOffset + m];
-            // High-performance branchless inlined lookup
-            const combined = nextPerm * ORIENTATION_COUNT + nextOrient;
-            const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
-            if (nextDist === nextDistance) {
-                moves.push(m);
-                permIndex = nextPerm;
-                orientIndex = nextOrient;
-                distance = nextDistance;
-                foundNext = true;
-                break;
-            }
-        }
-        if (!foundNext) {
-            throw new Error("BFS distance table corrupted or unreachable state.");
-        }
+    // Direct policy walk: the precomputed optimal move per state, so no
+    // candidate scanning (the old BFS-distance gradient walk) is needed.
+    let combined = permIndex * ORIENTATION_COUNT + orientIndex;
+    while (combined !== 0) {
+        const m = (policy[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        moves.push(m);
+        permIndex = permTable[permIndex * MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * MOVE_COUNT + m];
+        combined = permIndex * ORIENTATION_COUNT + orientIndex;
     }
     return moves;
 }

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

@@ -7,9 +7,9 @@ export declare const CUBE2_SOLVER_TABLE_METADATA: {
         readonly entries: 6561;
         readonly checksum: 1566738619;
     };
-    readonly distances: {
+    readonly policy: {
         readonly entries: 1837080;
-        readonly checksum: 2959532459;
+        readonly checksum: 2042005723;
         readonly maxDepth: 11;
     };
 };

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

@@ -7,9 +7,9 @@ export const CUBE2_SOLVER_TABLE_METADATA = {
         entries: 6561,
         checksum: 1566738619
     },
-    distances: {
+    policy: {
         entries: 1837080,
-        checksum: 2959532459,
+        checksum: 2042005723,
         maxDepth: 11
     }
 };

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

@@ -5,7 +5,7 @@ export declare function encodePermutation(permutation: readonly number[]): numbe
 export declare function encodeOrientation(orientation: readonly number[]): number;
 export declare let PERMUTATION_TABLE: Uint16Array | null;
 export declare let ORIENTATION_TABLE: Uint16Array | null;
-export declare let DISTANCES: Uint8Array | null;
+export declare let POLICY_TABLE: Uint8Array | null;
 export declare function ensureTablesLoaded(): Promise<void>;
 export declare function areCube2TablesLoaded(): boolean;
 export declare function getDistance(permIndex: number, orientIndex: number): number;

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

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAM5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAexE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,SAAS,EAAE,UAAU,GAAG,IAAW,CAAC;AAE/C,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAO1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAW5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYxE;AAWD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAElD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAkB1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}

package/dist/puzzles/cube2/solver/tables.js

@@ -5,19 +5,31 @@ export const MOVE_COUNT = 9;
 // ---------------------------------------------------------------------------
 // Coordinate encoding / decoding
 // ---------------------------------------------------------------------------
+// Lehmer encoding of the 7 free corners (DBL at index 6 is fixed), with a
+// bitmask instead of array removal: available values tracked as bits, the
+// rank of a value = the popcount of the bits below it.
+const PERM7_FACT = [720, 120, 24, 6, 2, 1, 1];
 export function encodePermutation(permutation) {
-    const perm7 = permutation.filter((_, i) => i !== 6);
-    const mapped = perm7.map((x) => (x > 6 ? x - 1 : x));
     let index = 0;
-    const available = [0, 1, 2, 3, 4, 5, 6];
+    let available = 0b1111111;
     for (let position = 0; position < 7; position += 1) {
-        const value = mapped[position];
-        const selected = available.indexOf(value);
-        index += selected * factorialSmall(6 - position);
-        available.splice(selected, 1);
+        const permPosition = position < 6 ? position : position + 1;
+        const piece = permutation[permPosition];
+        const value = piece > 6 ? piece - 1 : piece;
+        const rank = popcount(available & ((1 << value) - 1));
+        index += rank * PERM7_FACT[position];
+        available &= ~(1 << value);
     }
     return index;
 }
+function popcount(x) {
+    let count = 0;
+    while (x !== 0) {
+        x &= x - 1;
+        count += 1;
+    }
+    return count;
+}
 export function encodeOrientation(orientation) {
     const orient7 = orientation.filter((_, i) => i !== 6);
     let index = 0;
@@ -41,7 +53,7 @@ function factorialSmall(n) {
 let tablesLoaded = false;
 export let PERMUTATION_TABLE = null;
 export let ORIENTATION_TABLE = null;
-export let DISTANCES = null;
+export let POLICY_TABLE = null;
 export async function ensureTablesLoaded() {
     if (tablesLoaded) {
         return;
@@ -49,7 +61,7 @@ export async function ensureTablesLoaded() {
     const tables = await loadGeneratedCube2SolverTables();
     PERMUTATION_TABLE = tables.permutationTable;
     ORIENTATION_TABLE = tables.orientationTable;
-    DISTANCES = tables.distances;
+    POLICY_TABLE = tables.policyTable;
     tablesLoaded = true;
 }
 export function areCube2TablesLoaded() {
@@ -59,12 +71,23 @@ export function areCube2TablesLoaded() {
 // Public API
 // ---------------------------------------------------------------------------
 export function getDistance(permIndex, orientIndex) {
-    if (!DISTANCES) {
+    if (!POLICY_TABLE) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
-    const combined = permIndex * ORIENTATION_COUNT + orientIndex;
-    const byteValue = DISTANCES[combined >> 1];
-    return (combined & 1) === 0 ? (byteValue & 0x0f) : (byteValue >> 4);
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    let p = permIndex;
+    let o = orientIndex;
+    let combined = p * ORIENTATION_COUNT + o;
+    let distance = 0;
+    while (combined !== 0) {
+        const m = (POLICY_TABLE[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        p = permTable[p * MOVE_COUNT + m];
+        o = orientTable[o * MOVE_COUNT + m];
+        combined = p * ORIENTATION_COUNT + o;
+        distance += 1;
+    }
+    return distance;
 }
 export function getPermutationTransition(move, permIndex) {
     if (!PERMUTATION_TABLE) {

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

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAOnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAO7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAK7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAOnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAO7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAK7E;AAKD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}

package/dist/puzzles/cube2/state.js

@@ -19,8 +19,10 @@ export function cube2StatesEqual(left, right) {
     return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
         arraysEqual(left.corners.orientation, right.corners.orientation));
 }
+// Read-only canonical solved state for comparisons (never mutated).
+const SOLVED_STATE = createSolvedCube2State();
 export function isSolvedCube2State(state) {
-    return cube2StatesEqual(state, createSolvedCube2State());
+    return cube2StatesEqual(state, SOLVED_STATE);
 }
 function range(length) {
     return Array.from({ length }, (_, index) => index);

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

@@ -1,4 +1,5 @@
 import type { Cube2State, Cube2ValidationResult } from "./types.js";
+export declare function isTrivialCube2State(state: Cube2State): boolean;
 export declare function validateCube2State(state: Cube2State): Cube2ValidationResult;
 export declare function isOneMoveFromSolvedCube2State(state: Cube2State): boolean;
 export declare function isTrivialSamplingCube2State(p: number, o: number): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAgBpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAkB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIxE;AAKD,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAwBpE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAuB9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAkB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIxE;AAKD,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}

package/dist/puzzles/cube2/validation.js

@@ -2,16 +2,47 @@ import { CUBE2_MOVES, CORNER_COUNT } from "./types.js";
 import { applyCube2Move } from "./moves.js";
 import { createSolvedCube2State, isSolvedCube2State } from "./state.js";
 import { encodeOrientation, encodePermutation } from "./solver/tables.js";
+// The 18 single-move states, precomputed once so the hot random-state path
+// checks "solved or one move from solved" with pure array comparisons
+// (no coordinate encodings per generated state).
+const ONE_MOVE_FROM_SOLVED_STATES = CUBE2_MOVES.map((move) => applyCube2Move(createSolvedCube2State(), move));
 // Precomputed coordinate encodings of every single-move state, so the
 // "one move from solved" check is a couple of O(n) encodings + 18 comparisons
 // instead of 18 full state applications.
-const ONE_MOVE_FROM_SOLVED_ENCODED = CUBE2_MOVES.map((move) => {
-    const state = applyCube2Move(createSolvedCube2State(), move);
-    return {
-        p: encodePermutation(state.corners.permutation),
-        o: encodeOrientation(state.corners.orientation)
-    };
-});
+const ONE_MOVE_FROM_SOLVED_ENCODED = ONE_MOVE_FROM_SOLVED_STATES.map((state) => ({
+    p: encodePermutation(state.corners.permutation),
+    o: encodeOrientation(state.corners.orientation)
+}));
+// Cheap trivial check for random-state sampling: solved + the 18 single-move
+// states, compared by arrays with early exit (a random state differs from
+// each candidate within the first couple of permutation entries, so the
+// typical cost is tens of comparisons — no coordinate encodings).
+export function isTrivialCube2State(state) {
+    const cp = state.corners.permutation;
+    const co = state.corners.orientation;
+    for (const candidate of ONE_MOVE_FROM_SOLVED_STATES) {
+        const p = candidate.corners.permutation;
+        const o = candidate.corners.orientation;
+        let match = true;
+        for (let i = 0; i < 8; i += 1) {
+            if (cp[i] !== p[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (!match)
+            continue;
+        for (let i = 0; i < 8; i += 1) {
+            if (co[i] !== o[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return true;
+    }
+    return isSolvedCube2State(state);
+}
 export function validateCube2State(state) {
     const errors = [
         ...validatePermutation("corner", state.corners.permutation, CORNER_COUNT),

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

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

package/dist/puzzles/cube3/facelets.js

@@ -1,4 +1,6 @@
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const STICKERS = ["U", "R", "F", "D", "L", "B"];
+const STICKER_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 const CORNER_PIECE_STICKERS = [
     ["U", "R", "F"],
     ["U", "F", "L"],
@@ -47,20 +49,60 @@ const EDGE_POSITION_SLOTS = [
     [["B", 5], ["L", 3]],
     [["B", 3], ["R", 5]]
 ];
+const CORNER_CELLS = buildCells(CORNER_POSITION_SLOTS, CORNER_PIECE_STICKERS, 3);
+const EDGE_CELLS = buildCells(EDGE_POSITION_SLOTS, EDGE_PIECE_STICKERS, 2);
+function buildCells(slots, stickersTable, orientationCount) {
+    const cells = [];
+    for (let position = 0; position < slots.length; position += 1) {
+        const byPiece = [];
+        for (let piece = 0; piece < stickersTable.length; piece += 1) {
+            const byOrientation = [];
+            for (let orientation = 0; orientation < orientationCount; orientation += 1) {
+                const stickers = stickersTable[piece];
+                const slotList = slots[position];
+                const cell = [];
+                for (let index = 0; index < slotList.length; index += 1) {
+                    const [face, stickerIndex] = slotList[index];
+                    cell.push(FACE_ORDER.indexOf(face));
+                    cell.push(stickerIndex);
+                    cell.push(STICKER_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
+function placeCells(faces, cells) {
+    for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+        faces[cells[cellIndex]][cells[cellIndex + 1]] = STICKERS[cells[cellIndex + 2]];
+    }
+}
 export function toCube3Facelets(state) {
-    const facelets = createEmptyFacelets();
-    for (const face of FACE_ORDER) {
-        facelets[face][4] = face;
+    const facelets = {
+        U: Array(9),
+        R: Array(9),
+        F: Array(9),
+        D: Array(9),
+        L: Array(9),
+        B: Array(9)
+    };
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    // Centers (fixed, since no center permutation on the 3x3)
+    for (let face = 0; face < 6; face += 1) {
+        faces[face][4] = STICKERS[face];
     }
-    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);
+    const cornerPermutation = state.corners.permutation;
+    const cornerOrientation = state.corners.orientation;
+    for (let position = 0; position < CORNER_CELLS.length; position += 1) {
+        placeCells(faces, CORNER_CELLS[position][cornerPermutation[position]][cornerOrientation[position]]);
     }
-    for (let position = 0; position < EDGE_POSITION_SLOTS.length; position += 1) {
-        const piece = state.edges.permutation[position];
-        const orientation = state.edges.orientation[position];
-        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+    const edgePermutation = state.edges.permutation;
+    const edgeOrientation = state.edges.orientation;
+    for (let position = 0; position < EDGE_CELLS.length; position += 1) {
+        placeCells(faces, EDGE_CELLS[position][edgePermutation[position]][edgeOrientation[position]]);
     }
     return facelets;
 }
@@ -70,20 +112,3 @@ export function formatCube3Facelets(facelets) {
 export function getCube3FaceOrder() {
     return FACE_ORDER;
 }
-function createEmptyFacelets() {
-    return {
-        U: Array(9).fill("U"),
-        R: Array(9).fill("R"),
-        F: Array(9).fill("F"),
-        D: Array(9).fill("D"),
-        L: Array(9).fill("L"),
-        B: Array(9).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/cube3/random-state.d.ts.map

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

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

@@ -1,6 +1,7 @@
 import { createRandomSource } from "../../random/index.js";
 import { CORNER_COUNT, EDGE_COUNT } from "./types.js";
-import { isAllowedRandomCube3State, permutationParity } from "./validation.js";
+import { isOneMoveFromSolvedCube3State, permutationParity } from "./validation.js";
+import { isSolvedCube3State } from "./state.js";
 import { generateSubsetCube3State } from "./subset-state.js";
 export function generateRandomCube3State(options = {}) {
     const random = createRandomSource(options.seed);
@@ -9,8 +10,14 @@ export function generateRandomCube3State(options = {}) {
         return generateSubsetCube3State(options.subset, random);
     }
     for (let attempt = 0; attempt < 100; attempt += 1) {
+        // The state is legal by construction (permutations shuffled, orientation
+        // sums fixed, parity matched), so the only meaningful rejection is the
+        // trivial set (solved + 18 single-move states) — no full re-validation.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || isAllowedRandomCube3State(state)) {
+        if (!rejectTrivial) {
+            return state;
+        }
+        if (!isSolvedCube3State(state) && !isOneMoveFromSolvedCube3State(state)) {
             return state;
         }
     }

package/dist/puzzles/cube3/scrambler.js

@@ -44,7 +44,7 @@ export async function generateCube3Scramble(options = {}) {
             generatorVersion: "1.0.0",
             facelets,
             faceletString: formatCube3Facelets(facelets),
-            state: JSON.parse(JSON.stringify(state)),
+            state,
             solutionMoves: solution.moves,
             solutionDepth: solution.depth,
             phase1Depth: solution.phase1.depth,

package/dist/puzzles/cube3/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAWnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAW7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAO7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAWnD;AAMD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAW7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAO7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}

package/dist/puzzles/cube3/state.js

@@ -11,6 +11,9 @@ export function createSolvedCube3State() {
         }
     };
 }
+// Read-only canonical solved state for comparisons (never mutated, so a
+// single shared instance is safe and avoids allocating per call).
+const SOLVED_STATE = createSolvedCube3State();
 export function cloneCube3State(state) {
     return {
         corners: {
@@ -30,7 +33,7 @@ export function cube3StatesEqual(left, right) {
         arraysEqual(left.edges.orientation, right.edges.orientation));
 }
 export function isSolvedCube3State(state) {
-    return cube3StatesEqual(state, createSolvedCube3State());
+    return cube3StatesEqual(state, SOLVED_STATE);
 }
 function range(length) {
     return Array.from({ length }, (_, index) => index);

package/dist/puzzles/cube3/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CA+B3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAGxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CA+B3E;AASD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAExE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}