@wodzik/cubecore 0.1.0

package/core/arrows.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Turn arrows — what an arrow over a 3D cube needs to show a move: which
+ * layers turn, about which axis, which way and how far, in the CUBE'S OWN
+ * coordinates (its centres). A renderer draws one arrow per layer, so a wide
+ * r gets two, a rotation three.
+ *
+ * `frame` is how the cube is held (OrientationTracker / SequenceTracker):
+ * after an x in the algorithm, the U you're asked to turn is the physical F,
+ * and its arrow belongs there.
+ */
+import { type Frame } from "./frames.js";
+import { type Axis } from "./geometry.js";
+import { type Move } from "./moves.js";
+export interface TurnArrow {
+    axis: Axis;
+    /** Layer coordinates along the axis (-1, 0, 1) that turn — one arrow each. */
+    layers: number[];
+    /**
+     * Counter-clockwise quarter turns about +axis, the way it's written: ±1 a
+     * single turn, ±2 a double (R2' = the other way than R2), ±3 a triple.
+     */
+    quarters: number;
+}
+export declare function turnArrow(move: Move, frame?: Frame): TurnArrow;

package/core/arrows.js

@@ -0,0 +1,22 @@
+/**
+ * Turn arrows — what an arrow over a 3D cube needs to show a move: which
+ * layers turn, about which axis, which way and how far, in the CUBE'S OWN
+ * coordinates (its centres). A renderer draws one arrow per layer, so a wide
+ * r gets two, a rotation three.
+ *
+ * `frame` is how the cube is held (OrientationTracker / SequenceTracker):
+ * after an x in the algorithm, the U you're asked to turn is the physical F,
+ * and its arrow belongs there.
+ */
+import { IDENTITY_FRAME } from "./frames.js";
+import { apply } from "./geometry.js";
+import { FAMILY, writtenQuarters } from "./moves.js";
+export function turnArrow(move, frame = IDENTITY_FRAME) {
+    const def = FAMILY[move.family];
+    const unit = [0, 0, 0];
+    unit[def.axis] = 1;
+    const v = apply(frame.matrix, unit);
+    const axis = v.findIndex((c) => c !== 0);
+    const sign = v[axis];
+    return { axis, layers: def.layers.map((l) => l * sign), quarters: def.q * writtenQuarters(move) * sign };
+}

package/core/bytes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Byte helpers for compact, URL-safe encodings (state codec here, recordings
+ * and share links in @cubecore/timeline): unsigned LEB128 varints, fixed-width
+ * bit packing, base64url without padding. Readers are strict: running out of
+ * bytes returns null instead of throwing.
+ */
+export declare function writeVarint(out: number[], value: number): void;
+/** Append `values`, each `width` bits (≤ 24), least significant first. */
+export declare function packBits(out: number[], values: readonly number[], width: number): void;
+/** Append fields of different widths (each ≤ 24 bits) as one bit stream. */
+export declare function packFields(out: number[], values: readonly number[], widths: readonly number[]): void;
+export declare function writeText(out: number[], text: string): void;
+export declare class ByteReader {
+    private readonly b;
+    pos: number;
+    constructor(b: Uint8Array);
+    byte(): number | null;
+    varint(): number | null;
+    packed(count: number, width: number): number[] | null;
+    /** Read fields written by `packFields`. */
+    fields(widths: readonly number[]): number[] | null;
+    bytes(count: number): Uint8Array | null;
+    text(maxBytes?: number): string | null;
+    get done(): boolean;
+}
+export declare const toBase64Url: (bytes: readonly number[] | Uint8Array) => string;
+export declare function fromBase64Url(text: string): Uint8Array | null;

package/core/bytes.js

