@wodzik/cubecore 0.1.0

package/cfop/caseData.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OLL and PLL cases as data — numbering, names and groups as on
+ * speedcubedb.com (OLL 1–57, PLL Aa…Z). `alg` is one standard algorithm per
+ * case (speedcubedb's main one); recognition is built from it, so any
+ * algorithm for the case works with the recogniser.
+ */
+export interface LastLayerCase {
+    /** "OLL 27", "T"… */
+    id: string;
+    /** speedcubedb group ("Dot Case", "Adj Swap"…). */
+    group: string;
+    /** A standard algorithm (from the case, as held, to oriented / solved up to AUF). */
+    alg: string;
+}
+export declare const OLL_CASES: readonly LastLayerCase[];
+export declare const PLL_CASES: readonly LastLayerCase[];

package/cfop/caseData.js

@@ -0,0 +1,88 @@
+/**
+ * OLL and PLL cases as data — numbering, names and groups as on
+ * speedcubedb.com (OLL 1–57, PLL Aa…Z). `alg` is one standard algorithm per
+ * case (speedcubedb's main one); recognition is built from it, so any
+ * algorithm for the case works with the recogniser.
+ */
+export const OLL_CASES = [
+    { id: "OLL 1", group: "Dot Case", alg: "R U2 R2 F R F' U2 R' F R F'" },
+    { id: "OLL 2", group: "Dot Case", alg: "R U' R2 D' r U r' D R2 U R'" },
+    { id: "OLL 3", group: "Dot Case", alg: "R' F2 R2 U2 R' F R U2 R2 F2 R" },
+    { id: "OLL 4", group: "Dot Case", alg: "R' F2 R2 U2 R' F' R U2 R2 F2 R" },
+    { id: "OLL 5", group: "Square Shapes", alg: "r' U2 R U R' U r" },
+    { id: "OLL 6", group: "Square Shapes", alg: "r U2 R' U' R U' r'" },
+    { id: "OLL 7", group: "Lightning Shapes", alg: "r U R' U R U2 r'" },
+    { id: "OLL 8", group: "Lightning Shapes", alg: "r' U' R U' R' U2 r" },
+    { id: "OLL 9", group: "Fish Shapes", alg: "R U R' U' R' F R2 U R' U' F'" },
+    { id: "OLL 10", group: "Fish Shapes", alg: "R U R' U R' F R F' R U2 R'" },
+    { id: "OLL 11", group: "Lightning Shapes", alg: "r' R2 U R' U R U2 R' U M'" },
+    { id: "OLL 12", group: "Lightning Shapes", alg: "M' R' U' R U' R' U2 R U' M" },
+    { id: "OLL 13", group: "Knight Move Shapes", alg: "F U R U2 R' U' R U R' F'" },
+    { id: "OLL 14", group: "Knight Move Shapes", alg: "R' F R U R' F' R F U' F'" },
+    { id: "OLL 15", group: "Knight Move Shapes", alg: "r' U' r R' U' R U r' U r" },
+    { id: "OLL 16", group: "Knight Move Shapes", alg: "r U r' R U R' U' r U' r'" },
+    { id: "OLL 17", group: "Dot Case", alg: "R U R' U R' F R F' U2 R' F R F'" },
+    { id: "OLL 18", group: "Dot Case", alg: "R U2 R2 F R F' U2 M' U R U' r'" },
+    { id: "OLL 19", group: "Dot Case", alg: "S' R U R' S U' R' F R F'" },
+    { id: "OLL 20", group: "Dot Case", alg: "r U R' U' M2 U R U' R' U' M'" },
+    { id: "OLL 21", group: "OCLL", alg: "R U R' U R U' R' U R U2 R'" },
+    { id: "OLL 22", group: "OCLL", alg: "R U2 R2 U' R2 U' R2 U2 R" },
+    { id: "OLL 23", group: "OCLL", alg: "R2 D R' U2 R D' R' U2 R'" },
+    { id: "OLL 24", group: "OCLL", alg: "r U R' U' r' F R F'" },
+    { id: "OLL 25", group: "OCLL", alg: "R U2 R D R' U2 R D' R2" },
+    { id: "OLL 26", group: "OCLL", alg: "R U2 R' U' R U' R'" },
+    { id: "OLL 27", group: "OCLL", alg: "R U R' U R U2 R'" },
+    { id: "OLL 28", group: "All Corners Oriented", alg: "r U R' U' M U R U' R'" },
+    { id: "OLL 29", group: "Awkward Shapes", alg: "r2 D' r U r' D r2 U' r' U' r" },
+    { id: "OLL 30", group: "Awkward Shapes", alg: "r' D' r U' r' D r2 U' r' U r U r'" },
+    { id: "OLL 31", group: "P Shapes", alg: "R' U' F U R U' R' F' R" },
+    { id: "OLL 32", group: "P Shapes", alg: "S R U R' U' R' F R f'" },
+    { id: "OLL 33", group: "T Shapes", alg: "R U R' U' R' F R F'" },
+    { id: "OLL 34", group: "C Shapes", alg: "f R f' U' r' U' R U M'" },
+    { id: "OLL 35", group: "Fish Shapes", alg: "R U2 R2 F R F' R U2 R'" },
+    { id: "OLL 36", group: "W Shapes", alg: "R U R2 F' U' F U R2 U2 R'" },
+    { id: "OLL 37", group: "Fish Shapes", alg: "F R' F' R U R U' R'" },
+    { id: "OLL 38", group: "W Shapes", alg: "R U R' U R U' R' U' R' F R F'" },
+    { id: "OLL 39", group: "Lightning Shapes", alg: "R U R' F' U' F U R U2 R'" },
+    { id: "OLL 40", group: "Lightning Shapes", alg: "R' F R U R' U' F' U R" },
+    { id: "OLL 41", group: "Awkward Shapes", alg: "R U R' U R U2 R' F R U R' U' F'" },
+    { id: "OLL 42", group: "Awkward Shapes", alg: "R' U' R U' R' U2 R F R U R' U' F'" },
+    { id: "OLL 43", group: "P Shapes", alg: "R' U' F' U F R" },
+    { id: "OLL 44", group: "P Shapes", alg: "f R U R' U' f'" },
+    { id: "OLL 45", group: "T Shapes", alg: "F R U R' U' F'" },
+    { id: "OLL 46", group: "C Shapes", alg: "R' U' R' F R F' U R" },
+    { id: "OLL 47", group: "L Shapes", alg: "F R' F' R U2 R U' R' U R U2 R'" },
+    { id: "OLL 48", group: "L Shapes", alg: "F R U R' U' R U R' U' F'" },
+    { id: "OLL 49", group: "L Shapes", alg: "r U' r2 U r2 U r2 U' r" },
+    { id: "OLL 50", group: "L Shapes", alg: "r' U r2 U' r2 U' r2 U r'" },
+    { id: "OLL 51", group: "Line Shapes", alg: "F U R U' R' U R U' R' F'" },
+    { id: "OLL 52", group: "Line Shapes", alg: "R' F' U' F U' R U R' U R" },
+    { id: "OLL 53", group: "L Shapes", alg: "r' U' R U' R' U R U' R' U2 r" },
+    { id: "OLL 54", group: "L Shapes", alg: "r U R' U R U' R' U R U2 r'" },
+    { id: "OLL 55", group: "Line Shapes", alg: "R' F U R U' R2 F' R2 U R' U' R" },
+    { id: "OLL 56", group: "Line Shapes", alg: "r U r' U R U' R' U R U' R' r U' r'" },
+    { id: "OLL 57", group: "All Corners Oriented", alg: "R U R' U' M' U R U' r'" },
+];
+export const PLL_CASES = [
+    { id: "Aa", group: "Adj Swap", alg: "x R' U R' D2 R U' R' D2 R2 x'" },
+    { id: "Ab", group: "Adj Swap", alg: "x R2 D2 R U R' D2 R U' R x'" },
+    { id: "E", group: "Opp Swap", alg: "x' R U' R' D R U R' D' R U R' D R U' R' D' x" },
+    { id: "F", group: "Adj Swap", alg: "R' U' F' R U R' U' R' F R2 U' R' U' R U R' U R" },
+    { id: "Ga", group: "Adj Swap", alg: "R2 U R' U R' U' R U' R2 D U' R' U R D'" },
+    { id: "Gb", group: "Adj Swap", alg: "D R' U' R U D' R2 U R' U R U' R U' R2" },
+    { id: "Gc", group: "Adj Swap", alg: "R2 U' R U' R U R' U R2 D' U R U' R' D" },
+    { id: "Gd", group: "Adj Swap", alg: "R U R' U' D R2 U' R U' R' U R' U R2 D'" },
+    { id: "H", group: "EPLL", alg: "M2 U' M2 U2 M2 U' M2" },
+    { id: "Ja", group: "Adj Swap", alg: "x R2 F R F' R U2 r' U r U2 x'" },
+    { id: "Jb", group: "Adj Swap", alg: "R U R' F' R U R' U' R' F R2 U' R'" },
+    { id: "Na", group: "Opp Swap", alg: "R U R' U R U R' F' R U R' U' R' F R2 U' R' U2 R U' R'" },
+    { id: "Nb", group: "Opp Swap", alg: "R' U R U' R' F' U' F R U R' F R' F' R U' R" },
+    { id: "Ra", group: "Adj Swap", alg: "R U' R' U' R U R D R' U' R D' R' U2 R'" },
+    { id: "Rb", group: "Adj Swap", alg: "R' U2 R U2 R' F R U R' U' R' F' R2" },
+    { id: "T", group: "Adj Swap", alg: "R U R' U' R' F R2 U' R' U' R U R' F'" },
+    { id: "Ua", group: "EPLL", alg: "M2 U M U2 M' U M2" },
+    { id: "Ub", group: "EPLL", alg: "M2 U' M U2 M' U' M2" },
+    { id: "V", group: "Opp Swap", alg: "R' U R' U' R D' R' D R' U D' R2 U' R2 D R2" },
+    { id: "Y", group: "Opp Swap", alg: "F R U' R' U' R U R' F' R U R' U' R' F R F'" },
+    { id: "Z", group: "EPLL", alg: "M' U' M2 U' M2 U' M' U2 M2" },
+];

package/cfop/cases.d.ts

@@ -0,0 +1,42 @@
+/**
+ * OLL / PLL recognition — colour neutral, any colour scheme.
+ *
+ * Works on colours relative to the centres, like a solver looking at the
+ * cube: OLL is where the top colour faces on the eight last-layer pieces;
+ * PLL is the colours of the top rows on the four sides, relative to their
+ * centres. Both are compared up to the angle you look from (pre-AUF) and,
+ * for PLL, up to a final U turn. The patterns are built from the cases'
+ * algorithms (caseData.ts), so every pattern is exactly one case — the
+ * tests check all 216 orientations and 288 permutations.
+ *
+ *   recognizeLastLayer(cube.state)
+ *   // { face: "U", oll: { id: "OLL 27", preAuf: "U'" } | "skip", pll: null }   (null until OLL is done)
+ */
+import { type Face, type State } from "../core/index.js";
+export { OLL_CASES, PLL_CASES, type LastLayerCase } from "./caseData.js";
+export interface CaseMatch {
+    /** "OLL 27", "T"… */
+    id: string;
+    group: string;
+    /** The U turn before the case's algorithm, as the cube is held now ("" = none). */
+    preAuf: string;
+    alg: string;
+}
+/** The OLL case of a cube held with the last layer on U (F2L solved) — null for an OLL skip. */
+export declare function recognizeOll(s: State): CaseMatch | null;
+/** The PLL case of a cube held with the last layer on U (oriented) — null when it's solved up to AUF. */
+export declare function recognizePll(s: State): CaseMatch | null;
+export interface LastLayer {
+    /** Physical face the last layer is on. */
+    face: Face;
+    /** The OLL case, or "skip" (already oriented). */
+    oll: CaseMatch | "skip";
+    /** The PLL case once oriented ("skip": solved up to AUF); null while OLL isn't done. */
+    pll: CaseMatch | "skip" | null;
+}
+/**
+ * OLL and PLL of a cube with F2L solved on any face (colour neutral), or null
+ * if no F2L is solved. `preAuf` is said as the cube is held with the last
+ * layer on top and that frame's front in front.
+ */
+export declare function recognizeLastLayer(state: State): LastLayer | null;

package/cfop/cases.js

@@ -0,0 +1,116 @@
+/**
+ * OLL / PLL recognition — colour neutral, any colour scheme.
+ *
+ * Works on colours relative to the centres, like a solver looking at the
+ * cube: OLL is where the top colour faces on the eight last-layer pieces;
+ * PLL is the colours of the top rows on the four sides, relative to their
+ * centres. Both are compared up to the angle you look from (pre-AUF) and,
+ * for PLL, up to a final U turn. The patterns are built from the cases'
+ * algorithms (caseData.ts), so every pattern is exactly one case — the
+ * tests check all 216 orientations and 288 permutations.
+ *
+ *   recognizeLastLayer(cube.state)
+ *   // { face: "U", oll: { id: "OLL 27", preAuf: "U'" } | "skip", pll: null }   (null until OLL is done)
+ */
+import { CORNER_FACELETS, EDGE_FACELETS, FRAMES, applyMoves, colorAt, checks, invert, parseAlg, solvedState, view } from "../core/index.js";
+import { OLL_CASES, PLL_CASES } from "./caseData.js";
+export { OLL_CASES, PLL_CASES } from "./caseData.js";
+/** Last-layer pieces in turning order (index + 1 = the next one round the top): corners URF UFL ULB UBR, edges UF UL UB UR. */
+const LL_CORNERS = [0, 1, 2, 3].map((i) => CORNER_FACELETS[i]); // U sticker first, then clockwise
+const LL_EDGES = [1, 2, 3, 0].map((i) => EDGE_FACELETS[i]); // U sticker first
+/** Top rows of the side faces in the same turning order as the pieces (F, L, B, R), each left to right. */
+const SIDE_ROWS = [[18, 19, 20], [36, 37, 38], [45, 46, 47], [9, 10, 11]];
+const SIDE_CENTRES = [22, 40, 49, 13];
+const U_CENTRE = 4;
+const AUFS = ["", "U", "U2", "U'"];
+const shift = (a, k) => a.map((_, i) => a[(i + k) % a.length]);
+/** Where the top colour faces on each last-layer piece (corners 0–2 clockwise from U, edges 0–1), in turning order. */
+function orientation(s) {
+    const top = colorAt(s, U_CENTRE);
+    return {
+        corners: LL_CORNERS.map((fs) => fs.findIndex((f) => colorAt(s, f) === top)),
+        edges: LL_EDGES.map((fs) => fs.findIndex((f) => colorAt(s, f) === top)),
+    };
+}
+const ollRaw = (s) => {
+    const o = orientation(s);
+    return `${o.corners.join("")}|${o.edges.join("")}`;
+};
+/** The same up to the angle it's seen from. */
+const ollKey = (s) => {
+    const o = orientation(s);
+    return [0, 1, 2, 3].map((k) => `${shift(o.corners, k).join("")}|${shift(o.edges, k).join("")}`).sort()[0];
+};
+/** Each top-row sticker's colour as a step round the sides from its own face (0 = the face's centre colour). */
+function sideOffsets(s) {
+    const ring = SIDE_CENTRES.map((c) => colorAt(s, c));
+    return SIDE_ROWS.map((row, face) => row.map((f) => (ring.indexOf(colorAt(s, f)) - face + 4) % 4));
+}
+const pllText = (rows, add) => rows.map((r) => r.map((v) => (v + add) % 4).join("")).join("|");
+/** Up to a final U turn (all offsets move together). */
+const pllRaw = (s) => {
+    const rows = sideOffsets(s);
+    return [0, 1, 2, 3].map((a) => pllText(rows, a)).sort()[0];
+};
+/** …and up to the angle it's seen from. */
+const pllKey = (s) => {
+    const rows = sideOffsets(s);
+    return [0, 1, 2, 3].flatMap((k) => [0, 1, 2, 3].map((a) => pllText(shift(rows, k), a))).sort()[0];
+};
+function table(cases, key, raw) {
+    const map = new Map();
+    for (const kase of cases) {
+        const s = applyMoves(solvedState(), invert(parseAlg(kase.alg)));
+        const k = key(s);
+        if (map.has(k))
+            throw new Error(`${kase.id} looks like ${map.get(k).kase.id}`);
+        map.set(k, { kase, raw: raw(s) });
+    }
+    return map;
+}
+let ollTable = null;
+let pllTable = null;
+const SOLVED_OLL = ollKey(solvedState());
+const SOLVED_PLL = pllKey(solvedState());
+/** The OLL case of a cube held with the last layer on U (F2L solved) — null for an OLL skip. */
+export function recognizeOll(s) {
+    ollTable ??= table(OLL_CASES, ollKey, ollRaw);
+    const k = ollKey(s);
+    if (k === SOLVED_OLL)
+        return null;
+    const e = ollTable.get(k);
+    if (!e)
+        throw new Error("Not a last-layer orientation");
+    const preAuf = AUFS.find((a) => ollRaw(a ? applyMoves(s, a) : s) === e.raw) ?? "";
+    return { id: e.kase.id, group: e.kase.group, preAuf, alg: e.kase.alg };
+}
+/** The PLL case of a cube held with the last layer on U (oriented) — null when it's solved up to AUF. */
+export function recognizePll(s) {
+    pllTable ??= table(PLL_CASES, pllKey, pllRaw);
+    const k = pllKey(s);
+    if (k === SOLVED_PLL)
+        return null;
+    const e = pllTable.get(k);
+    if (!e)
+        throw new Error("Not a last-layer permutation");
+    const preAuf = AUFS.find((a) => pllRaw(a ? applyMoves(s, a) : s) === e.raw) ?? "";
+    return { id: e.kase.id, group: e.kase.group, preAuf, alg: e.kase.alg };
+}
+/** One frame per bottom face — which one has F2L solved tells where the last layer is. */
+const BY_BOTTOM = ["U", "R", "F", "D", "L", "B"].map((d) => FRAMES.find((f) => f.face.D === d));
+/**
+ * OLL and PLL of a cube with F2L solved on any face (colour neutral), or null
+ * if no F2L is solved. `preAuf` is said as the cube is held with the last
+ * layer on top and that frame's front in front.
+ */
+export function recognizeLastLayer(state) {
+    for (const frame of BY_BOTTOM) {
+        const s = view(state, frame);
+        if (!checks.f2lSolved(s))
+            continue;
+        const oll = recognizeOll(s);
+        const pll = oll ? null : recognizePll(s);
+        return { face: frame.face.U, oll: oll ?? "skip", pll: oll ? null : (pll ?? "skip") };
+    }
+    return null;
+}

package/cfop/f2l.d.ts

@@ -0,0 +1,28 @@
+/**
+ * F2L case recognition — which of the 41 standard cases a slot's pair is
+ * in, colour neutral and scheme-free (colours relative to the centres), for
+ * a cube held with the cross on D. The pair counts when its corner and edge
+ * are in the top layer or in their own slot (a piece stuck in another slot
+ * is not one of the 41 — "advanced F2L").
+ *
+ *   recognizeF2L(state, "FR")   // { id: "F2L 7", group: "Connected Pairs", preAuf: "U'", alg: "U' R U2 R' U2 R U' R'" } | "solved" | null
+ */
+import { type State } from "../core/index.js";
+import type { F2LSlot } from "./slots.js";
+export { F2L_CASES, type F2LCase } from "./f2lData.js";
+export interface F2LMatch {
+    id: string;
+    group: string;
+    slot: F2LSlot;
+    /** The U turn before the algorithm, as the cube is held (cross on D). */
+    preAuf: string;
+    alg: string;
+}
+/** Is the slot's pair in the top layer or its own slot (one of the 41 cases, or solved)? */
+export declare function isStandardF2L(s: State, slot: F2LSlot): boolean;
+/**
+ * The F2L case of `slot` for a cube held with the cross on D: the case,
+ * "solved" (pair in place), or null when a piece is in another slot
+ * (not one of the 41).
+ */
+export declare function recognizeF2L(s: State, slot: F2LSlot): F2LMatch | "solved" | null;

package/cfop/f2l.js

@@ -0,0 +1,88 @@
+/**
+ * F2L case recognition — which of the 41 standard cases a slot's pair is
+ * in, colour neutral and scheme-free (colours relative to the centres), for
+ * a cube held with the cross on D. The pair counts when its corner and edge
+ * are in the top layer or in their own slot (a piece stuck in another slot
+ * is not one of the 41 — "advanced F2L").
+ *
+ *   recognizeF2L(state, "FR")   // { id: "F2L 7", group: "Connected Pairs", preAuf: "U'", alg: "U' R U2 R' U2 R U' R'" } | "solved" | null
+ */
+import { CORNER_FACELETS, EDGE_FACELETS, applyMoves, colorAt, invert, parseAlg, solvedState } from "../core/index.js";
+import { F2L_CASES } from "./f2lData.js";
+export { F2L_CASES } from "./f2lData.js";
+const AUFS = ["", "U", "U2", "U'"];
+const CENTRE = { U: 4, R: 13, F: 22, D: 31, L: 40, B: 49 };
+const SIDES = { FR: ["F", "R"], FL: ["F", "L"], BL: ["B", "L"], BR: ["B", "R"] };
+/** Kociemba positions of each slot's corner and edge (DFR / FR…). */
+const HOME = {
+    FR: { corner: 4, edge: 8 },
+    FL: { corner: 5, edge: 9 },
+    BL: { corner: 6, edge: 10 },
+    BR: { corner: 7, edge: 11 },
+};
+const TOP_CORNERS = [0, 1, 2, 3], TOP_EDGES = [0, 1, 2, 3];
+/** Where the slot's pair is (Kociemba positions) and how it's turned, read by colour. */
+function pairOf(s, slot) {
+    const bottom = colorAt(s, CENTRE.D);
+    const [a, b] = SIDES[slot].map((f) => colorAt(s, CENTRE[f]));
+    const corner = CORNER_FACELETS.findIndex((fs) => [bottom, a, b].every((c) => fs.some((f) => colorAt(s, f) === c)));
+    const edge = EDGE_FACELETS.findIndex((fs) => [a, b].every((c) => fs.some((f) => colorAt(s, f) === c)));
+    if (corner < 0 || edge < 0)
+        return null;
+    return {
+        corner,
+        cornerOri: CORNER_FACELETS[corner].findIndex((f) => colorAt(s, f) === bottom),
+        edge,
+        edgeOri: EDGE_FACELETS[edge].findIndex((f) => colorAt(s, f) === a),
+    };
+}
+const pairText = (p) => `${p.corner}.${p.cornerOri}|${p.edge}.${p.edgeOri}`;
+/** Up to the angle (a U turn before the algorithm). */
+function key(s, slot) {
+    const texts = AUFS.map((u) => pairOf(u ? applyMoves(s, u) : s, slot)).map((p) => (p ? pairText(p) : ""));
+    return texts.includes("") ? null : texts.sort()[0];
+}
+const tables = new Map();
+function table(slot) {
+    let t = tables.get(slot);
+    if (t)
+        return t;
+    t = new Map();
+    for (const kase of F2L_CASES) {
+        const s = applyMoves(solvedState(), invert(parseAlg(kase.algs[slot])));
+        const k = key(s, slot);
+        if (t.has(k))
+            throw new Error(`${slot} ${kase.id} looks like ${t.get(k).kase.id}`);
+        t.set(k, { kase, raw: pairText(pairOf(s, slot)) });
+    }
+    tables.set(slot, t);
+    return t;
+}
+/** Is the slot's pair in the top layer or its own slot (one of the 41 cases, or solved)? */
+export function isStandardF2L(s, slot) {
+    const p = pairOf(s, slot);
+    return !!p && (TOP_CORNERS.includes(p.corner) || p.corner === HOME[slot].corner) && (TOP_EDGES.includes(p.edge) || p.edge === HOME[slot].edge);
+}
+/**
+ * The F2L case of `slot` for a cube held with the cross on D: the case,
+ * "solved" (pair in place), or null when a piece is in another slot
+ * (not one of the 41).
+ */
+export function recognizeF2L(s, slot) {
+    const p = pairOf(s, slot);
+    if (!p)
+        return null;
+    if (p.corner === HOME[slot].corner && p.cornerOri === 0 && p.edge === HOME[slot].edge && p.edgeOri === 0)
+        return "solved";
+    if (!isStandardF2L(s, slot))
+        return null;
+    const k = key(s, slot);
+    const e = k ? table(slot).get(k) : undefined;
+    if (!e)
+        return null;
+    const preAuf = AUFS.find((u) => {
+        const q = pairOf(u ? applyMoves(s, u) : s, slot);
+        return q !== null && pairText(q) === e.raw;
+    }) ?? "";
+    return { id: e.kase.id, group: e.kase.group, slot, preAuf, alg: e.kase.algs[slot] };
+}

package/cfop/f2lData.d.ts

@@ -0,0 +1,15 @@
+/**
+ * F2L cases as data — numbering and groups as on speedcubedb.com (F2L 1–41:
+ * the pair in the top layer or its own slot), one standard algorithm per
+ * case for each slot (speedcubedb's main one). Recognition is built from
+ * them, so any algorithm for the case works.
+ */
+import type { F2LSlot } from "./slots.js";
+export interface F2LCase {
+    /** "F2L 1"… */
+    id: string;
+    group: string;
+    /** An algorithm per slot (cube held with the cross on D). */
+    algs: Readonly<Record<F2LSlot, string>>;
+}
+export declare const F2L_CASES: readonly F2LCase[];

package/cfop/f2lData.js

@@ -0,0 +1,49 @@
+/**
+ * F2L cases as data — numbering and groups as on speedcubedb.com (F2L 1–41:
+ * the pair in the top layer or its own slot), one standard algorithm per
+ * case for each slot (speedcubedb's main one). Recognition is built from
+ * them, so any algorithm for the case works.
+ */
+export const F2L_CASES = [
+    { id: "F2L 1", group: "Free Pairs", algs: { FR: "U R U' R'", FL: "F' r U r'", BL: "U L U' L'", BR: "U f R' f'" } },
+    { id: "F2L 2", group: "Free Pairs", algs: { FR: "F R' F' R", FL: "U' L' U L", BL: "U' f' L f", BR: "U' R' U R" } },
+    { id: "F2L 3", group: "Free Pairs", algs: { FR: "F' U' F", FL: "L' U' L", BL: "y R' U' R y'", BR: "R' U' R" } },
+    { id: "F2L 4", group: "Free Pairs", algs: { FR: "R U R'", FL: "F U F'", BL: "L U L'", BR: "f R f'" } },
+    { id: "F2L 5", group: "Disconnected Pairs", algs: { FR: "U' R U R' U2 R U' R'", FL: "U R' F r U' r' F' R", BL: "U' L U L' U2 L U' L'", BR: "U' R' F R U R' U' F' R" } },
+    { id: "F2L 6", group: "Disconnected Pairs", algs: { FR: "U' r U' R' U R U r'", FL: "U L' U' L U2 L' U L", BL: "U r U' r' U' L U F L'", BR: "U R' U' R U2 R' U R" } },
+    { id: "F2L 7", group: "Disconnected Pairs", algs: { FR: "U' R U2 R' U' R U2 R'", FL: "F U R U2 R' U F'", BL: "U' L U2 L' U2 L U' L'", BR: "r U2 R2 U' R2 U' r'" } },
+    { id: "F2L 8", group: "Disconnected Pairs", algs: { FR: "d R' U2 R U R' U2 R y", FL: "U L' U2 L U L' U2 L", BL: "l' U2 L2 U L2 U l", BR: "U R' U2 R U R' U2 R" } },
+    { id: "F2L 9", group: "Disconnected Pairs", algs: { FR: "U' R U' R' U F' U' F", FL: "U L' U' L U' L' U' L", BL: "y U R' U' R U' R' U' R y'", BR: "U R' U' R U' R' U' R" } },
+    { id: "F2L 10", group: "Disconnected Pairs", algs: { FR: "U' R U R' U R U R'", FL: "U L' U L U' F U F'", BL: "U' L U L' U L U L'", BR: "U R' U R U' f R f'" } },
+    { id: "F2L 11", group: "Connected Pairs", algs: { FR: "U' R U2 R' U F' U' F", FL: "L' U L U' L' U L U2 L' U L", BL: "U' L U2 L' U f' L' f", BR: "R' U R U' R' U R U2 R' U R" } },
+    { id: "F2L 12", group: "Connected Pairs", algs: { FR: "R U' R' U R U' R' U2 R U' R'", FL: "U L' U2 L U' F U F'", BL: "L' U2 L2 U L2 U L", BR: "U R' U2 R U' f R f'" } },
+    { id: "F2L 13", group: "Connected Pairs", algs: { FR: "y' U R' U R U' R' U' R y", FL: "U L' U L U' L' U' L", BL: "d L' U L U' L' U' L y", BR: "U R' U R U' R' U' R" } },
+    { id: "F2L 14", group: "Connected Pairs", algs: { FR: "U' R U' R' U R U R'", FL: "d' L U' L' U L U L' y'", BL: "U' L U' L' U L U L'", BR: "y U' R U' R' U R U R' y'" } },
+    { id: "F2L 15", group: "Connected Pairs", algs: { FR: "R' D' R U' R' D R U R U' R'", FL: "L' U L U2 F U F'", BL: "L U L' U2 L U' L' U L U' L'", BR: "R' U R U2 f R f'" } },
+    { id: "F2L 16", group: "Connected Pairs", algs: { FR: "R U' R' U2 F' U' F", FL: "F U' R U' R' U2 F'", BL: "L U' L' U2 f' L' f", BR: "R' U' R U2 R' U R U' R' U R" } },
+    { id: "F2L 17", group: "Connected Pairs", algs: { FR: "R U2 R' U' R U R'", FL: "y L U2 L' U' L U L' y'", BL: "L U2 L' U' L U L'", BR: "y' L U2 L' U' L U L' y" } },
+    { id: "F2L 18", group: "Connected Pairs", algs: { FR: "y' R' U2 R U R' U' R y", FL: "L' U2 L U L' U' L", BL: "y R' U2 R U R' U' R y'", BR: "R' U2 R U R' U' R" } },
+    { id: "F2L 19", group: "Disconnected Pairs", algs: { FR: "U R U2 R' U R U' R'", FL: "U L' U L2 F' L' F L' U L", BL: "U L U2 L' U L U' L'", BR: "y U R U2 R' U R U' R' y'" } },
+    { id: "F2L 20", group: "Disconnected Pairs", algs: { FR: "y' U' R' U2 R U' R' U R y", FL: "U' L' U2 L U' L' U L", BL: "y U' R' U2 R U' R' U R y'", BR: "U' R' U2 R U' R' U R" } },
+    { id: "F2L 21", group: "Disconnected Pairs", algs: { FR: "U2 R U R' U R U' R'", FL: "l' U l U2 l' U' l", BL: "L U' L' U2 L U L'", BR: "r' U r U2 r' U' r" } },
+    { id: "F2L 22", group: "Disconnected Pairs", algs: { FR: "r U' r' U2 r U r'", FL: "L' U L U2 L' U' L", BL: "l U' l' U2 l U l'", BR: "R' U R U2 R' U' R" } },
+    { id: "F2L 23", group: "Connected Pairs", algs: { FR: "U R U' R' U' R U' R' U R U' R'", FL: "F' U' L' U L F L' U L", BL: "U L U' L' U' L U' L' U L U' L'", BR: "U R' F R' F' R2 U' R' U R" } },
+    { id: "F2L 24", group: "Connected Pairs", algs: { FR: "F U R U' R' F' R U' R'", FL: "U' L' U L U L' U L U' L' U L", BL: "U2 r U R' U R U2 B r'", BR: "R' U' R U2 R' U' R U R' U' R" } },
+    { id: "F2L 25", group: "Corner In Slot", algs: { FR: "U' R' F R F' R U R'", FL: "U' L' U L F' r U r'", BL: "L U' L' U' L U' L' U L U L'", BR: "U' R' U M U' R U M'" } },
+    { id: "F2L 26", group: "Corner In Slot", algs: { FR: "U R U' R' F R' F' R", FL: "r U r' U' r' F r F'", BL: "L S L' U L S' L'", BR: "U f R f' U' R' U' R" } },
+    { id: "F2L 27", group: "Corner In Slot", algs: { FR: "R U' R' U R U' R'", FL: "L' U' L U F' r U r'", BL: "L U' L' U L U' L'", BR: "R' U2 R' F R F' R" } },
+    { id: "F2L 28", group: "Corner In Slot", algs: { FR: "R U R' U' F R' F' R", FL: "L' U L U' L' U L", BL: "L U2 L F' L' F L'", BR: "R' U R U' R' U R" } },
+    { id: "F2L 29", group: "Corner In Slot", algs: { FR: "R' F R F' U R U' R'", FL: "L' U' L U L' U' L", BL: "y R' U' R U R' U' R y'", BR: "R' U' R U R' U' R" } },
+    { id: "F2L 30", group: "Corner In Slot", algs: { FR: "R U R' U' R U R'", FL: "L F' L' F U' L' U L", BL: "L U L' U' L U L'", BR: "y' L U L' U' L U L' y" } },
+    { id: "F2L 31", group: "Edge In Slot", algs: { FR: "U' R' F R F' R U' R'", FL: "U L F' L' F L' U L", BL: "L U' L F' L' F L'", BR: "R' U R' F R F' R" } },
+    { id: "F2L 32", group: "Edge In Slot", algs: { FR: "U R U' R' U R U' R' U R U' R'", FL: "U' L' U L U' L' U L U' L' U L", BL: "L U L' U' L U L' U' L U L'", BR: "U' R' U R U' R' U R U' R' U R" } },
+    { id: "F2L 33", group: "Edge In Slot", algs: { FR: "U' R U' R' U2 R U' R'", FL: "R' D R U' R' D' R", BL: "U' L U' L' U2 L U' L'", BR: "U' R D R' U R D' R'" } },
+    { id: "F2L 34", group: "Edge In Slot", algs: { FR: "U R U R' U2 R U R'", FL: "U L' U L U2 L' U L", BL: "U L U L' U2 L U L'", BR: "U R' U R U R' U2 R" } },
+    { id: "F2L 35", group: "Edge In Slot", algs: { FR: "U' R U R' U F' U' F", FL: "U2 F U F' U' L' U L", BL: "U' L U L' U f' L' f", BR: "U' f R f' U R' U' R" } },
+    { id: "F2L 36", group: "Edge In Slot", algs: { FR: "U F' U' F U' R U R'", FL: "U L' U' L d' L U L' y'", BL: "U f' L' f U' L U L'", BR: "U R' U' R U' f R f'" } },
+    { id: "F2L 37", group: "Pieces In Slot", algs: { FR: "R2 U2 F R2 F' U2 R' U R'", FL: "L2 U2 F' L2 F U2 L U' L", BL: "L U' L' l' U2 L2 U L2 U l", BR: "R' U R r U2 R2 U' R2 U' r'" } },
+    { id: "F2L 38", group: "Pieces In Slot", algs: { FR: "R U' R' U' R U R' U2 R U' R'", FL: "L' U L U' L' U2 L U' L' U L", BL: "L U L' U' L U2 L' U' L U L'", BR: "R' U' R U2 R' U R U' R' U' R" } },
+    { id: "F2L 39", group: "Pieces In Slot", algs: { FR: "R U' R' U R U2 R' U R U' R'", FL: "L' U' L U L' U2 L U L' U' L", BL: "L U L' U2 L U' L' U L U L'", BR: "R' U' R U R' U2 R U R' U' R" } },
+    { id: "F2L 40", group: "Pieces In Slot", algs: { FR: "r U' r' U2 r U r' R U R'", FL: "L' U L F R U2 R' F'", BL: "l U' l' U2 l U l' L U L'", BR: "R' U R r' U r U2 r' U' r" } },
+    { id: "F2L 41", group: "Pieces In Slot", algs: { FR: "R U' R' r U' r' U2 r U r'", FL: "l' U l U2 l' U' l L' U' L", BL: "f' L f U' L U L' U L U L'", BR: "r' U r U2 r' U' r R' U' R" } },
+];

package/cfop/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * CFOP — cross, F2L (four pairs, any order), OLL, PLL, AUF — and its masks.
+ * Built only from @cubecore/core check primitives, so it is colour and
+ * orientation neutral: the cross can be on any face, in any colour scheme.
+ *
+ * Later here: OLL / PLL / COLL case recognition and alg sets as data.
+ */
+import { type Frame, type Mask, type MaskRule, type Method, type Stage, type StageDef } from "../core/index.js";
+export declare const CFOP: Method;
+export type CfopMask = "cross" | "f2l" | "oll" | "pll" | "coll" | "ocll" | "ell" | "cll" | "ls" | "els" | "cls" | "vls" | "zbls" | "epll" | "cpll" | "zbll";
+export declare const CFOP_MASKS: Record<CfopMask, MaskRule>;
+/** A CFOP mask for a cube held in `frame` (e.g. the frame the tracker found the cross in). */
+export declare const cfopMask: (name: CfopMask, frame?: Frame) => Mask;
+import type { F2LSlot } from "./slots.js";
+export type { F2LSlot } from "./slots.js";
+/**
+ * CFOP trainer stages (canonical: cross on D). Each is a StageDef — plain
+ * data; `stageSolver(def)` answers distance / optimal solutions / next moves
+ * and `stageScramble({ stage: def, length })` draws a case at an exact level.
+ */
+export declare const CFOP_TRAINERS: {
+    readonly cross: () => StageDef;
+    readonly xcross: (slot?: F2LSlot) => StageDef;
+    /** Two slots: adjacent (FR + FL…) or opposite (FR + BL…). */
+    readonly xxcross: (a?: F2LSlot, b?: F2LSlot) => StageDef;
+    /**
+     * Free pair: cross solved and the slot's pair FORMED, one standard insert
+     * away — the inserted state or any of the 4 extractions × 4 AUFs (17 goal
+     * states, as in act's pairing trainer).
+     */
+    readonly pair: (slot?: F2LSlot) => StageDef;
+};
+export * from "./cases.js";
+export * from "./f2l.js";
+/**
+ * Last-layer stages that also say which case came up: OLL gets the OLL case
+ * after F2L ("OLL 27", "OLL skip"), PLL the PLL case after OLL ("T", "PLL
+ * skip") — StageBoundary.case, MethodTracker.current.case. ZZ / Petrus can
+ * use the same.
+ */
+export declare function withLastLayerCases(stages: readonly Stage[]): Stage[];

package/cfop/index.js

@@ -0,0 +1,110 @@
+/**
+ * CFOP — cross, F2L (four pairs, any order), OLL, PLL, AUF — and its masks.
+ * Built only from @cubecore/core check primitives, so it is colour and
+ * orientation neutral: the cross can be on any face, in any colour scheme.
+ *
+ * Later here: OLL / PLL / COLL case recognition and alg sets as data.
+ */
+import { IDENTITY_FRAME, LAST_LAYER_STAGES, PIECE, buildMask, checks as C, checks, countedStages } from "../core/index.js";
+import { recognizeOll, recognizePll } from "./cases.js";
+export const CFOP = {
+    id: "cfop",
+    name: "CFOP",
+    stages: [
+        { id: "cross", label: "Cross", done: C.crossSolved },
+        ...countedStages("f2l", "F2L", C.solvedPairs, C.crossSolved),
+        ...withLastLayerCases(LAST_LAYER_STAGES),
+    ],
+};
+export const CFOP_MASKS = {
+    cross: (f, c) => (c.kind === "center" || (c.kind === "edge" && c.pos[1] === -1) ? "regular" : "ignored"),
+    f2l: (f, c) => (c.pos[1] <= 0 || c.kind === "center" ? "regular" : "ignored"),
+    // Orientation: last-layer pieces show only their top-facing colour; centres stay in colour.
+    oll: (f, c) => (c.kind === "center" ? "regular" : lastLayer(c) ? (f.face === "U" ? "regular" : "ignored") : "dim"),
+    // Permutation: everything in colour, the first two layers dimmed.
+    pll: (f, c) => (lastLayer(c) || c.kind === "center" ? "regular" : "dim"),
+    coll: (f, c) => (c.kind === "center" ? "regular" : lastLayer(c) ? (c.kind === "corner" || f.face === "U" ? "regular" : "ignored") : "dim"),
+    ocll: (f, c) => (c.kind === "center" ? "regular" : lastLayer(c) ? (c.kind === "corner" && f.face === "U" ? "regular" : "ignored") : "dim"),
+    cll: (f, c) => (c.kind === "center" ? "regular" : lastLayer(c) ? (c.kind === "corner" ? "regular" : "ignored") : "dim"),
+    ell: (f, c) => (c.kind === "center" ? "regular" : lastLayer(c) ? (c.kind === "edge" ? "regular" : "ignored") : "dim"),
+    // PLL parts: the pieces being permuted in colour, the others dimmed (EPLL) or hidden (CPLL).
+    epll: (f, c) => (c.kind === "center" || (lastLayer(c) && c.kind === "edge") ? "regular" : "dim"),
+    cpll: (f, c) => (c.kind === "center" || (lastLayer(c) && c.kind === "corner") ? "regular" : lastLayer(c) ? "ignored" : "dim"),
+    zbll: (f, c) => (lastLayer(c) || c.kind === "center" ? "regular" : "dim"),
+    // Last slot (canonical FR): the pair in colour, the rest of F2L dimmed, the last layer by variant.
+    ls: (f, c) => (c.kind === "center" || inSlot(c) ? "regular" : c.pos[1] <= 0 ? "dim" : "ignored"),
+    // ZBLS / ELS orient the last-layer edges while inserting: show them as orientation material.
+    zbls: (f, c) => (c.kind === "center" || inSlot(c) ? "regular" : c.pos[1] <= 0 ? "dim" : c.kind === "edge" && f.face === "U" ? "oriented" : "ignored"),
+    els: (f, c) => (c.kind === "center" || (inSlot(c) && c.kind === "edge") ? "regular" : c.pos[1] <= 0 ? (inSlot(c) ? "ignored" : "dim") : c.kind === "edge" && f.face === "U" ? "oriented" : "ignored"),
+    // CLS / VLS / WVLS orient the last-layer corners while inserting: their top stickers matter.
+    cls: (f, c) => (c.kind === "center" || inSlot(c) ? "regular" : c.pos[1] <= 0 ? "dim" : f.face === "U" ? "regular" : "ignored"),
+    vls: (f, c) => (c.kind === "center" || inSlot(c) ? "regular" : c.pos[1] <= 0 ? "dim" : f.face === "U" ? "regular" : "ignored"),
+};
+/** The canonical last slot: the FR pair (front-right, bottom two layers). */
+function inSlot(c) {
+    return c.pos[0] === 1 && c.pos[2] === 1 && c.pos[1] <= 0;
+}
+function lastLayer(c) {
+    return c.pos[1] === 1 && c.kind !== "center";
+}
+/** A CFOP mask for a cube held in `frame` (e.g. the frame the tracker found the cross in). */
+export const cfopMask = (name, frame = IDENTITY_FRAME) => buildMask(CFOP_MASKS[name], frame);
+const CROSS_PIECES = [PIECE.DR, PIECE.DF, PIECE.DL, PIECE.DB];
+const SLOT_PIECES = {
+    FR: { edge: PIECE.FR, corner: PIECE.DFR },
+    FL: { edge: PIECE.FL, corner: PIECE.DLF },
+    BL: { edge: PIECE.BL, corner: PIECE.DBL },
+    BR: { edge: PIECE.BR, corner: PIECE.DRB },
+};
+/** The four ways to take a paired slot out (the pair is then one insert away), per slot. */
+const EXTRACTIONS = {
+    FR: ["R U R'", "R U' R'", "F' U F", "F' U' F"],
+    FL: ["L' U L", "L' U' L", "F U F'", "F U' F'"],
+    BL: ["L U L'", "L U' L'", "B' U B", "B' U' B"],
+    BR: ["R' U R", "R' U' R", "B U B'", "B U' B'"],
+};
+/**
+ * CFOP trainer stages (canonical: cross on D). Each is a StageDef — plain
+ * data; `stageSolver(def)` answers distance / optimal solutions / next moves
+ * and `stageScramble({ stage: def, length })` draws a case at an exact level.
+ */
+export const CFOP_TRAINERS = {
+    cross: () => ({ name: "cross", pieces: CROSS_PIECES, groups: [[0, 1, 2, 3]] }),
+    xcross: (slot = "FR") => ({
+        name: `xcross-${slot}`,
+        pieces: [...CROSS_PIECES, SLOT_PIECES[slot].edge, SLOT_PIECES[slot].corner],
+        groups: [[0, 1, 2, 3, 4], [0, 1, 2, 3, 5]],
+    }),
+    /** Two slots: adjacent (FR + FL…) or opposite (FR + BL…). */
+    xxcross: (a = "FR", b = "FL") => ({
+        name: `xxcross-${a}-${b}`,
+        pieces: [...CROSS_PIECES, SLOT_PIECES[a].edge, SLOT_PIECES[a].corner, SLOT_PIECES[b].edge, SLOT_PIECES[b].corner],
+        groups: [[0, 1, 2, 3, 4], [0, 1, 2, 3, 5], [0, 1, 2, 3, 6], [0, 1, 2, 3, 7]],
+    }),
+    /**
+     * Free pair: cross solved and the slot's pair FORMED, one standard insert
+     * away — the inserted state or any of the 4 extractions × 4 AUFs (17 goal
+     * states, as in act's pairing trainer).
+     */
+    pair: (slot = "FR") => ({
+        name: `pair-${slot}`,
+        pieces: [...CROSS_PIECES, SLOT_PIECES[slot].edge, SLOT_PIECES[slot].corner],
+        groups: [[0, 1, 2, 3, 4], [0, 1, 2, 3, 5]],
+        goals: ["", ...EXTRACTIONS[slot].flatMap((x) => ["", " U", " U2", " U'"].map((auf) => x + auf))],
+    }),
+};
+export * from "./cases.js";
+export * from "./f2l.js";
+/**
+ * Last-layer stages that also say which case came up: OLL gets the OLL case
+ * after F2L ("OLL 27", "OLL skip"), PLL the PLL case after OLL ("T", "PLL
+ * skip") — StageBoundary.case, MethodTracker.current.case. ZZ / Petrus can
+ * use the same.
+ */
+export function withLastLayerCases(stages) {
+    return stages.map((st) => st.id === "oll"
+        ? { ...st, recognize: (s) => (checks.f2lSolved(s) ? (recognizeOll(s)?.id ?? "OLL skip") : undefined) }
+        : st.id === "pll"
+            ? { ...st, recognize: (s) => (checks.f2lSolved(s) && checks.topOriented(s) ? (recognizePll(s)?.id ?? "PLL skip") : undefined) }
+            : st);
+}

package/cfop/slots.d.ts

@@ -0,0 +1,2 @@
+/** An F2L slot, cube held with the cross on D. */
+export type F2LSlot = "FR" | "FL" | "BL" | "BR";

package/cfop/slots.js

@@ -0,0 +1 @@
+export {};