cubegin 0.0.1

package/dist/scramble-core/src/solvers/min2phase/search-wca.mjs

@@ -0,0 +1,21 @@
+import { axisForRestriction, isAxisRestriction, splitAlgorithm } from "./util.mjs";
+import { Search } from "./search.mjs";
+//#region .build/vendor/scramble-core/src/solvers/min2phase/search-wca.ts
+var SearchWCA = class extends Search {
+	solution(facelets, maxDepth, probeMax, probeMin, verbose, firstAxisRestriction, lastAxisRestriction) {
+		if (!isValidRestriction(firstAxisRestriction)) return "Error 9";
+		if (!isValidRestriction(lastAxisRestriction)) return "Error 9";
+		const solution = super.solution(facelets, maxDepth, probeMax, probeMin, verbose);
+		if (solution.startsWith("Error")) return solution;
+		const moves = splitAlgorithm(solution);
+		if (violatesAxisRestriction(moves[0], firstAxisRestriction) || violatesAxisRestriction(moves.at(-1), lastAxisRestriction)) return "Error 7";
+		return solution;
+	}
+};
+const isValidRestriction = (restriction) => restriction === null || restriction === void 0 || isAxisRestriction(restriction);
+const violatesAxisRestriction = (move, restriction) => {
+	if (move === void 0 || restriction === null || restriction === void 0) return false;
+	return axisForRestriction(move[0]) === axisForRestriction(restriction);
+};
+//#endregion
+export { SearchWCA };

package/dist/scramble-core/src/solvers/min2phase/search.mjs

@@ -0,0 +1,25 @@
+import { solve } from "./engine.mjs";
+import { initCoordCube } from "./coord-cube.mjs";
+import { invertAlgorithm } from "./util.mjs";
+import { CubieCube } from "./cubie-cube.mjs";
+//#region .build/vendor/scramble-core/src/solvers/min2phase/search.ts
+var Search = class {
+	static init() {
+		initCoordCube();
+	}
+	solution(facelets, maxDepth, _probeMax, _probeMin, verbose) {
+		if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) return "Error 7";
+		initCoordCube();
+		const cube = CubieCube.fromFaceCube(facelets);
+		if (cube === null) return "Error 1";
+		const verification = cube.verify();
+		if (verification !== 0) return `Error ${Math.abs(verification)}`;
+		const solution = solve(cube).trim();
+		if (solution.startsWith("Error")) return solution;
+		if ((solution.length === 0 ? [] : solution.split(/\s+/)).length > maxDepth) return "Error 7";
+		if ((verbose & 8) !== 0) return "Error 7";
+		return (verbose & 2) === 0 ? invertAlgorithm(solution) : solution;
+	}
+};
+//#endregion
+export { Search };

package/dist/scramble-core/src/solvers/min2phase/tools.mjs

