@wodzik/cubecore 0.1.0

package/roux/cmll.js

@@ -0,0 +1,121 @@
+/**
+ * CMLL recognition — the last-layer corners with both blocks built, colour
+ * neutral and scheme-free. Read relative to the BLOCKS (the M slice may be
+ * off): L / R colours from the side centres, front / back / bottom from the
+ * first block's own stickers, the top colour is the one left. Corners only
+ * (the edges are LSE), compared up to the angle (pre-AUF) and a final U turn.
+ *
+ *   recognizeCmll(state)   // { id: "Sune Left Bar", group: "Sune", preAuf: "U", alg } | null (skip) — cube held blocks L/R, bottom D
+ */
+import { CORNER_FACELETS, FRAMES, applyMoves, colorAt, fromCubies, invert, parseAlg, solvedState, view } from "../core/index.js";
+import { CMLL_CASES } from "./cmllData.js";
+export { CMLL_CASES } from "./cmllData.js";
+/** Last-layer corners in turning order: URF UFL ULB UBR (U sticker first, then clockwise). */
+const U_CORNERS = [0, 1, 2, 3].map((i) => CORNER_FACELETS[i]);
+const AUFS = ["", "U", "U2", "U'"];
+// Reference stickers: side centres L and R; the first block's DL edge (bottom), FL edge (front), BL edge (back).
+const L_CENTRE = 40, R_CENTRE = 13, DL_BOTTOM = 30, FL_FRONT = 21, BL_BACK = 50;
+function corners(s) {
+    const L = colorAt(s, L_CENTRE), R = colorAt(s, R_CENTRE);
+    const front = colorAt(s, FL_FRONT), back = colorAt(s, BL_BACK), bottom = colorAt(s, DL_BOTTOM);
+    const top = [0, 1, 2, 3, 4, 5].find((c) => ![L, R, front, back, bottom].includes(c));
+    if (top === undefined)
+        return null;
+    // Home corners by their two side colours.
+    const HOME = [
+        [R, front],
+        [front, L],
+        [L, back],
+        [back, R],
+    ];
+    const cp = [], co = [];
+    for (const fs of U_CORNERS) {
+        const cols = fs.map((f) => colorAt(s, f));
+        const o = cols.indexOf(top);
+        if (o < 0)
+            return null;
+        const sides = cols.filter((_, i) => i !== o);
+        cp.push(HOME.findIndex((h) => h.every((c) => sides.includes(c))));
+        co.push(o);
+    }
+    return cp.includes(-1) ? null : { cp, co };
+}
+const shift = (a, k) => a.map((_, i) => a[(i + k) % a.length]);
+const text = (c, k, b) => `${shift(c.cp, k).map((v) => (v + b) % 4).join("")}|${shift(c.co, k).join("")}`;
+/** Up to a final U turn. */
+const raw = (c) => [0, 1, 2, 3].map((b) => text(c, 0, b)).sort()[0];
+/** …and up to the angle. */
+const key = (c) => [0, 1, 2, 3].flatMap((k) => [0, 1, 2, 3].map((b) => text(c, k, b))).sort()[0];
+let TABLE = null;
+function table() {
+    if (TABLE)
+        return TABLE;
+    TABLE = new Map();
+    for (const kase of CMLL_CASES) {
+        const c = corners(applyMoves(solvedState(), invert(parseAlg(kase.alg))));
+        const k = key(c);
+        if (TABLE.has(k))
+            throw new Error(`${kase.id} looks like ${TABLE.get(k).kase.id}`);
+        TABLE.set(k, { kase, raw: raw(c) });
+    }
+    return TABLE;
+}
+const SOLVED = key(corners(solvedState()));
+/**
+ * The CMLL case of a cube held with the blocks on L / R and their bottom
+ * on D (both blocks solved) — null when the corners are already solved (up
+ * to AUF) or it isn't a CMLL state.
+ */
+export function recognizeCmll(s) {
+    const c = corners(s);
+    if (!c)
+        return null;
+    const k = key(c);
+    if (k === SOLVED)
+        return null;
+    const e = table().get(k);
+    if (!e)
+        return null;
+    const preAuf = AUFS.find((a) => {
+        const t = corners(a ? applyMoves(s, a) : s);
+        return t !== null && raw(t) === e.raw;
+    }) ?? "";
+    return { id: e.kase.id, group: e.kase.group, preAuf, alg: e.kase.alg };
+}
+/** CMLL of a cube with both Roux blocks built in any orientation (colour neutral): the frame, or null. */
+export function recognizeCmllAnywhere(state, blocksBuilt) {
+    for (const frame of FRAMES) {
+        const s = view(state, frame);
+        if (!blocksBuilt(s))
+            continue;
+        return { match: recognizeCmll(s) ?? "skip", frame };
+    }
+    return null;
+}
+/**
+ * A cube to practise one CMLL case on: both blocks solved, the corners in
+ * the case (from a random angle), the last six edges random. Make a
+ * scramble to it with @cubecore/solve `scrambleTo(state, { from })`.
+ */
+export function cmllCaseState(id, random = Math.random) {
+    const kase = CMLL_CASES.find((c) => c.id === id);
+    if (!kase)
+        throw new Error(`Unknown CMLL case: ${id}`);
+    const c = corners(applyMoves(solvedState(), invert(parseAlg(kase.alg))));
+    // Last six edges (UR UF UL UB DF DB = 0 1 2 3 5 7): any order and flips the corners' parity allows.
+    const lse = [0, 1, 2, 3, 5, 7];
+    const parity = (p) => p.reduce((acc, v, i) => acc + p.slice(i + 1).filter((w) => w < v).length, 0) % 2;
+    let order;
+    do
+        order = [...lse].sort(() => random() - 0.5);
+    while (parity(order) !== parity(c.cp));
+    const ep = Array.from({ length: 12 }, (_, i) => i);
+    lse.forEach((pos, i) => (ep[pos] = order[i]));
+    const eo = new Array(12).fill(0);
+    let flips = 0;
+    for (const pos of lse.slice(1))
+        flips += eo[pos] = random() < 0.5 ? 1 : 0;
+    eo[lse[0]] = flips % 2;
+    const state = fromCubies({ frame: FRAMES[0], cp: [...c.cp, 4, 5, 6, 7], co: [...c.co, 0, 0, 0, 0], ep, eo });
+    return applyMoves(state, AUFS[Math.floor(random() * 4)] || []);
+}

