@wodzik/cubecore 0.1.0

package/analyze/index.js

@@ -0,0 +1,151 @@
+/**
+ * Scramble analysis for CFOP (in the spirit of speedcubedb.com/analyze):
+ * for each cross colour, a good way through — the cross (or XCross…), the
+ * F2L pairs in the best order, the last layer with its cases — so an app
+ * can show the optimal cross, the recommended first pair, the pair order,
+ * which cases come up, and how much of it the solver's own algorithms
+ * cover.
+ *
+ *   const a = analyzeScramble("R U2 F' …", { f2l: "optimal", start: "cross" });
+ *   a.best                 // the shortest analysis over the six cross colours
+ *   a.byCross[0].steps     // [{ step: "cross", moves }, { step: "pair", slot: "FL", moves, case? }, … { step: "oll", case } …]
+ *   a.byCross[0].rotation  // "x2" — hold like this (cross on the bottom), then do the moves as written
+ *
+ * F2L modes:
+ *   "optimal"     each pair the fewest moves that keep the cross and the pairs
+ *                 already in (StageSolver), over all 24 pair orders;
+ *   "algorithms"  each pair its F2L case's algorithm (pre-AUF + alg), over all
+ *                 orders; a pair not in one of the 41 cases (a piece stuck in
+ *                 another slot) falls back to the fewest-moves insertion.
+ * The last layer always goes by OLL + PLL algorithms (+ AUF).
+ */
+import { FRAMES, PIECE, applyMoves, checks, isSolved, moveCount, parseAlg, reframe, simplify, solvedState, toFaceTurns, } from "../core/index.js";
+import { recognizeF2L, recognizeOll, recognizePll } from "../cfop/index.js";
+import { stageSolver } from "../solve/index.js";
+import { rotationFor } from "./rotations.js";
+export * from "./roux.js";
+export * from "./zz.js";
+export { rotationFor } from "./rotations.js";
+const SLOTS = ["FR", "FL", "BL", "BR"];
+const CROSS = [PIECE.DR, PIECE.DF, PIECE.DL, PIECE.DB];
+const SLOT_PIECES = { FR: [PIECE.FR, PIECE.DFR], FL: [PIECE.FL, PIECE.DLF], BL: [PIECE.BL, PIECE.DBL], BR: [PIECE.BR, PIECE.DRB] };
+/** Cross plus the given pairs solved — one stage (tables: cross + each piece); `moves` limits the faces turned (ZZ: R U L). */
+export function f2lStage(slots, moves) {
+    const pieces = [...CROSS, ...slots.flatMap((s) => SLOT_PIECES[s])];
+    const groups = slots.flatMap((_, i) => [[0, 1, 2, 3, 4 + 2 * i], [0, 1, 2, 3, 5 + 2 * i]]);
+    return { name: `cross+${[...slots].sort().join("+")}`, pieces, groups: groups.length ? groups : [[0, 1, 2, 3]], ...(moves ? { moves } : {}) };
+}
+const combos = (items, k) => k === 0 ? [[]] : items.flatMap((x, i) => combos(items.slice(i + 1), k - 1).map((c) => [x, ...c]));
+/** The best way through the remaining pairs (all orders). */
+export function planPairs(state, done, mode, known, moves) {
+    const left = SLOTS.filter((s) => !done.includes(s));
+    if (!left.length)
+        return { steps: [], length: 0, order: [], state };
+    let best = null;
+    for (const slot of left) {
+        const step = pairStep(state, done, slot, mode, known, moves);
+        if (!step)
+            continue;
+        const after = applyMoves(state, step.moves);
+        const rest = planPairs(after, [...done, slot], mode, known, moves);
+        const length = step.moves.length + rest.length;
+        if (!best || length < best.length)
+            best = { steps: [step, ...rest.steps], length, order: [slot, ...rest.order], state: rest.state };
+    }
+    return best;
+}
+function pairStep(state, done, slot, mode, known, moves) {
+    if (mode === "algorithms") {
+        const r = recognizeF2L(state, slot);
+        if (r === "solved")
+            return { step: "pair", slot, moves: [], case: "solved", how: "algorithm" };
+        if (r) {
+            const moves = simplify(parseAlg(`${r.preAuf} ${r.alg}`));
+            // The case's algorithm must leave the cross and the pairs already in untouched.
+            if (stageSolver(f2lStage([...done, slot])).distance(applyMoves(state, moves), { maxDepth: 0 }) === 0) {
+                const alg = `${r.preAuf} ${r.alg}`.trim();
+                return { step: "pair", slot, moves: simplify(toFaceTurns(moves).moves), case: r.id, alg, how: "algorithm", ...(known ? { known: known.has(r.id) } : {}) };
+            }
+        }
+    }
+    const sol = stageSolver(f2lStage([...done, slot], moves)).solve(state, { maxDepth: 16 })[0];
+    if (!sol)
+        return null;
+    const r = recognizeF2L(state, slot);
+    return { step: "pair", slot, moves: sol, ...(r ? { case: r === "solved" ? "solved" : r.id } : {}), how: "optimal" };
+}
+export function lastLayer(state, known) {
+    const steps = [];
+    let s = state;
+    const oll = recognizeOll(s);
+    if (oll) {
+        const moves = simplify(toFaceTurns(`${oll.preAuf} ${oll.alg}`).moves);
+        steps.push({ step: "oll", moves, case: oll.id, alg: `${oll.preAuf} ${oll.alg}`.trim(), ...(known ? { known: known.has(oll.id) } : {}) });
+        s = applyMoves(s, moves);
+    }
+    else
+        steps.push({ step: "oll", moves: [], case: "OLL skip" });
+    const pll = recognizePll(s);
+    if (pll) {
+        const moves = simplify(toFaceTurns(`${pll.preAuf} ${pll.alg}`).moves);
+        steps.push({ step: "pll", moves, case: pll.id, alg: `${pll.preAuf} ${pll.alg}`.trim(), ...(known ? { known: known.has(pll.id) } : {}) });
+        s = applyMoves(s, moves);
+    }
+    else
+        steps.push({ step: "pll", moves: [], case: "PLL skip" });
+    const auf = ["", "U", "U2", "U'"].find((a) => isSolved(a ? applyMoves(s, a) : s)) ?? "";
+    if (auf) {
+        steps.push({ step: "auf", moves: parseAlg(auf) });
+        s = applyMoves(s, auf);
+    }
+    return { steps, state: s };
+}
+/** One cross colour: the whole way through, as held with the cross on the bottom. */
+export function analyzeCross(scrambled, face, options = {}) {
+    const frame = FRAMES.find((f) => f.face.D === face);
+    const known = options.known ? new Set(options.known) : null;
+    const mode = options.f2l ?? "optimal";
+    // As held: sticker names renamed so the cross face is D (colour logic is unaffected).
+    let s = reframe(scrambled, frame);
+    const steps = [];
+    const first = { cross: 0, xcross: 1, xxcross: 2, xxxcross: 3 }[options.start ?? "cross"];
+    let done = [];
+    // Cross (+ pairs): the best choice of slots for Cross+N.
+    let crossBest = null;
+    for (const slots of combos(SLOTS, first)) {
+        const sol = stageSolver(f2lStage(slots)).solve(s, { maxDepth: 16 })[0];
+        if (sol && (!crossBest || sol.length < crossBest.moves.length))
+            crossBest = { moves: sol, slots };
+    }
+    steps.push({ step: "cross", moves: crossBest.moves, ...(first ? { slots: crossBest.slots } : {}) });
+    s = applyMoves(s, crossBest.moves);
+    done = crossBest.slots;
+    const pairs = planPairs(s, done, mode, known);
+    steps.push(...pairs.steps);
+    s = pairs.state;
+    const ll = lastLayer(s, known);
+    steps.push(...ll.steps);
+    return {
+        face,
+        rotation: rotationFor(frame),
+        frame,
+        steps,
+        length: steps.reduce((n, st) => n + moveCount(st.moves), 0),
+        pairOrder: pairs.order,
+    };
+}
+/** Analyse a scramble (moves from solved, or a state) for each cross colour. */
+export function analyzeScramble(scramble, options = {}) {
+    const state = scramble instanceof Uint8Array ? scramble : applyMoves(solvedState(), typeof scramble === "string" ? parseAlg(scramble) : scramble);
+    const faces = options.crosses ?? ["D", "U", "F", "B", "L", "R"];
+    const byCross = faces.map((face) => analyzeCross(state, face, options)).sort((a, b) => a.length - b.length);
+    return { byCross, best: byCross[0] };
+}
+/** Does following the analysis (rotation, then every step) solve the cube? — for tests / sanity checks. */
+export function followsThrough(scramble, a) {
+    let s = reframe(scramble, a.frame);
+    for (const st of a.steps)
+        s = applyMoves(s, st.moves);
+    return isSolved(s) && checks.f2lSolved(s);
+}
+export * from "./client.js";