@@ -0,0 +1,169 @@
+import { drawRandomInt } from "./util.mjs";
+import { CubieCube, getNParity, getNPerm } from "./cubie-cube.mjs";
+//#region .build/vendor/scramble-core/src/solvers/min2phase/tools.ts
+const STATE_RANDOM = null;
+const STATE_SOLVED = [];
+const randomCube = (random) => randomState(STATE_RANDOM, STATE_RANDOM, STATE_RANDOM, STATE_RANDOM, random);
+const randomState = (cornerPermutation, cornerOrientation, edgePermutation, edgeOrientation, random) => {
+	const epUnknownCount = edgePermutation === STATE_RANDOM ? 12 : countUnknown(edgePermutation);
+	const cpUnknownCount = cornerPermutation === STATE_RANDOM ? 8 : countUnknown(cornerPermutation);
+	let parity;
+	let cpValue;
+	let epValue;
+	if (epUnknownCount < 2) {
+		if (edgePermutation === STATE_SOLVED) {
+			epValue = 0;
+			parity = 0;
+		} else if (edgePermutation !== STATE_RANDOM) {
+			const resolvedEp = materializeState(edgePermutation, 12);
+			parity = resolvePerm(resolvedEp, epUnknownCount, -1, random);
+			epValue = getNPerm(resolvedEp, 12);
+		} else throw new Error("@cubegin/scramble-core: invalid random edge state");
+		if (cornerPermutation === STATE_SOLVED) cpValue = 0;
+		else if (cornerPermutation === STATE_RANDOM) cpValue = drawRandomPermutationWithParity(random, 40320, 8, parity);
+		else {
+			const resolvedCp = materializeState(cornerPermutation, 8);
+			resolvePerm(resolvedCp, cpUnknownCount, parity, random);
+			cpValue = getNPerm(resolvedCp, 8);
+		}
+	} else {
+		if (cornerPermutation === STATE_SOLVED) {
+			cpValue = 0;
+			parity = 0;
+		} else if (cornerPermutation === STATE_RANDOM) {
+			cpValue = drawRandomInt(random, 40320);
+			parity = getNParity(cpValue, 8);
+		} else {
+			const resolvedCp = materializeState(cornerPermutation, 8);
+			parity = resolvePerm(resolvedCp, cpUnknownCount, -1, random);
+			cpValue = getNPerm(resolvedCp, 8);
+		}
+		if (edgePermutation === STATE_RANDOM) epValue = drawRandomPermutationWithParity(random, 479001600, 12, parity);
+		else {
+			const resolvedEp = materializeState(edgePermutation, 12);
+			resolvePerm(resolvedEp, epUnknownCount, parity, random);
+			epValue = getNPerm(resolvedEp, 12);
+		}
+	}
+	return CubieCube.fromCoordinates(cpValue, cornerOrientation === STATE_RANDOM ? drawRandomInt(random, 2187) : cornerOrientation === STATE_SOLVED ? 0 : resolveOri(materializeState(cornerOrientation, 8), 3, random), epValue, edgeOrientation === STATE_RANDOM ? drawRandomInt(random, 2048) : edgeOrientation === STATE_SOLVED ? 0 : resolveOri(materializeState(edgeOrientation, 12), 2, random)).toFaceCube();
+};
+const drawRandomPermutationWithParity = (random, maxExclusive, pieceCount, parity) => {
+	const permutationValue = drawRandomInt(random, maxExclusive);
+	return getNParity(permutationValue, pieceCount) === parity ? permutationValue : flipPermutationParity(permutationValue, pieceCount);
+};
+const flipPermutationParity = (permutationValue, pieceCount) => {
+	const permutation = permutationFromIndex(permutationValue, pieceCount);
+	const first = permutation[0] ?? 0;
+	permutation[0] = permutation[1] ?? 0;
+	permutation[1] = first;
+	return getNPerm(permutation, pieceCount);
+};
+const permutationFromIndex = (permutationValue, pieceCount) => {
+	const permutation = Array(pieceCount);
+	let index = permutationValue;
+	for (let i = pieceCount - 1; i >= 0; i -= 1) {
+		permutation[i] = index % (pieceCount - i);
+		index = Math.floor(index / (pieceCount - i));
+		for (let j = i + 1; j < pieceCount; j += 1) if ((permutation[j] ?? 0) >= (permutation[i] ?? 0)) permutation[j] = (permutation[j] ?? 0) + 1;
+	}
+	return permutation;
+};
+const resolveOri = (orientations, base, random) => {
+	let sum = 0;
+	let index = 0;
+	let lastUnknown = -1;
+	for (let i = 0; i < orientations.length; i += 1) {
+		if (orientations[i] === -1) {
+			orientations[i] = drawRandomInt(random, base);
+			lastUnknown = i;
+		}
+		sum += orientations[i] ?? 0;
+	}
+	if (sum % base !== 0 && lastUnknown !== -1) orientations[lastUnknown] = (30 + (orientations[lastUnknown] ?? 0) - sum) % base;
+	for (let i = 0; i < orientations.length - 1; i += 1) {
+		index *= base;
+		index += orientations[i] ?? 0;
+	}
+	return index;
+};
+const countUnknown = (state) => {
+	if (state === STATE_SOLVED) return 0;
+	return state?.filter((value) => value === -1).length ?? 0;
+};
+const resolvePerm = (permutation, unknownCount, parity, random) => {
+	const available = Array.from({ length: permutation.length }, (_, index) => permutation.includes(index) ? -1 : index);
+	let shuffledCount = 0;
+	for (let i = 0; i < available.length; i += 1) {
+		if (available[i] === -1) continue;
+		const swapIndex = drawRandomInt(random, shuffledCount + 1);
+		const value = available[i] ?? -1;
+		available[i] = available[swapIndex] ?? -1;
+		available[shuffledCount] = value;
+		shuffledCount += 1;
+	}
+	let last = -1;
+	let cursor = 0;
+	let remainingUnknown = unknownCount;
+	while (cursor < permutation.length && remainingUnknown > 0) {
+		if (permutation[cursor] === -1) {
+			if (remainingUnknown === 2) last = cursor;
+			permutation[cursor] = available[remainingUnknown -= 1] ?? 0;
+		}
+		cursor += 1;
+	}
+	const resolvedParity = getNParity(getNPerm(permutation, permutation.length), permutation.length);
+	if (resolvedParity === 1 - parity && last !== -1) {
+		const swapIndex = cursor - 1;
+		const value = permutation[swapIndex] ?? 0;
+		permutation[swapIndex] = permutation[last] ?? 0;
+		permutation[last] = value;
+	}
+	return resolvedParity;
+};
+const materializeState = (state, length) => {
+	if (state === STATE_SOLVED) return Array.from({ length }, (_, index) => index);
+	return [...state];
+};
+const MOVE_CUBES = [
+	CubieCube.fromCoordinates(15120, 0, 119750400, 0),
+	CubieCube.solved(),
+	CubieCube.solved(),
+	CubieCube.fromCoordinates(21021, 1494, 323403417, 0),
+	CubieCube.solved(),
+	CubieCube.solved(),
+	CubieCube.fromCoordinates(8064, 1236, 29441808, 550),
+	CubieCube.solved(),
+	CubieCube.solved(),
+	CubieCube.fromCoordinates(9, 0, 5880, 0),
+	CubieCube.solved(),
+	CubieCube.solved(),
+	CubieCube.fromCoordinates(1230, 412, 2949660, 0),
+	CubieCube.solved(),
+	CubieCube.solved(),
+	CubieCube.fromCoordinates(224, 137, 328552, 137),
+	CubieCube.solved(),
+	CubieCube.solved()
+];
+for (let axis = 0; axis < 18; axis += 3) {
+	MOVE_CUBES[axis + 1] = multiply(MOVE_CUBES[axis], MOVE_CUBES[axis]);
+	MOVE_CUBES[axis + 2] = multiply(MOVE_CUBES[axis + 1], MOVE_CUBES[axis]);
+}
+function multiply(left, right) {
+	const cp = Array(8);
+	const co = Array(8);
+	const ep = Array(12);
+	const eo = Array(12);
+	for (let corner = 0; corner < 8; corner += 1) {
+		const rightCorner = right.cp[corner] ?? 0;
+		cp[corner] = left.cp[rightCorner] ?? 0;
+		co[corner] = ((left.co[rightCorner] ?? 0) + (right.co[corner] ?? 0)) % 3;
+	}
+	for (let edge = 0; edge < 12; edge += 1) {
+		const rightEdge = right.ep[edge] ?? 0;
+		ep[edge] = left.ep[rightEdge] ?? 0;
+		eo[edge] = (right.eo[edge] ?? 0) ^ (left.eo[rightEdge] ?? 0);
+	}
+	return new CubieCube(cp, co, ep, eo);
+}
+//#endregion
+export { randomCube };