package/roux/cmllData.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CMLL cases as data — names and groups as on speedcubedb.com (O, H, Pi,
+ * U, T, Sune, Anti Sune, L; 42 cases). `alg` is one standard algorithm per
+ * case; recognition is built from it, so any algorithm for the case works.
+ */
+export interface CmllCase {
+    /** "Sune Left Bar", "H Columns"… */
+    id: string;
+    group: string;
+    alg: string;
+}
+export declare const CMLL_CASES: readonly CmllCase[];

package/roux/cmllData.js

@@ -0,0 +1,49 @@
+/**
+ * CMLL cases as data — names and groups as on speedcubedb.com (O, H, Pi,
+ * U, T, Sune, Anti Sune, L; 42 cases). `alg` is one standard algorithm per
+ * case; recognition is built from it, so any algorithm for the case works.
+ */
+export const CMLL_CASES = [
+    { id: "O Adjacent", group: "Solved", alg: "R U R' F' R U R' U' R' F R2 U' R'" },
+    { id: "O Diagonal", group: "Solved", alg: "F R U' R' U' R U R' F' R U R' U' R' F R F'" },
+    { id: "H Columns", group: "H", alg: "U R U R' U R U' R' U R U2 R'" },
+    { id: "H Rows", group: "H", alg: "F R U R' U' R U R' U' R U R' U' F'" },
+    { id: "H Column", group: "H", alg: "R' F2 D R2 U R2 D' F2 R" },
+    { id: "H Row", group: "H", alg: "U2 r U' r2 D' r U' r' D r2 U r'" },
+    { id: "Pi Right Bar", group: "Pi", alg: "F R U R' U' R U R' U' F'" },
+    { id: "Pi Down Slash", group: "Pi", alg: "U F R' F' R U2 R U' R' U R U2 R'" },
+    { id: "Pi X", group: "Pi", alg: "R' F2 D R2 U' R2 D' F2 R" },
+    { id: "Pi Up Slash", group: "Pi", alg: "R U2 R' U' R U R' U2 R' F R F'" },
+    { id: "Pi Columns", group: "Pi", alg: "U' r U' r2 D' r U r' D r2 U r'" },
+    { id: "Pi Left Bar", group: "Pi", alg: "U' R' U' R' F R F' R U' R' U2 R" },
+    { id: "U Up Slash", group: "U", alg: "U2 R2 D R' U2 R D' R' U2 R'" },
+    { id: "U Down Slash", group: "U", alg: "R2 D' R U2 R' D R U2 R" },
+    { id: "U Bottom Row", group: "U", alg: "R' U' R U' R' U2 R2 U R' U R U2 R'" },
+    { id: "U Rows", group: "U", alg: "U' F R2 D R' U R D' R2 U' F'" },
+    { id: "U X", group: "U", alg: "U2 r U' r' U r' D' r U' r' D r" },
+    { id: "U Upper Row", group: "U", alg: "U' F R U R' U' F'" },
+    { id: "T Left Bar", group: "T", alg: "U' R U R' U' R' F R F'" },
+    { id: "T Right Bar", group: "T", alg: "U L' U' L U L F' L' F" },
+    { id: "T Rows", group: "T", alg: "R U2 R' U' R U' R2 U2 R U R' U R" },
+    { id: "T Bottom Row", group: "T", alg: "r' U r U2 R2 F R F' R" },
+    { id: "T Top Row", group: "T", alg: "r' D' r U r' D r U' r U r'" },
+    { id: "T Columns", group: "T", alg: "U2 r U' r2 D' r U2 r' D r2 U r'" },
+    { id: "Sune Left Bar", group: "Sune", alg: "U R U R' U R U2 R'" },
+    { id: "Sune X", group: "Sune", alg: "U L' U2 L U2 r U' r' F" },
+    { id: "Sune Up Slash", group: "Sune", alg: "U F R' F' R U2 R U2 R'" },
+    { id: "Sune Columns", group: "Sune", alg: "U R U R' U' R' F R F' R U R' U R U2 R'" },
+    { id: "Sune Right Bar", group: "Sune", alg: "U' R U R' U R' F R F' R U2 R'" },
+    { id: "Sune Down Slash", group: "Sune", alg: "U r U' r' F R' F' R" },
+    { id: "Anti Sune Right Bar", group: "Anti Sune", alg: "U R' U' R U' R' U2 R" },
+    { id: "Anti Sune Columns", group: "Anti Sune", alg: "U2 R U R2 F' r F R U' r2 F r" },
+    { id: "Anti Sune Down Slash", group: "Anti Sune", alg: "U' F' L F L' U2 L' U2 L" },
+    { id: "Anti Sune X", group: "Anti Sune", alg: "U' R U2 R' U2 R' F R F'" },
+    { id: "Anti Sune Up Slash", group: "Anti Sune", alg: "U' R' F R F' r U r'" },
+    { id: "Anti Sune Left Bar", group: "Anti Sune", alg: "U R U2 R' F R' F' R U' R U' R'" },
+    { id: "L Best", group: "L", alg: "U' F' r U r' U' r' F r" },
+    { id: "L Good", group: "L", alg: "U2 F R' F' R U R U' R'" },
+    { id: "L Pure", group: "L", alg: "R U R' U R U' R' U R U' R' U R U2 R'" },
+    { id: "L Front Commutator", group: "L", alg: "U2 R U2 R D R' U2 R D' R2" },
+    { id: "L Diagonal", group: "L", alg: "U2 R U2 R2 F R F' R U2 R'" },
+    { id: "L Back Commutator", group: "L", alg: "U R' U2 R' D' R U2 R' D R2" },
+];