package/analyze/rotations.d.ts

@@ -0,0 +1,3 @@
+/** A whole-cube rotation for each frame ("x2", "z y'"…): hold the cube like this to see it as the frame does. */
+import { type Frame } from "../core/index.js";
+export declare const rotationFor: (frame: Frame) => string;

package/analyze/rotations.js

@@ -0,0 +1,15 @@
+/** A whole-cube rotation for each frame ("x2", "z y'"…): hold the cube like this to see it as the frame does. */
+import { toFaceTurns } from "../core/index.js";
+const ROTATIONS = (() => {
+    const out = new Map();
+    for (const tilt of ["", "x", "x2", "x'", "z", "z'"]) {
+        for (const turn of ["", "y", "y2", "y'"]) {
+            const alg = `${tilt} ${turn}`.trim();
+            const frame = toFaceTurns(alg).frame;
+            if (!out.has(frame.id))
+                out.set(frame.id, alg);
+        }
+    }
+    return out;
+})();
+export const rotationFor = (frame) => ROTATIONS.get(frame.id) ?? "";

package/analyze/roux.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Scramble analysis for Roux: for each side the first block can go on,
+ * the best way through — first block (with the best bottom colour),
+ * second square and the rest of the second block, CMLL (case named), LSE
+ * (M / U, split into EO, UL/UR and the last four edges).
+ *
+ *   const a = analyzeRoux("R U2 F' …");
+ *   a.best.rotation    // hold like this: the first block goes on the left, its bottom down
+ *   a.best.steps       // fb, ss (front / back), sb, cmll, lse
+ *
+ * Blocks by fewest face turns (optimal FB; second square, then the last
+ * pair of the second block, each optimal keeping what's built); CMLL by
+ * its algorithm; LSE optimal in M and U (exact table). Lengths in STM
+ * (a slice counts one).
+ */
+import { type Face, type Frame, type Move, type State } from "../core/index.js";
+import { type RouxSide } from "../roux/index.js";
+export interface RouxAnalyzeOptions {
+    /** Physical faces the first block may go on (its left side); default all six. */
+    sides?: readonly Face[];
+    /** Case ids the solver knows ("Sune Left Bar"…) — the CMLL step gets `known`. */
+    known?: Iterable<string>;
+}
+export type RouxStep = {
+    step: "fb";
+    moves: Move[];
+} | {
+    step: "ss";
+    side: RouxSide;
+    moves: Move[];
+} | {
+    step: "sb";
+    moves: Move[];
+} | {
+    step: "cmll";
+    moves: Move[];
+    case: string;
+    alg?: string;
+    known?: boolean;
+} | {
+    step: "lse";
+    moves: Move[];
+    eo: number;
+    ulur: number;
+    l4e: number;
+};
+export interface RouxAnalysis {
+    /** Physical face the first block is built against (left side as held). */
+    side: Face;
+    /** Physical face its bottom is on. */
+    bottom: Face;
+    rotation: string;
+    frame: Frame;
+    steps: RouxStep[];
+    /** STM. */
+    length: number;
+}
+export interface RouxAnalysisResult {
+    bySide: RouxAnalysis[];
+    best: RouxAnalysis;
+}
+/** One side (and its best bottom): the whole way through, as held. */
+export declare function analyzeRouxSide(scrambled: State, side: Face, known?: Set<string> | null): RouxAnalysis;
+/** Analyse a scramble for Roux, for each side the first block can go on. */
+export declare function analyzeRoux(scramble: string | readonly Move[] | State, options?: RouxAnalyzeOptions): RouxAnalysisResult;
+/** Does following it (as held) solve the cube? */
+export declare function rouxFollowsThrough(scramble: State, a: RouxAnalysis): boolean;

package/analyze/roux.js

@@ -0,0 +1,95 @@
+/**
+ * Scramble analysis for Roux: for each side the first block can go on,
+ * the best way through — first block (with the best bottom colour),
+ * second square and the rest of the second block, CMLL (case named), LSE
+ * (M / U, split into EO, UL/UR and the last four edges).
+ *
+ *   const a = analyzeRoux("R U2 F' …");
+ *   a.best.rotation    // hold like this: the first block goes on the left, its bottom down
+ *   a.best.steps       // fb, ss (front / back), sb, cmll, lse
+ *
+ * Blocks by fewest face turns (optimal FB; second square, then the last
+ * pair of the second block, each optimal keeping what's built); CMLL by
+ * its algorithm; LSE optimal in M and U (exact table). Lengths in STM
+ * (a slice counts one).
+ */
+import { FRAMES, applyMoves, isSolved, moveCount, parseAlg, reframe, simplify, solvedState, toFaceTurns } from "../core/index.js";
+import { ROUX_TRAINERS, cmll as cmllDone, lseEo, recognizeCmll, ulUr } from "../roux/index.js";
+import { STAGES, lseSolver, stageSolver } from "../solve/index.js";
+import { rotationFor } from "./rotations.js";
+const FB_FIXED = { ...ROUX_TRAINERS.fb(), name: "roux-fb-fixed", neutral: undefined };
+const SIDES = ["front", "back"];
+/** One side (and its best bottom): the whole way through, as held. */
+export function analyzeRouxSide(scrambled, side, known = null) {
+    // The best bottom colour for the first block on this side.
+    const fb = stageSolver(FB_FIXED);
+    let best = null;
+    for (const frame of FRAMES.filter((f) => f.face.L === side)) {
+        const sol = fb.solve(reframe(scrambled, frame), { maxDepth: 12 })[0];
+        if (sol && (!best || sol.length < best.moves.length))
+            best = { frame, moves: sol };
+    }
+    const { frame } = best;
+    const steps = [{ step: "fb", moves: best.moves }];
+    let s = applyMoves(reframe(scrambled, frame), best.moves);
+    // Second square (the better side), then the rest of the second block.
+    let ss = null;
+    for (const sq of SIDES) {
+        const sol = stageSolver(ROUX_TRAINERS.ss(sq)).solve(s, { maxDepth: 14 })[0];
+        if (sol && (!ss || sol.length < ss.moves.length))
+            ss = { side: sq, moves: sol };
+    }
+    steps.push({ step: "ss", side: ss.side, moves: ss.moves });
+    s = applyMoves(s, ss.moves);
+    const sb = stageSolver(STAGES["roux-blocks"]()).solve(s, { maxDepth: 14 })[0];
+    steps.push({ step: "sb", moves: sb });
+    s = applyMoves(s, sb);
+    // CMLL by its algorithm.
+    const c = recognizeCmll(s);
+    if (c) {
+        const moves = simplify(toFaceTurns(`${c.preAuf} ${c.alg}`).moves);
+        s = applyMoves(s, moves);
+        if (!cmllDone(s))
+            throw new Error(`CMLL ${c.id} didn't solve the corners`);
+        steps.push({ step: "cmll", moves, case: c.id, alg: `${c.preAuf} ${c.alg}`.trim(), ...(known ? { known: known.has(c.id) } : {}) });
+    }
+    else
+        steps.push({ step: "cmll", moves: [], case: "CMLL skip" });
+    // LSE, optimal in M / U; where EO and UL/UR were done along the way.
+    const lse = lseSolver(ROUX_TRAINERS.lse()).solve(s)[0] ?? [];
+    let eo = -1, ulur = -1;
+    let t = s;
+    for (let i = 0; i <= lse.length; i++) {
+        if (eo < 0 && lseEo(t))
+            eo = i;
+        if (ulur < 0 && ulUr(t))
+            ulur = i;
+        if (i < lse.length)
+            t = applyMoves(t, [lse[i]]);
+    }
+    const eoLen = Math.max(eo, 0), ulurLen = Math.max(ulur, eoLen) - eoLen;
+    steps.push({ step: "lse", moves: lse, eo: eoLen, ulur: ulurLen, l4e: lse.length - eoLen - ulurLen });
+    return {
+        side,
+        bottom: frame.face.D,
+        rotation: rotationFor(frame),
+        frame,
+        steps,
+        length: steps.reduce((n, st) => n + moveCount(st.moves, "stm"), 0),
+    };
+}
+/** Analyse a scramble for Roux, for each side the first block can go on. */
+export function analyzeRoux(scramble, options = {}) {
+    const state = scramble instanceof Uint8Array ? scramble : applyMoves(solvedState(), typeof scramble === "string" ? parseAlg(scramble) : scramble);
+    const known = options.known ? new Set(options.known) : null;
+    const sides = options.sides ?? ["L", "R", "F", "B", "U", "D"];
+    const bySide = sides.map((side) => analyzeRouxSide(state, side, known)).sort((a, b) => a.length - b.length);
+    return { bySide, best: bySide[0] };
+}
+/** Does following it (as held) solve the cube? */
+export function rouxFollowsThrough(scramble, a) {
+    let s = reframe(scramble, a.frame);
+    for (const st of a.steps)
+        s = applyMoves(s, st.moves);
+    return isSolved(s);
+}

package/analyze/worker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The analyser in a Web Worker (the F2L tables build here, once, ~10 s;
+ * then an analysis of all six cross colours takes ~0.5 s optimal / ~50 ms
+ * by algorithms). Use it through `createAnalyzerWorker()`.
+ */
+export {};

package/analyze/worker.js

@@ -0,0 +1,31 @@
+/**
+ * The analyser in a Web Worker (the F2L tables build here, once, ~10 s;
+ * then an analysis of all six cross colours takes ~0.5 s optimal / ~50 ms
+ * by algorithms). Use it through `createAnalyzerWorker()`.
+ */
+import { ROUX_TRAINERS } from "../roux/index.js";
+import { STAGES, indexedDbTableStore, preloadStageTables } from "../solve/index.js";
+import { analyzeRoux, analyzeScramble, analyzeZZ, f2lStage } from "./index.js";
+import { ZZ_TRAINERS } from "../zz/index.js";
+// The tables (CFOP: cross + each pair piece; Roux: blocks, squares) survive reloads in IndexedDB: built once per device.
+const STAGE_TABLES = [f2lStage(["FR", "FL", "BL", "BR"]), ZZ_TRAINERS.eocross(), ROUX_TRAINERS.fb(), ROUX_TRAINERS.ss("front"), ROUX_TRAINERS.ss("back"), STAGES["roux-blocks"]()];
+const ready = typeof indexedDB !== "undefined" ? preloadStageTables(STAGE_TABLES, indexedDbTableStore()).catch(() => undefined) : Promise.resolve();
+self.onmessage = async (e) => {
+    const { id, scramble, options, method } = e.data;
+    await ready;
+    try {
+        const input = typeof scramble === "string" ? scramble : Uint8Array.from(scramble);
+        self.postMessage({
+            id,
+            ok: true,
+            value: method === "roux"
+                ? analyzeRoux(input, options)
+                : method === "zz"
+                    ? analyzeZZ(input, options)
+                    : analyzeScramble(input, options),
+        });
+    }
+    catch (err) {
+        self.postMessage({ id, ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+};

package/analyze/zz.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Scramble analysis for ZZ, either way in:
+ *   "eocross" — EOCross (every edge oriented, on the better of the two EO
+ *               axes), then the four pairs with R, U and L only in the best order;
+ *   "eoline"  — EOLine (edges oriented, DF + DB), then the left and right
+ *               blocks with R U L (the better order);
+ * then the last layer: with the edges oriented the OLL is an OCLL case (or a
+ * skip), then PLL.
+ *
+ *   const z = analyzeZZ(scramble);
+ *   z.best.steps       // eocross, pair ×4 (R U L), oll (OCLL), pll, auf
+ *   z.best.eoAxis      // the physical faces EO is judged against, e.g. ["F", "B"]
+ */
+import { type Face, type Frame, type Move, type State } from "../core/index.js";
+import type { F2LSlot } from "../cfop/index.js";
+import { type AnalysisStep } from "./index.js";
+export interface ZZAnalyzeOptions {
+    /** "eocross" (default) or classic "eoline" + blocks. */
+    start?: "eocross" | "eoline";
+    /** Physical faces to put the cross on (default all six). */
+    crosses?: readonly Face[];
+    /** Case ids the solver knows ("OLL 27", "T"…). */
+    known?: Iterable<string>;
+}
+export interface ZZAnalysis {
+    face: Face;
+    /** The physical faces the edges are oriented against (the front / back as held). */
+    eoAxis: [Face, Face];
+    rotation: string;
+    frame: Frame;
+    /** "cross" is the EOCross; pairs are R / U / L only. */
+    steps: AnalysisStep[];
+    length: number;
+    /** EOCross: the order of the pairs; EOLine: empty (see blockOrder). */
+    pairOrder: F2LSlot[];
+    /** EOLine: which block went first. */
+    blockOrder?: ("left" | "right")[];
+}
+export interface ZZAnalysisResult {
+    byCross: ZZAnalysis[];
+    best: ZZAnalysis;
+}
+/** EOLine, then the two blocks (R U L) in the better order. */
+export declare function analyzeZZLine(scrambled: State, face: Face, known?: Set<string> | null): ZZAnalysis;
+export declare function analyzeZZCross(scrambled: State, face: Face, known?: Set<string> | null): ZZAnalysis;
+export declare function analyzeZZ(scramble: string | readonly Move[] | State, options?: ZZAnalyzeOptions): ZZAnalysisResult;
+export declare function zzFollowsThrough(scramble: State, a: ZZAnalysis): boolean;

package/analyze/zz.js

@@ -0,0 +1,102 @@
+/**
+ * Scramble analysis for ZZ, either way in:
+ *   "eocross" — EOCross (every edge oriented, on the better of the two EO
+ *               axes), then the four pairs with R, U and L only in the best order;
+ *   "eoline"  — EOLine (edges oriented, DF + DB), then the left and right
+ *               blocks with R U L (the better order);
+ * then the last layer: with the edges oriented the OLL is an OCLL case (or a
+ * skip), then PLL.
+ *
+ *   const z = analyzeZZ(scramble);
+ *   z.best.steps       // eocross, pair ×4 (R U L), oll (OCLL), pll, auf
+ *   z.best.eoAxis      // the physical faces EO is judged against, e.g. ["F", "B"]
+ */
+import { FRAMES, applyMoves, isSolved, moveCount, parseAlg, reframe, solvedState } from "../core/index.js";
+import { ZZ_TRAINERS } from "../zz/index.js";
+import { stageSolver } from "../solve/index.js";
+import { lastLayer, planPairs } from "./index.js";
+import { rotationFor } from "./rotations.js";
+const RUL = ["R", "U", "L"];
+/** EOLine, then the two blocks (R U L) in the better order. */
+export function analyzeZZLine(scrambled, face, known = null) {
+    const line = stageSolver(ZZ_TRAINERS.eoline());
+    let best = null;
+    for (const frame of FRAMES.filter((f) => f.face.D === face)) {
+        const sol = line.solve(reframe(scrambled, frame), { maxDepth: 10 })[0];
+        if (sol && (!best || sol.length < best.moves.length))
+            best = { frame, moves: sol };
+    }
+    const { frame } = best;
+    const afterLine = applyMoves(reframe(scrambled, frame), best.moves);
+    const both = stageSolver(ZZ_TRAINERS.block("right", true));
+    let blocks = null;
+    for (const first of ["left", "right"]) {
+        const a = stageSolver(ZZ_TRAINERS.block(first)).solve(afterLine, { maxDepth: 18 })[0];
+        if (!a)
+            continue;
+        const b = both.solve(applyMoves(afterLine, a), { maxDepth: 18 })[0];
+        if (!b)
+            continue;
+        if (!blocks || a.length + b.length < blocks.first.length + blocks.second.length) {
+            blocks = { order: [first, first === "left" ? "right" : "left"], first: a, second: b };
+        }
+    }
+    const steps = [
+        { step: "eoline", moves: best.moves },
+        { step: "block", side: blocks.order[0], moves: blocks.first },
+        { step: "block", side: blocks.order[1], moves: blocks.second },
+    ];
+    const ll = lastLayer(applyMoves(afterLine, [...blocks.first, ...blocks.second]), known);
+    steps.push(...ll.steps);
+    return {
+        face,
+        eoAxis: [frame.face.F, frame.face.B],
+        rotation: rotationFor(frame),
+        frame,
+        steps,
+        length: steps.reduce((n, st) => n + moveCount(st.moves), 0),
+        pairOrder: [],
+        blockOrder: blocks.order,
+    };
+}
+export function analyzeZZCross(scrambled, face, known = null) {
+    // EOCross on the better axis: frames with this bottom differ in which faces are front / back.
+    const eo = stageSolver(ZZ_TRAINERS.eocross());
+    let best = null;
+    for (const frame of FRAMES.filter((f) => f.face.D === face)) {
+        const sol = eo.solve(reframe(scrambled, frame), { maxDepth: 12 })[0];
+        if (sol && (!best || sol.length < best.moves.length))
+            best = { frame, moves: sol };
+    }
+    const { frame } = best;
+    const steps = [{ step: "cross", moves: best.moves }];
+    let s = applyMoves(reframe(scrambled, frame), best.moves);
+    const pairs = planPairs(s, [], "optimal", known, [...RUL]);
+    steps.push(...pairs.steps);
+    s = pairs.state;
+    const ll = lastLayer(s, known);
+    steps.push(...ll.steps);
+    return {
+        face,
+        eoAxis: [frame.face.F, frame.face.B],
+        rotation: rotationFor(frame),
+        frame,
+        steps,
+        length: steps.reduce((n, st) => n + moveCount(st.moves), 0),
+        pairOrder: pairs.order,
+    };
+}
+export function analyzeZZ(scramble, options = {}) {
+    const state = scramble instanceof Uint8Array ? scramble : applyMoves(solvedState(), typeof scramble === "string" ? parseAlg(scramble) : scramble);
+    const known = options.known ? new Set(options.known) : null;
+    const faces = options.crosses ?? ["D", "U", "F", "B", "L", "R"];
+    const analyse = options.start === "eoline" ? analyzeZZLine : analyzeZZCross;
+    const byCross = faces.map((f) => analyse(state, f, known)).sort((a, b) => a.length - b.length);
+    return { byCross, best: byCross[0] };
+}
+export function zzFollowsThrough(scramble, a) {
+    let s = reframe(scramble, a.frame);
+    for (const st of a.steps)
+        s = applyMoves(s, st.moves);
+    return isSolved(s);
+}

package/bld/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Blindfolded solving (Old Pochmann): letter schemes, memorisation (the
+ * letters to remember for a scrambled cube), following the execution letter
+ * by letter on a smart cube, and a skin with the letters on the stickers.
+ *
+ *   const m = memo(state);             // { edges: ["Q","U",…], corners: [...], parity, … }
+ *   formatMemo(m.edges)                // "QU SR NX IV PR DE"
+ *   const t = new BldTracker(state);   // push the cube's moves; t.progress says which letter is done
+ *   player.skin = letterSkin(SKINS.default);
+ */
+export * from "./scheme.js";
+export * from "./memo.js";
+export * from "./tracker.js";
+export * from "./skin.js";

package/bld/index.js

@@ -0,0 +1,14 @@
+/**
+ * Blindfolded solving (Old Pochmann): letter schemes, memorisation (the
+ * letters to remember for a scrambled cube), following the execution letter
+ * by letter on a smart cube, and a skin with the letters on the stickers.
+ *
+ *   const m = memo(state);             // { edges: ["Q","U",…], corners: [...], parity, … }
+ *   formatMemo(m.edges)                // "QU SR NX IV PR DE"
+ *   const t = new BldTracker(state);   // push the cube's moves; t.progress says which letter is done
+ *   player.skin = letterSkin(SKINS.default);
+ */
+export * from "./scheme.js";
+export * from "./memo.js";
+export * from "./tracker.js";
+export * from "./skin.js";

package/bld/memo.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Old Pochmann memorisation. Starting from the buffer, follow where each
+ * sticker belongs: the sticker in the buffer belongs at A → remember A; the
+ * sticker at A belongs at B → remember B; … until the buffer's own piece
+ * comes back. Pieces left unsolved start new cycles (a cycle break: shoot
+ * to one of their stickers, follow, and finish on that piece again) — which
+ * also covers flipped edges and twisted corners in place.
+ *
+ * Executing: each letter is one swap of the buffer piece with the lettered
+ * sticker's piece (edges: T-perm with setup moves, corners: Y-perm). An odd
+ * number of edge letters means parity (an extra algorithm between edges and
+ * corners).
+ *
+ * Buffers: UR for edges, ULB for corners (the usual OP buffers).
+ */
+import { type Move, type State } from "../core/index.js";
+import { type LetterScheme } from "./scheme.js";
+/** Edge buffer: the U sticker of UR. */
+export declare const EDGE_BUFFER = 5;
+/** Corner buffer: the U sticker of ULB. */
+export declare const CORNER_BUFFER = 0;
+export interface Memo {
+    /** Letters to remember, edges first. */
+    edges: string[];
+    corners: string[];
+    /** The sticker position of each letter (what to shoot to). */
+    edgeTargets: number[];
+    cornerTargets: number[];
+    /** Odd number of edge letters: do the parity algorithm between edges and corners. */
+    parity: boolean;
+}
+export interface MemoOptions {
+    scheme?: LetterScheme;
+    /**
+     * How the cube is held while solving, as rotations from its own U on top /
+     * F in front — e.g. "x2 y'" = yellow on top, orange in front for a cube
+     * with white U and green F. Letters go by the positions as held.
+     */
+    rotation?: string | readonly Move[];
+    edgeBuffer?: number;
+    cornerBuffer?: number;
+}
+/**
+ * The state with positions and sticker names as held: turned by `rotation`
+ * if given, and with the centres where they are now counted as home (a
+ * state after rotations, e.g. "… x2 y'", reads the way the cube is now held).
+ */
+export declare function asHeld(state: State, rotation?: string | readonly Move[]): State;
+/** The letters to remember for `state`. */
+export declare function memo(input: State, options?: MemoOptions): Memo;
+/** Letters in pairs, the usual way to write memo: "QU SR NX IV PR DE". */
+export declare const formatMemo: (letters: readonly string[]) => string;
+/**
+ * The effect of one letter on the pieces of its kind: the buffer piece and
+ * the target's piece swap, the buffer sticker going to the target sticker
+ * (what the setup + T-perm / Y-perm + undo do to that kind of piece).
+ */
+export declare function swapToTarget(state: State, kind: "edge" | "corner", target: number, buffer?: number): State;
+/** Sticker positions of edges / corners (to compare only one kind of piece). */
+export declare const EDGE_POSITIONS: readonly number[];
+export declare const CORNER_POSITIONS: readonly number[];
+export declare const samePieces: (a: State, b: State, positions: readonly number[]) => boolean;
+/** Two sticker positions on the same edge / corner. */
+export declare const samePiece: (kind: "edge" | "corner", a: number, b: number) => boolean;
+/** The whole-cube rotation state with these centres (a solved cube as held), or null. */
+export declare const rotationState: (rotation: string | readonly Move[]) => State;