package/dist/scramble-core/src/solvers/min2phase/util.mjs

@@ -0,0 +1,30 @@
+//#region .build/vendor/scramble-core/src/solvers/min2phase/util.ts
+const SOLVED_FACE_CUBE = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB";
+const FACE_AXIS = {
+	U: 0,
+	D: 0,
+	R: 1,
+	L: 1,
+	F: 2,
+	B: 2
+};
+const axisForRestriction = (restriction) => {
+	if (restriction === void 0) return void 0;
+	return FACE_AXIS[restriction];
+};
+const isAxisRestriction = (restriction) => restriction !== void 0 && axisForRestriction(restriction) !== void 0;
+const splitAlgorithm = (algorithm) => algorithm.trim().length === 0 ? [] : algorithm.trim().split(/\s+/);
+const invertAlgorithm = (algorithm) => splitAlgorithm(algorithm).reverse().map(invertMove).join(" ");
+const drawRandomInt = (random, maxExclusive) => {
+	if (!Number.isSafeInteger(maxExclusive) || maxExclusive <= 0) throw new RangeError("@cubegin/scramble-core: random maxExclusive must be a positive safe integer");
+	const value = random.nextInt(maxExclusive);
+	if (!Number.isSafeInteger(value) || value < 0 || value >= maxExclusive) throw new RangeError(`@cubegin/scramble-core: random source returned ${value} for max ${maxExclusive}`);
+	return value;
+};
+const invertMove = (move) => {
+	if (move.endsWith("2")) return move;
+	if (move.endsWith("'")) return move.slice(0, -1);
+	return `${move}'`;
+};
+//#endregion
+export { SOLVED_FACE_CUBE, axisForRestriction, drawRandomInt, invertAlgorithm, isAxisRestriction, splitAlgorithm };