package/roux/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Roux — first block, second block, CMLL, EO, UL/UR, L4E — checks, method and
+ * masks. Canonical: first block on L, second on R, both on the bottom layer.
+ *
+ * M slices move the U/F/D/B centres, so blocks are checked by comparing
+ * pieces to each other (and to the L/R centres, which M never moves) — still
+ * no absolute colours, so any scheme and any orientation works.
+ */
+import { type Frame, type Mask, type MaskRule, type Method, type LseStageDef, type StageDef, type State } from "../core/index.js";
+export * from "./cmll.js";
+export declare const firstBlock: (s: State) => boolean;
+export declare function secondBlock(s: State): boolean;
+/** CMLL: both blocks, and the top corners solved relative to them (up to AUF). */
+export declare const cmll: (s: State) => boolean;
+/**
+ * LSE edge orientation: every last-six edge has its top/bottom-coloured
+ * sticker on U or D — as the centres say: with the M slice a quarter off
+ * (the top / bottom centres on F / B), the edges in the M slice count by
+ * F / B instead (one M puts them right, flips and all).
+ */
+export declare function lseEo(s: State): boolean;
+/** LSE 4b: UL and UR edges in place, with the corners aligned. */
+export declare function ulUr(s: State): boolean;
+export declare const ROUX: Method;
+export type RouxMask = "fb" | "blocks" | "cmll" | "lse" | "eo" | "ulur";
+export declare const ROUX_MASKS: Record<RouxMask, MaskRule>;
+export declare const rouxMask: (name: RouxMask, frame?: Frame) => Mask;
+export type RouxSide = "front" | "back";
+/**
+ * Roux trainer stages (canonical: first block on L-bottom), as in
+ * roux-trainers / act: first block and first square may be built with any
+ * bottom colour on the L side (`neutral: "x"`, the best of the four);
+ * FBDR keeps one first square solved, second square keeps the first block.
+ * EOLR is a last-six-edges stage — see @cubecore/solve `LSE_STAGES`.
+ */
+export declare const ROUX_TRAINERS: {
+    readonly fb: () => StageDef;
+    /** First square: DL + FL + DLF (front) or DL + BL + DBL (back). */
+    readonly fs: (side?: RouxSide) => StageDef;
+    /** The first block and the DR edge, from a solved first square (`keep`: which one). */
+    readonly fbdr: (keep?: RouxSide) => StageDef;
+    /** Second square: DR + FR + DFR (front) or DR + BR + DRB (back), first block solved. */
+    /**
+     * EOLR: the six edges oriented and UL / UR brought to where one
+     * `[U] M2 [AUF]` (or `M' [U] M2 [AUF]` with the centres off) finishes
+     * them — the 16 goal states roux-trainers and act use. M / U only.
+     */
+    readonly eolr: () => LseStageDef;
+    /** The whole of LSE (M / U), from CMLL solved to a solved cube. */
+    readonly lse: () => LseStageDef;
+    readonly ss: (side?: RouxSide) => StageDef;
+};