@@ -0,0 +1,145 @@
+/**
+ * Byte helpers for compact, URL-safe encodings (state codec here, recordings
+ * and share links in @cubecore/timeline): unsigned LEB128 varints, fixed-width
+ * bit packing, base64url without padding. Readers are strict: running out of
+ * bytes returns null instead of throwing.
+ */
+export function writeVarint(out, value) {
+    let n = Math.max(0, Math.floor(value));
+    while (n >= 128) {
+        out.push((n % 128) | 128);
+        n = Math.floor(n / 128);
+    }
+    out.push(n);
+}
+/** Append `values`, each `width` bits (≤ 24), least significant first. */
+export function packBits(out, values, width) {
+    let acc = 0, bits = 0;
+    for (const v of values) {
+        acc |= v << bits;
+        bits += width;
+        while (bits >= 8) {
+            out.push(acc & 255);
+            acc >>>= 8;
+            bits -= 8;
+        }
+    }
+    if (bits > 0)
+        out.push(acc & 255);
+}
+/** Append fields of different widths (each ≤ 24 bits) as one bit stream. */
+export function packFields(out, values, widths) {
+    let acc = 0, bits = 0;
+    values.forEach((v, i) => {
+        acc |= v << bits;
+        bits += widths[i];
+        while (bits >= 8) {
+            out.push(acc & 255);
+            acc >>>= 8;
+            bits -= 8;
+        }
+    });
+    if (bits > 0)
+        out.push(acc & 255);
+}
+export function writeText(out, text) {
+    const bytes = new TextEncoder().encode(text);
+    writeVarint(out, bytes.length);
+    out.push(...bytes);
+}
+export class ByteReader {
+    b;
+    pos = 0;
+    constructor(b) {
+        this.b = b;
+    }
+    byte() {
+        return this.pos < this.b.length ? this.b[this.pos++] : null;
+    }
+    varint() {
+        let r = 0, scale = 1;
+        for (let i = 0; i < 7; i++) {
+            const x = this.byte();
+            if (x === null)
+                return null;
+            r += (x & 127) * scale;
+            if (x < 128)
+                return r;
+            scale *= 128;
+        }
+        return null;
+    }
+    packed(count, width) {
+        const need = Math.ceil((count * width) / 8);
+        if (this.pos + need > this.b.length)
+            return null;
+        const out = [];
+        let acc = 0, bits = 0, p = this.pos;
+        for (let i = 0; i < count; i++) {
+            while (bits < width) {
+                acc |= this.b[p++] << bits;
+                bits += 8;
+            }
+            out.push(acc & ((1 << width) - 1));
+            acc >>>= width;
+            bits -= width;
+        }
+        this.pos += need;
+        return out;
+    }
+    /** Read fields written by `packFields`. */
+    fields(widths) {
+        const total = widths.reduce((a, b) => a + b, 0);
+        const need = Math.ceil(total / 8);
+        if (this.pos + need > this.b.length)
+            return null;
+        const out = [];
+        let acc = 0, bits = 0, p = this.pos;
+        for (const w of widths) {
+            while (bits < w) {
+                acc |= this.b[p++] << bits;
+                bits += 8;
+            }
+            out.push(acc & ((1 << w) - 1));
+            acc >>>= w;
+            bits -= w;
+        }
+        this.pos += need;
+        return out;
+    }
+    bytes(count) {
+        if (this.pos + count > this.b.length)
+            return null;
+        const out = this.b.slice(this.pos, this.pos + count);
+        this.pos += count;
+        return out;
+    }
+    text(maxBytes = 256) {
+        const n = this.varint();
+        if (n === null || n > maxBytes)
+            return null;
+        const raw = this.bytes(n);
+        if (!raw)
+            return null;
+        try {
+            return new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    get done() {
+        return this.pos === this.b.length;
+    }
+}
+export const toBase64Url = (bytes) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+export function fromBase64Url(text) {
+    if (!/^[A-Za-z0-9_-]*$/.test(text) || text.length % 4 === 1)
+        return null;
+    try {
+        return Uint8Array.from(atob(text.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0));
+    }
+    catch {
+        return null;
+    }
+}

package/core/centers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Centre spin — the one thing a facelet permutation can't express. After U the
+ * U centre is still at facelet 4, but it has turned a quarter; a logo or an
+ * arrow drawn on it has to turn too. Supercube-style puzzles (and pictures
+ * with a brand logo) need it; solving never does.
+ *
+ * `CenterSpins[c]` belongs to the centre whose home face is `c` (U R F D L B)
+ * and counts counter-clockwise quarter turns (seen from outside) of that
+ * centre relative to `FACE_BASIS` of the face it currently sits on: spin 0 =
+ * the sticker's "up" points along that face's `b` axis.
+ */
+import { type Face, type Vec3 } from "./geometry.js";
+import { type Move } from "./moves.js";
+import { type State } from "./state.js";
+export type CenterSpins = Uint8Array;
+export declare const solvedSpins: () => CenterSpins;
+/** Direction the centre's "up" points when it sits on `face` with spin `spin`. */
+export declare function centerUp(face: Face, spin: number): Vec3;
+/** Spins after `move` is applied to `state` (the state BEFORE the move). */
+export declare function advanceSpins(spins: CenterSpins, state: State, move: Move): CenterSpins;
+/** Spins after a sequence of moves from `start` (whose spins default to 0). */
+export declare function spinsAfter(start: State, moves: readonly Move[] | string, spins?: CenterSpins): CenterSpins;
+/**
+ * How far sticker `sticker` (a home facelet index) is turned in its face's
+ * plane — counter-clockwise quarter turns relative to `FACE_BASIS` of the
+ * face it currently sits on, compared with how it sat at home. Anything drawn
+ * on a sticker (a logo, a decal, holes) turns by this much.
+ *
+ * Centres: their spin (`spins`, see above). Edges and corners: read off the
+ * piece itself — the direction towards one of its other stickers.
+ */
+export declare function stickerTurn(state: State, sticker: number, spins?: CenterSpins): number;

package/core/centers.js

@@ -0,0 +1,83 @@
+/**
+ * Centre spin — the one thing a facelet permutation can't express. After U the
+ * U centre is still at facelet 4, but it has turned a quarter; a logo or an
+ * arrow drawn on it has to turn too. Supercube-style puzzles (and pictures
+ * with a brand logo) need it; solving never does.
+ *
+ * `CenterSpins[c]` belongs to the centre whose home face is `c` (U R F D L B)
+ * and counts counter-clockwise quarter turns (seen from outside) of that
+ * centre relative to `FACE_BASIS` of the face it currently sits on: spin 0 =
+ * the sticker's "up" points along that face's `b` axis.
+ */
+import { CUBIE_OF_FACELET, FACE_BASIS, FACELETS, faceOfNormal, rotate } from "./geometry.js";
+import { FAMILY } from "./moves.js";
+import { parseAlg } from "./notation.js";
+import { applyMove } from "./state.js";
+export const solvedSpins = () => new Uint8Array(6);
+const eq = (p, q) => p[0] === q[0] && p[1] === q[1] && p[2] === q[2];
+/** `v` turned `q` CCW quarters about the outward normal of `face`. */
+function aboutNormal(v, face, q) {
+    const n = FACE_BASIS[face].n;
+    const axis = n[0] !== 0 ? 0 : n[1] !== 0 ? 1 : 2;
+    return rotate(v, axis, q * n[axis]);
+}
+/** Direction the centre's "up" points when it sits on `face` with spin `spin`. */
+export function centerUp(face, spin) {
+    return aboutNormal(FACE_BASIS[face].b, face, spin);
+}
+/** Spins after `move` is applied to `state` (the state BEFORE the move). */
+export function advanceSpins(spins, state, move) {
+    const def = FAMILY[move.family];
+    const quarters = def.q * (move.amount === -1 ? -1 : move.amount === 2 ? 2 : 1);
+    const out = new Uint8Array(spins);
+    for (let c = 0; c < 6; c++) {
+        const f = FACELETS[state.indexOf(c * 9 + 4)];
+        if (!def.layers.includes(f.pos[def.axis]))
+            continue;
+        const up = rotate(centerUp(f.face, spins[c]), def.axis, quarters);
+        const face = faceOfNormal(rotate(f.normal, def.axis, quarters));
+        for (let k = 0; k < 4; k++)
+            if (eq(centerUp(face, k), up))
+                out[c] = k;
+    }
+    return out;
+}
+/** Spins after a sequence of moves from `start` (whose spins default to 0). */
+export function spinsAfter(start, moves, spins = solvedSpins()) {
+    let s = start;
+    let out = spins;
+    for (const m of typeof moves === "string" ? parseAlg(moves) : moves) {
+        out = advanceSpins(out, s, m);
+        s = applyMove(s, m);
+    }
+    return out;
+}
+/**
+ * How far sticker `sticker` (a home facelet index) is turned in its face's
+ * plane — counter-clockwise quarter turns relative to `FACE_BASIS` of the
+ * face it currently sits on, compared with how it sat at home. Anything drawn
+ * on a sticker (a logo, a decal, holes) turns by this much.
+ *
+ * Centres: their spin (`spins`, see above). Edges and corners: read off the
+ * piece itself — the direction towards one of its other stickers.
+ */
+export function stickerTurn(state, sticker, spins = solvedSpins()) {
+    if (sticker % 9 === 4)
+        return spins[Math.floor(sticker / 9)];
+    const home = FACELETS[sticker];
+    const partner = CUBIE_OF_FACELET[sticker].facelets.find((f) => f !== sticker);
+    const now = FACELETS[state.indexOf(sticker)];
+    const partnerNow = FACELETS[state.indexOf(partner)];
+    const inPlane = (face, dir) => {
+        const { a, b } = FACE_BASIS[face];
+        return [dir[0] * a[0] + dir[1] * a[1] + dir[2] * a[2], dir[0] * b[0] + dir[1] * b[1] + dir[2] * b[2]];
+    };
+    let d = inPlane(home.face, FACELETS[partner].normal);
+    const target = inPlane(now.face, partnerNow.normal);
+    for (let k = 0; k < 4; k++) {
+        if (d[0] === target[0] && d[1] === target[1])
+            return k;
+        d = [-d[1], d[0]];
+    }
+    return 0;
+}

package/core/checks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Check primitives, written for the CANONICAL frame (run them on
+ * `view(state, frame)`): first layer on D, last layer on U. Method packages
+ * (@cubecore/cfop, roux, zz, petrus, lbl) build their stages from these, so
+ * every method is colour neutral by construction.
+ *
+ * "Solved" pieces show the colour of the centre of the face they sit on. No
+ * absolute colours anywhere — methods that move centres (Roux M slices)
+ * compare pieces to each other with the helpers below instead.
+ */
+import { type Cubie, type Face, type Vec3 } from "./geometry.js";
+import { type State, isSolved } from "./state.js";
+/** Facelet index of a face's centre. */
+export declare const centerIdx: (face: Face) => number;
+/** Colour class of the opposite face (U↔D, R↔L, F↔B). */
+export declare const opposite: (color: number) => number;
+export declare function cubieAt(x: number, y: number, z: number): Cubie;
+export declare const cubiesWhere: (pred: (p: Vec3) => boolean) => Cubie[];
+/** Facelet of `cubie` that faces `face`, or undefined. */
+export declare function faceletOn(cubie: Cubie, face: Face): number | undefined;
+export declare const matchesCenter: (s: State, facelet: number) => boolean;
+export declare const cubieSolved: (s: State, c: Cubie) => boolean;
+export declare const allSolved: (s: State, cubies: readonly Cubie[]) => boolean;
+export declare function upToAuf(s: State, pred: (s: State) => boolean): boolean;
+export type Slot = "FR" | "FL" | "BR" | "BL";
+export declare const SLOTS: readonly Slot[];
+export declare const U_CORNERS: Cubie[];
+export declare const U_EDGES: Cubie[];
+export declare const crossSolved: (s: State) => boolean;
+export declare const firstLayerSolved: (s: State) => boolean;
+export declare const f2lSolved: (s: State) => boolean;
+export declare const pairSolved: (s: State, slot: Slot) => boolean;
+export declare const slotCornerSolved: (s: State, slot: Slot) => boolean;
+export declare const slotEdgeSolved: (s: State, slot: Slot) => boolean;
+export declare const solvedPairs: (s: State) => Slot[];
+export declare const topColor: (s: State) => number;
+/** OLL: the whole top face shows the top centre's colour. */
+export declare const topOriented: (s: State) => boolean;
+export declare const topCornersOriented: (s: State) => boolean;
+export declare const topEdgesOriented: (s: State) => boolean;
+/** PLL done, possibly short of the final U turn (AUF). */
+export declare const solvedUpToAuf: (s: State) => boolean;
+/** Last-layer corners in place (relative to each other and F2L), up to AUF. */
+export declare const llCornersPermuted: (s: State) => boolean;
+/**
+ * EO for the F/B axis (ZZ, Petrus): an edge is good if it can be solved
+ * without F/B quarter turns. Look at its sticker on U/D (or, for an E-slice
+ * edge, on F/B): U/D colour → good, L/R colour → bad, F/B colour → bad only
+ * if the other sticker is a U/D colour.
+ */
+export declare function edgeOrientedFB(s: State, edge: Cubie): boolean;
+export declare const edgesOrientedFB: (s: State) => boolean;
+export { isSolved };

package/core/checks.js

@@ -0,0 +1,85 @@
+/**
+ * Check primitives, written for the CANONICAL frame (run them on
+ * `view(state, frame)`): first layer on D, last layer on U. Method packages
+ * (@cubecore/cfop, roux, zz, petrus, lbl) build their stages from these, so
+ * every method is colour neutral by construction.
+ *
+ * "Solved" pieces show the colour of the centre of the face they sit on. No
+ * absolute colours anywhere — methods that move centres (Roux M slices)
+ * compare pieces to each other with the helpers below instead.
+ */
+import { CUBIES, FACELETS, FACES } from "./geometry.js";
+import { parseAlg } from "./notation.js";
+import { applyMoves, colorAt, isSolved } from "./state.js";
+// ─── helpers ───
+const faceIndex = (face) => FACES.indexOf(face);
+/** Facelet index of a face's centre. */
+export const centerIdx = (face) => faceIndex(face) * 9 + 4;
+/** Colour class of the opposite face (U↔D, R↔L, F↔B). */
+export const opposite = (color) => (color + 3) % 6;
+export function cubieAt(x, y, z) {
+    return CUBIES.find((c) => c.pos[0] === x && c.pos[1] === y && c.pos[2] === z);
+}
+export const cubiesWhere = (pred) => CUBIES.filter((c) => pred(c.pos));
+/** Facelet of `cubie` that faces `face`, or undefined. */
+export function faceletOn(cubie, face) {
+    return cubie.facelets.find((f) => FACELETS[f].face === face);
+}
+export const matchesCenter = (s, facelet) => colorAt(s, facelet) === colorAt(s, centerIdx(FACELETS[facelet].face));
+export const cubieSolved = (s, c) => c.facelets.every((f) => matchesCenter(s, f));
+export const allSolved = (s, cubies) => cubies.every((c) => cubieSolved(s, c));
+/** True if some U-layer turn (none, U, U2, U') makes `pred` hold. */
+const U_TURNS = [[], parseAlg("U"), parseAlg("U2"), parseAlg("U'")];
+export function upToAuf(s, pred) {
+    return U_TURNS.some((t) => pred(t.length ? applyMoves(s, t) : s));
+}
+export const SLOTS = ["FR", "FL", "BR", "BL"];
+const SLOT_XZ = { FR: [1, 1], FL: [-1, 1], BR: [1, -1], BL: [-1, -1] };
+const slotCorner = (slot) => cubieAt(SLOT_XZ[slot][0], -1, SLOT_XZ[slot][1]);
+const slotEdge = (slot) => cubieAt(SLOT_XZ[slot][0], 0, SLOT_XZ[slot][1]);
+// ─── layers (first layer on D) ───
+const CROSS = cubiesWhere((p) => p[1] === -1 && p.filter((v) => v !== 0).length === 2);
+const FIRST_LAYER = cubiesWhere((p) => p[1] === -1);
+const F2L = cubiesWhere((p) => p[1] <= 0);
+export const U_CORNERS = cubiesWhere((p) => p[1] === 1 && p[0] !== 0 && p[2] !== 0);
+export const U_EDGES = cubiesWhere((p) => p[1] === 1 && (p[0] === 0) !== (p[2] === 0));
+export const crossSolved = (s) => allSolved(s, CROSS);
+export const firstLayerSolved = (s) => allSolved(s, FIRST_LAYER);
+export const f2lSolved = (s) => allSolved(s, F2L);
+export const pairSolved = (s, slot) => cubieSolved(s, slotCorner(slot)) && cubieSolved(s, slotEdge(slot));
+export const slotCornerSolved = (s, slot) => cubieSolved(s, slotCorner(slot));
+export const slotEdgeSolved = (s, slot) => cubieSolved(s, slotEdge(slot));
+export const solvedPairs = (s) => SLOTS.filter((slot) => pairSolved(s, slot));
+export const topColor = (s) => colorAt(s, centerIdx("U"));
+const onTop = (s, cubies) => cubies.every((c) => colorAt(s, faceletOn(c, "U")) === topColor(s));
+/** OLL: the whole top face shows the top centre's colour. */
+export const topOriented = (s) => onTop(s, U_CORNERS) && onTop(s, U_EDGES);
+export const topCornersOriented = (s) => onTop(s, U_CORNERS);
+export const topEdgesOriented = (s) => onTop(s, U_EDGES);
+/** PLL done, possibly short of the final U turn (AUF). */
+export const solvedUpToAuf = (s) => upToAuf(s, isSolved);
+/** Last-layer corners in place (relative to each other and F2L), up to AUF. */
+export const llCornersPermuted = (s) => upToAuf(s, (t) => allSolved(t, U_CORNERS));
+// ─── Edge orientation ───
+/**
+ * EO for the F/B axis (ZZ, Petrus): an edge is good if it can be solved
+ * without F/B quarter turns. Look at its sticker on U/D (or, for an E-slice
+ * edge, on F/B): U/D colour → good, L/R colour → bad, F/B colour → bad only
+ * if the other sticker is a U/D colour.
+ */
+export function edgeOrientedFB(s, edge) {
+    const ud = [colorAt(s, centerIdx("U")), colorAt(s, centerIdx("D"))];
+    const lr = [colorAt(s, centerIdx("L")), colorAt(s, centerIdx("R"))];
+    const primaryFaces = edge.pos[1] !== 0 ? ["U", "D"] : ["F", "B"];
+    const primary = edge.facelets.find((f) => primaryFaces.includes(FACELETS[f].face));
+    const other = edge.facelets.find((f) => f !== primary);
+    const c = colorAt(s, primary);
+    if (ud.includes(c))
+        return true;
+    if (lr.includes(c))
+        return false;
+    return !ud.includes(colorAt(s, other));
+}
+const EDGES = CUBIES.filter((c) => c.kind === "edge");
+export const edgesOrientedFB = (s) => EDGES.every((e) => edgeOrientedFB(s, e));
+export { isSolved };

package/core/cubies.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The cube as pieces: corner / edge permutation and orientation in the
+ * standard (Kociemba) numbering, plus how the centres are turned (a Frame).
+ * The compact state codec and the two-phase solver work on this; everything
+ * else in cubecore uses the 54-sticker State.
+ *
+ * Corners URF UFL ULB UBR DFR DLF DBL DRB, edges UR UF UL UB DR DF DL DB FR FL
+ * BL BR. Corner twist counts how far the U/D sticker is turned from the U/D
+ * position (0..2, clockwise); an edge is flipped (1) when its first sticker —
+ * the U/D one, or F/B for the middle-layer edges — isn't in the first place.
+ */
+import { type Frame } from "./frames.js";
+import type { State } from "./state.js";
+/** Facelets of each corner position, U/D sticker first, then clockwise. */
+export declare const CORNER_FACELETS: readonly (readonly [number, number, number])[];
+/** Facelets of each edge position, the reference sticker first. */
+export declare const EDGE_FACELETS: readonly (readonly [number, number])[];
+export interface CubieState {
+    /** How the centres are turned (FRAMES id 0 = at home). */
+    frame: Frame;
+    cp: number[];
+    co: number[];
+    ep: number[];
+    eo: number[];
+}
+/** Pieces of a state, or null if it isn't made of real pieces. */
+export declare function toCubies(state: State): CubieState | null;
+export declare function fromCubies(c: CubieState): State;
+/** Parity of a permutation (0 even, 1 odd). */
+export declare function parity(p: readonly number[]): number;
+/** Reachable by turning (not a reassembled cube): twist sum ≡ 0 mod 3, flips even, equal parities. */
+export declare function isSolvable(c: CubieState): boolean;
+/** Lehmer rank of a permutation of 0..n-1: 0 .. n!-1. */
+export declare function permRank(p: readonly number[]): number;
+export declare function permUnrank(rank: number, n: number): number[];
+/**
+ * A state from a 54-letter facelet string (Kociemba order U1…U9 R1… F1… D1…
+ * L1… B1…, each letter the face whose colour is there) — what smart cubes
+ * report and many tools exchange. Colours are read against the centres, so
+ * any letters work as long as each centre has its own. Null if the string
+ * isn't a reachable cube.
+ */
+export declare function stateFromFacelets(text: string): State | null;
+/** The 54-letter facelet string of a state (each letter = the colour class's home face). */
+export declare function faceletsOf(state: State): string;