package/dist/scramble-core/src/solvers/pyraminx-solver.d.mts

@@ -0,0 +1,17 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/solvers/pyraminx-solver.d.ts
+interface PyraminxSolverState {
+  readonly edgePerm: number;
+  readonly edgeOrient: number;
+  readonly cornerOrient: number;
+  readonly tips: number;
+}
+declare class PyraminxSolver {
+  randomState(random: RandomSource): PyraminxSolverState;
+  solveIn(state: PyraminxSolverState, maxLength: number, includingTips: boolean, random: RandomSource): string | null;
+  generateExactly(state: PyraminxSolverState, length: number, includingTips: boolean, random: RandomSource): string;
+  private solve;
+}
+//#endregion
+export { PyraminxSolver, PyraminxSolverState };

package/dist/scramble-core/src/solvers/pyraminx-solver.mjs

@@ -0,0 +1,350 @@
+//#region .build/vendor/scramble-core/src/solvers/pyraminx-solver.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const N_EDGE_PERM = 720;
+const N_EDGE_ORIENT = 32;
+const N_CORNER_ORIENT = 81;
+const N_ORIENT = N_EDGE_ORIENT * N_CORNER_ORIENT;
+const N_TIPS = 81;
+const N_MOVES = 8;
+const MAX_LENGTH = 20;
+const MAX_EDGE_PERM_ATTEMPTS = 100;
+const MOVE_TO_STRING = [
+	"U",
+	"U'",
+	"L",
+	"L'",
+	"R",
+	"R'",
+	"B",
+	"B'"
+];
+const INVERSE_MOVE_TO_STRING = [
+	"U'",
+	"U",
+	"L'",
+	"L",
+	"R'",
+	"R",
+	"B'",
+	"B"
+];
+const TIP_TO_STRING = [
+	"u",
+	"u'",
+	"l",
+	"l'",
+	"r",
+	"r'",
+	"b",
+	"b'"
+];
+const INVERSE_TIP_TO_STRING = [
+	"u'",
+	"u",
+	"l'",
+	"l",
+	"r'",
+	"r",
+	"b'",
+	"b"
+];
+const FACT = [
+	1,
+	1,
+	2,
+	6,
+	24,
+	120,
+	720
+];
+let cachedTables;
+const packEdgePerm = (edges) => {
+	let index = 0;
+	let value = 5517840;
+	for (let position = 0; position < 5; position += 1) {
+		const shiftedEdge = (edges[position] & 7) << 2;
+		index = (6 - position) * index + (value >> shiftedEdge & 7);
+		value -= 1118480 << shiftedEdge;
+	}
+	return index;
+};
+const unpackEdgePerm = (permutation, edges) => {
+	let remaining = permutation;
+	let value = 5517840;
+	for (let position = 0; position < 5; position += 1) {
+		const divisor = FACT[5 - position];
+		let edge = Math.floor(remaining / divisor);
+		remaining -= edge * divisor;
+		edge <<= 2;
+		edges[position] = value >> edge & 7;
+		const mask = (1 << edge) - 1;
+		value = (value & mask) + (value >> 4 & ~mask);
+	}
+	edges[5] = value;
+};
+const packEdgeOrient = (edges) => {
+	let orientation = 0;
+	for (let position = 0; position < 5; position += 1) orientation = 2 * orientation + (edges[position] >> 3);
+	return orientation;
+};
+const unpackEdgeOrient = (orientation, edges) => {
+	let remaining = orientation;
+	let orientationSum = 0;
+	for (let position = 4; position >= 0; position -= 1) {
+		const edgeOrientation = remaining & 1;
+		edges[position] = edgeOrientation << 3;
+		orientationSum ^= edgeOrientation;
+		remaining >>= 1;
+	}
+	edges[5] = orientationSum << 3;
+};
+const packCornerOrient = (corners) => {
+	let orientation = 0;
+	for (let position = 0; position < 4; position += 1) orientation = 3 * orientation + corners[position];
+	return orientation;
+};
+const unpackCornerOrient = (orientation, corners) => {
+	let remaining = orientation;
+	for (let position = 3; position >= 0; position -= 1) {
+		corners[position] = remaining % 3;
+		remaining = Math.floor(remaining / 3);
+	}
+};
+const cycleAndOrient = (edges, first, second, third, times) => {
+	for (let count = 0; count < times; count += 1) {
+		const savedThird = edges[third];
+		edges[third] = (edges[second] + 8) % 16;
+		edges[second] = (edges[first] + 8) % 16;
+		edges[first] = savedThird;
+	}
+};
+const moveEdges = (edges, move) => {
+	const face = Math.floor(move / 2);
+	const times = move % 2 + 1;
+	switch (face) {
+		case 0:
+			cycleAndOrient(edges, 5, 3, 1, times);
+			break;
+		case 1:
+			cycleAndOrient(edges, 2, 1, 0, times);
+			break;
+		case 2:
+			cycleAndOrient(edges, 0, 3, 4, times);
+			break;
+		case 3:
+			cycleAndOrient(edges, 2, 4, 5, times);
+			break;
+	}
+};
+const moveCorners = (corners, move) => {
+	const face = Math.floor(move / 2);
+	const times = move % 2 + 1;
+	corners[face] = (corners[face] + times) % 3;
+};
+const copyCubies = (source, target) => {
+	for (let index = 0; index < source.length; index += 1) target[index] = source[index];
+};
+const createMoveTables = () => {
+	const moveEdgePerm = Array.from({ length: N_EDGE_PERM }, () => new Uint16Array(N_MOVES));
+	const moveEdgeOrient = Array.from({ length: N_EDGE_ORIENT }, () => new Uint8Array(N_MOVES));
+	const moveCornerOrient = Array.from({ length: N_CORNER_ORIENT }, () => new Uint8Array(N_MOVES));
+	const edges = Array.from({ length: 6 }, () => 0);
+	const movedEdges = Array.from({ length: 6 }, () => 0);
+	const corners = Array.from({ length: 4 }, () => 0);
+	const movedCorners = Array.from({ length: 4 }, () => 0);
+	for (let permutation = 0; permutation < N_EDGE_PERM; permutation += 1) {
+		unpackEdgePerm(permutation, edges);
+		for (let move = 0; move < N_MOVES; move += 1) {
+			copyCubies(edges, movedEdges);
+			moveEdges(movedEdges, move);
+			moveEdgePerm[permutation][move] = packEdgePerm(movedEdges);
+		}
+	}
+	for (let orientation = 0; orientation < N_EDGE_ORIENT; orientation += 1) {
+		unpackEdgeOrient(orientation, edges);
+		for (let move = 0; move < N_MOVES; move += 1) {
+			copyCubies(edges, movedEdges);
+			moveEdges(movedEdges, move);
+			moveEdgeOrient[orientation][move] = packEdgeOrient(movedEdges);
+		}
+	}
+	for (let orientation = 0; orientation < N_CORNER_ORIENT; orientation += 1) {
+		unpackCornerOrient(orientation, corners);
+		for (let move = 0; move < N_MOVES; move += 1) {
+			copyCubies(corners, movedCorners);
+			moveCorners(movedCorners, move);
+			moveCornerOrient[orientation][move] = packCornerOrient(movedCorners);
+		}
+	}
+	return {
+		moveEdgePerm,
+		moveEdgeOrient,
+		moveCornerOrient
+	};
+};
+const createPermutationPruningTable = (moveEdgePerm) => {
+	const pruning = new Int8Array(N_EDGE_PERM);
+	pruning.fill(-1);
+	pruning[0] = 0;
+	let done = 1;
+	for (let length = 0; done < N_EDGE_PERM / 2; length += 1) for (let permutation = 0; permutation < N_EDGE_PERM; permutation += 1) {
+		if (pruning[permutation] !== length) continue;
+		for (let move = 0; move < N_MOVES; move += 1) {
+			const nextPermutation = moveEdgePerm[permutation][move];
+			if (pruning[nextPermutation] !== -1) continue;
+			pruning[nextPermutation] = length + 1;
+			done += 1;
+		}
+	}
+	return pruning;
+};
+const createOrientationPruningTable = (moveEdgeOrient, moveCornerOrient) => {
+	const pruning = new Int8Array(N_ORIENT);
+	pruning.fill(-1);
+	pruning[0] = 0;
+	let done = 1;
+	for (let length = 0; done < N_ORIENT; length += 1) for (let orientation = 0; orientation < N_ORIENT; orientation += 1) {
+		if (pruning[orientation] !== length) continue;
+		for (let move = 0; move < N_MOVES; move += 1) {
+			const nextEdgeOrient = moveEdgeOrient[orientation % N_EDGE_ORIENT][move];
+			const nextOrientation = moveCornerOrient[Math.floor(orientation / N_EDGE_ORIENT)][move] * N_EDGE_ORIENT + nextEdgeOrient;
+			if (pruning[nextOrientation] !== -1) continue;
+			pruning[nextOrientation] = length + 1;
+			done += 1;
+		}
+	}
+	return pruning;
+};
+const createTables = () => {
+	const { moveEdgePerm, moveEdgeOrient, moveCornerOrient } = createMoveTables();
+	return {
+		moveEdgePerm,
+		moveEdgeOrient,
+		moveCornerOrient,
+		prunPerm: createPermutationPruningTable(moveEdgePerm),
+		prunOrient: createOrientationPruningTable(moveEdgeOrient, moveCornerOrient)
+	};
+};
+const getTables = () => {
+	cachedTables ??= createTables();
+	return cachedTables;
+};
+const validateCoordinate = (coordinateName, coordinate, maxExclusive) => {
+	if (!Number.isSafeInteger(coordinate) || coordinate < 0 || coordinate >= maxExclusive) throw new RangeError(`${ERROR_PREFIX}: Pyraminx ${coordinateName} must be an integer from 0 to ${maxExclusive - 1}`);
+};
+const validateState = (state) => {
+	validateCoordinate("edgePerm", state.edgePerm, N_EDGE_PERM);
+	validateCoordinate("edgeOrient", state.edgeOrient, N_EDGE_ORIENT);
+	validateCoordinate("cornerOrient", state.cornerOrient, N_CORNER_ORIENT);
+	validateCoordinate("tips", state.tips, N_TIPS);
+};
+const validateLength = (length) => {
+	if (!Number.isSafeInteger(length) || length < 0 || length > MAX_LENGTH) throw new RangeError(`${ERROR_PREFIX}: Pyraminx solve length must be an integer from 0 to ${MAX_LENGTH}`);
+};
+const nextCoordinate = (random, coordinateName, maxExclusive) => {
+	const coordinate = random.nextInt(maxExclusive);
+	validateCoordinate(coordinateName, coordinate, maxExclusive);
+	return coordinate;
+};
+const unsolvedTips = (tips) => {
+	let count = 0;
+	let remainingTips = tips;
+	while (remainingTips !== 0) {
+		if (remainingTips % 3 > 0) count += 1;
+		remainingTips = Math.floor(remainingTips / 3);
+	}
+	return count;
+};
+const search = ({ edgePerm, edgeOrient, cornerOrient, depth, length, lastMove, solution, random, tables }) => {
+	if (length === 0) return edgePerm === 0 && edgeOrient === 0 && cornerOrient === 0;
+	if (tables.prunPerm[edgePerm] > length || tables.prunOrient[cornerOrient * N_EDGE_ORIENT + edgeOrient] > length) return false;
+	const randomOffset = nextCoordinate(random, "searchMoveOffset", N_MOVES);
+	for (let move = 0; move < N_MOVES; move += 1) {
+		const randomMove = (move + randomOffset) % N_MOVES;
+		if (Math.floor(randomMove / 2) === Math.floor(lastMove / 2)) continue;
+		if (search({
+			edgePerm: tables.moveEdgePerm[edgePerm][randomMove],
+			edgeOrient: tables.moveEdgeOrient[edgeOrient][randomMove],
+			cornerOrient: tables.moveCornerOrient[cornerOrient][randomMove],
+			depth: depth + 1,
+			length: length - 1,
+			lastMove: randomMove,
+			solution,
+			random,
+			tables
+		})) {
+			solution[depth] = randomMove;
+			return true;
+		}
+	}
+	return false;
+};
+const formatSolution = (state, solution, length, inverse) => {
+	const moves = [];
+	if (inverse) for (let index = length - 1; index >= 0; index -= 1) moves.push(INVERSE_MOVE_TO_STRING[solution[index]]);
+	else for (let index = 0; index < length; index += 1) moves.push(MOVE_TO_STRING[solution[index]]);
+	const tips = Array.from({ length: 4 }, () => 0);
+	unpackCornerOrient(state.tips, tips);
+	for (let tip = 0; tip < 4; tip += 1) {
+		const direction = tips[tip];
+		if (direction === 0) continue;
+		const tipMove = tip * 2 + direction - 1;
+		moves.push(inverse ? TIP_TO_STRING[tipMove] : INVERSE_TIP_TO_STRING[tipMove]);
+	}
+	return moves.join(" ");
+};
+var PyraminxSolver = class {
+	randomState(random) {
+		const tables = getTables();
+		let edgePerm;
+		for (let attempt = 0; attempt < MAX_EDGE_PERM_ATTEMPTS; attempt += 1) {
+			const sampledEdgePerm = nextCoordinate(random, "edgePerm", N_EDGE_PERM);
+			if (tables.prunPerm[sampledEdgePerm] === -1) continue;
+			edgePerm = sampledEdgePerm;
+			break;
+		}
+		if (edgePerm === void 0) throw new Error(`${ERROR_PREFIX}: could not sample a reachable Pyraminx edge permutation after ${MAX_EDGE_PERM_ATTEMPTS} attempts`);
+		const state = {
+			edgePerm,
+			edgeOrient: nextCoordinate(random, "edgeOrient", N_EDGE_ORIENT),
+			cornerOrient: nextCoordinate(random, "cornerOrient", N_CORNER_ORIENT),
+			tips: nextCoordinate(random, "tips", N_TIPS)
+		};
+		validateState(state);
+		return state;
+	}
+	solveIn(state, maxLength, includingTips, random) {
+		return this.solve(state, maxLength, false, false, includingTips, random);
+	}
+	generateExactly(state, length, includingTips, random) {
+		const scramble = this.solve(state, length, true, true, includingTips, random);
+		if (scramble === null) throw new Error(`${ERROR_PREFIX}: could not generate a Pyraminx scramble exactly ${length} moves long`);
+		return scramble;
+	}
+	solve(state, desiredLength, exactLength, inverse, includingTips, random) {
+		validateState(state);
+		validateLength(desiredLength);
+		const mainMoveDesiredLength = includingTips ? desiredLength - unsolvedTips(state.tips) : desiredLength;
+		if (mainMoveDesiredLength < 0) return null;
+		const tables = getTables();
+		const solution = Array.from({ length: MAX_LENGTH }, () => 0);
+		let length = exactLength ? mainMoveDesiredLength : 0;
+		while (length <= mainMoveDesiredLength) {
+			if (search({
+				edgePerm: state.edgePerm,
+				edgeOrient: state.edgeOrient,
+				cornerOrient: state.cornerOrient,
+				depth: 0,
+				length,
+				lastMove: 42,
+				solution,
+				random,
+				tables
+			})) return formatSolution(state, solution, length, inverse);
+			length += 1;
+		}
+		return null;
+	}
+};
+//#endregion
+export { PyraminxSolver };

package/dist/scramble-core/src/solvers/skewb-solver.d.mts

@@ -0,0 +1,15 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/solvers/skewb-solver.d.ts
+interface SkewbSolverState {
+  readonly perm: number;
+  readonly twst: number;
+}
+declare class SkewbSolver {
+  randomState(random: RandomSource): SkewbSolverState;
+  solveIn(state: SkewbSolverState, length: number, random: RandomSource): string | null;
+  generateExactly(state: SkewbSolverState, length: number, random: RandomSource): string;
+  private solve;
+}
+//#endregion
+export { SkewbSolver, SkewbSolverState };