package/roux/index.js

@@ -0,0 +1,175 @@
+/**
+ * Roux — first block, second block, CMLL, EO, UL/UR, L4E — checks, method and
+ * masks. Canonical: first block on L, second on R, both on the bottom layer.
+ *
+ * M slices move the U/F/D/B centres, so blocks are checked by comparing
+ * pieces to each other (and to the L/R centres, which M never moves) — still
+ * no absolute colours, so any scheme and any orientation works.
+ */
+import { FACELETS, IDENTITY_FRAME, PIECE, buildMask, checks as C, colorAt, } from "../core/index.js";
+import { recognizeCmll } from "./cmll.js";
+export * from "./cmll.js";
+const { cubieAt, faceletOn, centerIdx, opposite, upToAuf } = C;
+const FB = { dl: cubieAt(-1, -1, 0), fl: cubieAt(-1, 0, 1), bl: cubieAt(-1, 0, -1), dfl: cubieAt(-1, -1, 1), dbl: cubieAt(-1, -1, -1) };
+const SB = { dr: cubieAt(1, -1, 0), fr: cubieAt(1, 0, 1), br: cubieAt(1, 0, -1), dfr: cubieAt(1, -1, 1), dbr: cubieAt(1, -1, -1) };
+function uniformOn(s, cubies, face) {
+    const colors = cubies.map((c) => faceletOn(c, face)).filter((f) => f !== undefined).map((f) => colorAt(s, f));
+    return colors.every((c) => c === colors[0]) ? colors[0] : null;
+}
+/**
+ * A 1×2×3 Roux block on the `side` (L or R) of the bottom layer: its side
+ * stickers match that side's centre, and its bottom / front / back stickers
+ * are each one colour (the centres there may be off by M, so they aren't used).
+ * Returns the block's colours, or null if it isn't built.
+ */
+function rouxBlock(s, side) {
+    const b = side === "L" ? FB : SB;
+    const pieces = Object.values(b);
+    const sideColor = colorAt(s, centerIdx(side));
+    if (!pieces.every((c) => colorAt(s, faceletOn(c, side)) === sideColor))
+        return null;
+    const bottom = uniformOn(s, pieces, "D");
+    const front = uniformOn(s, pieces, "F");
+    const back = uniformOn(s, pieces, "B");
+    if (bottom === null || front === null || back === null)
+        return null;
+    // The three colours must form a real block (e.g. bottom ≠ front's opposite) — true for real pieces
+    // once every sticker agrees, but guard against a colour appearing twice.
+    if (new Set([bottom, front, back, sideColor]).size !== 4)
+        return null;
+    return { bottom, front, back };
+}
+export const firstBlock = (s) => rouxBlock(s, "L") !== null;
+export function secondBlock(s) {
+    const fb = rouxBlock(s, "L");
+    const sb = rouxBlock(s, "R");
+    return fb !== null && sb !== null && fb.bottom === sb.bottom && fb.front === sb.front && fb.back === sb.back;
+}
+const CMLL_CORNERS = { ufl: cubieAt(-1, 1, 1), ubl: cubieAt(-1, 1, -1), ufr: cubieAt(1, 1, 1), ubr: cubieAt(1, 1, -1) };
+function cmllAligned(s) {
+    const fb = rouxBlock(s, "L");
+    if (!fb)
+        return false;
+    const top = opposite(fb.bottom);
+    const { ufl, ubl, ufr, ubr } = CMLL_CORNERS;
+    const col = (c, face) => colorAt(s, faceletOn(c, face));
+    return ([ufl, ubl, ufr, ubr].every((c) => col(c, "U") === top) &&
+        col(ufl, "L") === colorAt(s, centerIdx("L")) &&
+        col(ubl, "L") === colorAt(s, centerIdx("L")) &&
+        col(ufr, "R") === colorAt(s, centerIdx("R")) &&
+        col(ubr, "R") === colorAt(s, centerIdx("R")) &&
+        col(ufl, "F") === fb.front &&
+        col(ufr, "F") === fb.front &&
+        col(ubl, "B") === fb.back &&
+        col(ubr, "B") === fb.back);
+}
+/** CMLL: both blocks, and the top corners solved relative to them (up to AUF). */
+export const cmll = (s) => secondBlock(s) && upToAuf(s, cmllAligned);
+const LSE_EDGES = [cubieAt(0, 1, 1), cubieAt(0, 1, -1), cubieAt(-1, 1, 0), cubieAt(1, 1, 0), cubieAt(0, -1, 1), cubieAt(0, -1, -1)];
+/**
+ * LSE edge orientation: every last-six edge has its top/bottom-coloured
+ * sticker on U or D — as the centres say: with the M slice a quarter off
+ * (the top / bottom centres on F / B), the edges in the M slice count by
+ * F / B instead (one M puts them right, flips and all).
+ */
+export function lseEo(s) {
+    if (!cmll(s))
+        return false;
+    const bottom = rouxBlock(s, "L").bottom;
+    const ud = [bottom, opposite(bottom)];
+    const offQuarter = !ud.includes(colorAt(s, centerIdx("U")));
+    return LSE_EDGES.every((e) => {
+        const f = e.facelets.find((x) => ud.includes(colorAt(s, x)));
+        if (f === undefined)
+            return false;
+        const face = FACELETS[f].face;
+        const inM = e.pos[0] === 0;
+        return inM && offQuarter ? face === "F" || face === "B" : face === "U" || face === "D";
+    });
+}
+/** LSE 4b: UL and UR edges in place, with the corners aligned. */
+export function ulUr(s) {
+    if (!lseEo(s))
+        return false;
+    return upToAuf(s, (t) => {
+        if (!cmllAligned(t))
+            return false;
+        const top = opposite(rouxBlock(t, "L").bottom);
+        const ul = cubieAt(-1, 1, 0);
+        const ur = cubieAt(1, 1, 0);
+        return (colorAt(t, faceletOn(ul, "U")) === top &&
+            colorAt(t, faceletOn(ur, "U")) === top &&
+            colorAt(t, faceletOn(ul, "L")) === colorAt(t, centerIdx("L")) &&
+            colorAt(t, faceletOn(ur, "R")) === colorAt(t, centerIdx("R")));
+    });
+}
+export const ROUX = {
+    id: "roux",
+    name: "Roux",
+    stages: [
+        { id: "fb", label: "First block", done: firstBlock },
+        { id: "sb", label: "Second block", done: secondBlock },
+        // CMLL recognises the case it starts from ("Sune Left Bar", "CMLL skip") — StageBoundary.case.
+        { id: "cmll", label: "CMLL", done: cmll, recognize: (s) => (secondBlock(s) ? (recognizeCmll(s)?.id ?? "CMLL skip") : undefined) },
+        { id: "eo", label: "EO", done: lseEo },
+        { id: "ulur", label: "UL/UR", done: ulUr },
+        { id: "l4e", label: "L4E", done: C.isSolved },
+    ],
+};
+const y = (c) => c.pos[1];
+export const ROUX_MASKS = {
+    fb: (f, c) => (c.pos[0] === -1 && y(c) <= 0 ? "regular" : c.kind === "center" ? "dim" : "ignored"),
+    blocks: (f, c) => (c.pos[0] !== 0 && y(c) <= 0 ? "regular" : c.kind === "center" ? "dim" : "ignored"),
+    cmll: (f, c) => (c.kind === "corner" && y(c) === 1 ? "regular" : c.pos[0] !== 0 && y(c) <= 0 ? "dim" : "ignored"),
+    lse: (f, c) => (c.pos[0] === 0 || (c.kind === "edge" && y(c) === 1) ? "regular" : "dim"),
+    // LSE step by step: EO shows the six edges as orientation material; UL/UR puts those two in colour.
+    eo: (f, c) => (c.kind === "center" ? "regular" : lse6(c) ? "oriented" : "dim"),
+    ulur: (f, c) => (c.kind === "center" ? "regular" : c.kind === "edge" && y(c) === 1 && c.pos[0] !== 0 ? "regular" : lse6(c) ? "ignored" : "dim"),
+};
+/** The last six edges: the M slice plus UL and UR. */
+function lse6(c) {
+    return c.kind === "edge" && (c.pos[0] === 0 || y(c) === 1);
+}
+export const rouxMask = (name, frame = IDENTITY_FRAME) => buildMask(ROUX_MASKS[name], frame);
+const FB_PIECES = [PIECE.DL, PIECE.FL, PIECE.BL, PIECE.DLF, PIECE.DBL];
+const FIRST_SQUARE = { front: [PIECE.DL, PIECE.FL, PIECE.DLF], back: [PIECE.DL, PIECE.BL, PIECE.DBL] };
+const SECOND_SQUARE = { front: [PIECE.FR, PIECE.DFR], back: [PIECE.BR, PIECE.DRB] };
+/**
+ * Roux trainer stages (canonical: first block on L-bottom), as in
+ * roux-trainers / act: first block and first square may be built with any
+ * bottom colour on the L side (`neutral: "x"`, the best of the four);
+ * FBDR keeps one first square solved, second square keeps the first block.
+ * EOLR is a last-six-edges stage — see @cubecore/solve `LSE_STAGES`.
+ */
+export const ROUX_TRAINERS = {
+    fb: () => ({ name: "roux-fb", pieces: FB_PIECES, groups: [[0, 1, 2, 3, 4]], neutral: "x" }),
+    /** First square: DL + FL + DLF (front) or DL + BL + DBL (back). */
+    fs: (side = "front") => ({ name: `roux-fs-${side}`, pieces: FIRST_SQUARE[side], groups: [[0, 1, 2]], neutral: "x" }),
+    /** The first block and the DR edge, from a solved first square (`keep`: which one). */
+    fbdr: (keep = "front") => ({
+        name: `roux-fbdr-${keep}`,
+        pieces: [...FB_PIECES, PIECE.DR],
+        groups: [[0, 1, 2, 3, 4], [0, 1, 3, 5], [0, 2, 4, 5]],
+        keep: keep === "front" ? [0, 1, 3] : [0, 2, 4],
+    }),
+    /** Second square: DR + FR + DFR (front) or DR + BR + DRB (back), first block solved. */
+    /**
+     * EOLR: the six edges oriented and UL / UR brought to where one
+     * `[U] M2 [AUF]` (or `M' [U] M2 [AUF]` with the centres off) finishes
+     * them — the 16 goal states roux-trainers and act use. M / U only.
+     */
+    eolr: () => ({
+        name: "roux-eolr",
+        kind: "lse",
+        features: "eolr",
+        goals: ["U' M2", "U M2", "M' U M2", "M' U' M2"].flatMap((head) => ["", " U", " U'", " U2"].map((auf) => head + auf)),
+    }),
+    /** The whole of LSE (M / U), from CMLL solved to a solved cube. */
+    lse: () => ({ name: "roux-lse", kind: "lse", features: "lse", goals: [""] }),
+    ss: (side = "front") => ({
+        name: `roux-ss-${side}`,
+        pieces: [...FB_PIECES, PIECE.DR, ...SECOND_SQUARE[side]],
+        groups: [[0, 1, 2, 3, 4], [5, 6, 7, 0, 3]],
+        keep: [0, 1, 2, 3, 4],
+    }),
+};

package/skin/attachments.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Things attached to stickers: decals (any PNG / SVG image) and features
+ * (extra geometry — holes, charging slots, anything an app defines).
+ *
+ * Both are chosen with a `StickerSelector` and belong to the STICKER, not to
+ * a place on the cube: a charging port on the yellow centre stays on the
+ * yellow centre whatever you turn, and turns with it (see core
+ * `stickerTurn`). Coordinates are tile-local: x right / y up in the tile's
+ * plane as it sat at home, in fractions of the tile's HALF side (so ±1 is
+ * the tile's edge), z out of the tile.
+ *
+ * Skins stay plain data: a skin names a feature `type` and passes `params`;
+ * the code that draws it is registered once with `defineFeature` — built-ins
+ * below, apps add their own the same way.
+ */
+import { type Face } from "../core/index.js";
+import type * as THREE from "three";
+import type { PieceKind } from "./shapes.js";
+/**
+ * Which stickers something applies to. Every given condition must hold; an
+ * empty selector matches all 54. `faces` are HOME faces, i.e. colour classes:
+ * with the western scheme "D" = the yellow stickers.
+ */
+export interface StickerSelector {
+    faces?: readonly Face[];
+    kinds?: readonly PieceKind[];
+    /** Explicit home facelet indices (e.g. 4 = the U centre). */
+    stickers?: readonly number[];
+}
+export declare function kindOfSticker(sticker: number): PieceKind;
+export declare function selects(selector: StickerSelector, sticker: number): boolean;
+export declare const selectedStickers: (selector: StickerSelector) => number[];
+export interface Decal {
+    select: StickerSelector;
+    /** URL, data: URL or an SVG string. */
+    image: string;
+    /** Width and height as a fraction of the tile side. */
+    size: number;
+    /** Centre offset, tile-local (fractions of the half side). Default [0, 0]. */
+    offset?: readonly [number, number];
+    /** Extra counter-clockwise quarter turns. Default 0. */
+    rotate?: number;
+    /** "multiply" lets an image drawn on white sit on any colour. */
+    blend?: "normal" | "multiply";
+    /** Draw only while the sticker is shown in full colour (not dimmed / greyed by a mask). Default true. */
+    onlyRegular?: boolean;
+}
+/**
+ * An SVG string as a data: URL; URLs and data: URLs pass through. An SVG
+ * without width/height gets 512×512: browsers load such an image with no
+ * intrinsic size, which leaves a WebGL texture empty.
+ */
+export declare function imageUrl(image: string): string;
+export interface FeatureUse {
+    select: StickerSelector;
+    /** A type registered with `defineFeature` ("holes", "slot", or your own). */
+    type: string;
+    params?: Record<string, unknown>;
+}
+export interface FeatureContext {
+    /** Tile side in cubie units (tile-local ±1 = ± side / 2). */
+    side: number;
+    /** Height of the tile top above the cubie face. */
+    thickness: number;
+    params: Record<string, unknown>;
+}
+export interface FeatureDef {
+    type: string;
+    /**
+     * three.js objects in tile-local 3D units: x/y in the tile plane (tile
+     * centre = 0, cubie units — multiply fractions by side / 2), z = 0 on the
+     * tile top. `three` is the renderer's three.js module.
+     */
+    build3d?(ctx: FeatureContext & {
+        three: typeof THREE;
+    }): THREE.Object3D;
+    /** SVG markup in the tile's box: x, y ∈ 0..1, y down, (0.5, 0.5) = tile centre. For @cubecore/image. */
+    svg?(ctx: FeatureContext): string;
+}
+/** Register (or replace) a feature type. */
+export declare function defineFeature(def: FeatureDef): FeatureDef;
+export declare const featureDef: (type: string) => FeatureDef | undefined;

package/skin/attachments.js

@@ -0,0 +1,110 @@
+/**
+ * Things attached to stickers: decals (any PNG / SVG image) and features
+ * (extra geometry — holes, charging slots, anything an app defines).
+ *
+ * Both are chosen with a `StickerSelector` and belong to the STICKER, not to
+ * a place on the cube: a charging port on the yellow centre stays on the
+ * yellow centre whatever you turn, and turns with it (see core
+ * `stickerTurn`). Coordinates are tile-local: x right / y up in the tile's
+ * plane as it sat at home, in fractions of the tile's HALF side (so ±1 is
+ * the tile's edge), z out of the tile.
+ *
+ * Skins stay plain data: a skin names a feature `type` and passes `params`;
+ * the code that draws it is registered once with `defineFeature` — built-ins
+ * below, apps add their own the same way.
+ */
+import { FACES } from "../core/index.js";
+export function kindOfSticker(sticker) {
+    const i = sticker % 9;
+    return i === 4 ? "center" : i % 2 === 0 ? "corner" : "edge";
+}
+export function selects(selector, sticker) {
+    if (selector.faces && !selector.faces.includes(FACES[Math.floor(sticker / 9)]))
+        return false;
+    if (selector.kinds && !selector.kinds.includes(kindOfSticker(sticker)))
+        return false;
+    if (selector.stickers && !selector.stickers.includes(sticker))
+        return false;
+    return true;
+}
+export const selectedStickers = (selector) => Array.from({ length: 54 }, (_, i) => i).filter((i) => selects(selector, i));
+/**
+ * An SVG string as a data: URL; URLs and data: URLs pass through. An SVG
+ * without width/height gets 512×512: browsers load such an image with no
+ * intrinsic size, which leaves a WebGL texture empty.
+ */
+export function imageUrl(image) {
+    const svg = image.trimStart();
+    if (!svg.startsWith("<svg"))
+        return image;
+    const open = svg.slice(0, svg.indexOf(">") + 1);
+    const sized = /\swidth=/.test(open) ? svg : svg.replace("<svg", '<svg width="512" height="512"');
+    return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(sized)}`;
+}
+const REGISTRY = new Map();
+/** Register (or replace) a feature type. */
+export function defineFeature(def) {
+    REGISTRY.set(def.type, def);
+    return def;
+}
+export const featureDef = (type) => REGISTRY.get(type);
+const num = (v, d) => (typeof v === "number" ? v : d);
+const pts = (v, d) => (Array.isArray(v) ? v : d);
+/** Where the shade of a hole / slot is drawn: translucent black darkens any tile colour. */
+function shade(three, opacity) {
+    return new three.MeshBasicMaterial({ color: 0x000000, transparent: true, opacity, depthWrite: false });
+}
+/**
+ * Round holes. params: `radius` (fraction of the tile side), `at` (tile-local
+ * centres, fractions of the half side), `opacity` (0.38).
+ */
+defineFeature({
+    type: "holes",
+    build3d({ three, side, params }) {
+        const g = new three.Group();
+        const disc = new three.CircleGeometry(num(params.radius, 0.045) * side, 20);
+        const mat = shade(three, num(params.opacity, 0.38));
+        for (const [x, y] of pts(params.at, [[0.64, 0.64], [-0.64, 0.64], [-0.64, -0.64], [0.64, -0.64]])) {
+            const m = new three.Mesh(disc, mat);
+            m.position.set((x * side) / 2, (y * side) / 2, 0.001);
+            g.add(m);
+        }
+        return g;
+    },
+    svg({ params }) {
+        const r = num(params.radius, 0.045), o = num(params.opacity, 0.38);
+        return pts(params.at, [[0.64, 0.64], [-0.64, 0.64], [-0.64, -0.64], [0.64, -0.64]])
+            .map(([x, y]) => `<circle cx="${0.5 + x / 2}" cy="${0.5 - y / 2}" r="${r}" fill="#000" fill-opacity="${o}"/>`)
+            .join("");
+    },
+});
+/**
+ * A rounded slot, e.g. a charging port. params: `width`, `height`, `radius`
+ * (fractions of the tile side), `at` (tile-local centre), `opacity` (0.55).
+ */
+defineFeature({
+    type: "slot",
+    build3d({ three, side, params }) {
+        const w = num(params.width, 0.3) * side, h = num(params.height, 0.1) * side;
+        const r = Math.min(num(params.radius, 0.05) * side, w / 2, h / 2);
+        const s = new three.Shape();
+        s.moveTo(-w / 2 + r, -h / 2);
+        s.lineTo(w / 2 - r, -h / 2);
+        s.absarc(w / 2 - r, -h / 2 + r, r, -Math.PI / 2, 0, false);
+        s.lineTo(w / 2, h / 2 - r);
+        s.absarc(w / 2 - r, h / 2 - r, r, 0, Math.PI / 2, false);
+        s.lineTo(-w / 2 + r, h / 2);
+        s.absarc(-w / 2 + r, h / 2 - r, r, Math.PI / 2, Math.PI, false);
+        s.lineTo(-w / 2, -h / 2 + r);
+        s.absarc(-w / 2 + r, -h / 2 + r, r, Math.PI, Math.PI * 1.5, false);
+        const m = new three.Mesh(new three.ShapeGeometry(s, 6), shade(three, num(params.opacity, 0.55)));
+        const [x, y] = params.at ?? [0, 0];
+        m.position.set((x * side) / 2, (y * side) / 2, 0.001);
+        return m;
+    },
+    svg({ params }) {
+        const w = num(params.width, 0.3), h = num(params.height, 0.1), r = Math.min(num(params.radius, 0.05), w / 2, h / 2);
+        const [x, y] = params.at ?? [0, 0];
+        return `<rect x="${0.5 + x / 2 - w / 2}" y="${0.5 - y / 2 - h / 2}" width="${w}" height="${h}" rx="${r}" fill="#000" fill-opacity="${num(params.opacity, 0.55)}"/>`;
+    },
+});

package/skin/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./skin.js";
+export * from "./shapes.js";
+export * from "./attachments.js";

package/skin/index.js

@@ -0,0 +1,3 @@
+export * from "./skin.js";
+export * from "./shapes.js";
+export * from "./attachments.js";