cubing 0.23.0 → 0.24.0-pre1

package/src/cubing/puzzles/stickerings/appearance.ts

@@ -1,292 +0,0 @@
-// TODO: figure out where to house this permanently.
-
-import { Move } from "../../alg";
-import { experimentalIs } from "../../alg";
-import { KPuzzleDefinition, transformationForMove } from "../../kpuzzle";
-
-export type FaceletMeshAppearance =
-  | "regular"
-  | "dim"
-  | "oriented"
-  | "ignored"
-  | "invisible";
-
-export type FaceletAppearance = {
-  appearance: FaceletMeshAppearance;
-  hintAppearance?: FaceletMeshAppearance;
-};
-
-export type PieceAppearance = {
-  // TODO: foundation?
-  facelets: (FaceletMeshAppearance | FaceletAppearance | null)[];
-};
-
-export type OrbitAppearance = {
-  pieces: (PieceAppearance | null)[];
-};
-
-export type PuzzleAppearance = {
-  name?: string; // TODO
-  orbits: Record<string, OrbitAppearance>;
-};
-
-export function getFaceletAppearance(
-  appearance: PuzzleAppearance,
-  orbitName: string,
-  pieceIdx: number,
-  faceletIdx: number,
-  hint: boolean,
-): FaceletMeshAppearance {
-  const orbitAppearance = appearance.orbits[orbitName];
-  const pieceAppearance: PieceAppearance | null =
-    orbitAppearance.pieces[pieceIdx];
-  if (pieceAppearance === null) {
-    return regular;
-  }
-  const faceletAppearance: FaceletMeshAppearance | FaceletAppearance | null =
-    pieceAppearance.facelets[faceletIdx];
-  if (faceletAppearance === null) {
-    return regular;
-  }
-  if (typeof faceletAppearance === "string") {
-    return faceletAppearance;
-  }
-  if (hint) {
-    return faceletAppearance.hintAppearance ?? faceletAppearance.appearance;
-  }
-  return faceletAppearance.appearance;
-}
-
-// TODO: Revert this to a normal enum, or write a standard to codify the names?
-export enum PieceStickering {
-  Regular = "Regular",
-  Dim = "Dim",
-  Ignored = "Ignored",
-  OrientationStickers = "OrientationStickers",
-  Invisible = "Invisible",
-  Ignoriented = "Ignoriented",
-  IgnoreNonPrimary = "IgnoreNonPrimary",
-  PermuteNonPrimary = "PermuteNonPrimary",
-  OrientationWithoutPermutation = "OrientationWithoutPermutation",
-}
-
-export class PieceAnnotation<T> {
-  stickerings: Map<string, T[]> = new Map();
-  constructor(def: KPuzzleDefinition, defaultValue: T) {
-    for (const [orbitName, orbitDef] of Object.entries(def.orbits)) {
-      this.stickerings.set(
-        orbitName,
-        new Array(orbitDef.numPieces).fill(defaultValue),
-      );
-    }
-  }
-}
-
-const regular = "regular";
-const ignored = "ignored";
-const oriented = "oriented";
-const invisible = "invisible";
-const dim = "dim";
-
-// regular
-const r: PieceAppearance = {
-  facelets: [regular, regular, regular, regular, regular],
-};
-
-// ignored
-const i: PieceAppearance = {
-  facelets: [ignored, ignored, ignored, ignored, ignored],
-};
-
-// oriented stickers
-const o: PieceAppearance = {
-  facelets: [oriented, oriented, oriented, oriented, oriented],
-};
-
-// invisible
-const invisiblePiece: PieceAppearance = {
-  facelets: [invisible, invisible, invisible, invisible], // TODO: 4th entry is for void cube. Should be handled properly for all stickerings.
-};
-
-// "OLL"
-const riiii: PieceAppearance = {
-  facelets: [regular, ignored, ignored, ignored, ignored],
-};
-
-// "PLL"
-const drrrr: PieceAppearance = {
-  facelets: [dim, regular, regular, regular, regular],
-};
-
-// ignored
-const d: PieceAppearance = {
-  facelets: [dim, dim, dim, dim, dim],
-};
-
-// "OLL"
-const diiii: PieceAppearance = {
-  facelets: [dim, ignored, ignored, ignored, ignored],
-};
-
-// oriented
-const oiiii: PieceAppearance = {
-  facelets: [oriented, ignored, ignored, ignored, ignored],
-};
-
-export function getPieceAppearance(
-  pieceStickering: PieceStickering,
-): PieceAppearance {
-  switch (pieceStickering) {
-    case PieceStickering.Regular:
-      return r;
-    case PieceStickering.Dim:
-      return d;
-    case PieceStickering.Ignored:
-      return i;
-    case PieceStickering.OrientationStickers: // TODO: Hack for centers. This shouldn't be needed.
-      return o;
-    case PieceStickering.Invisible: // TODO: Hack for centers. This shouldn't be needed.
-      return invisiblePiece;
-    case PieceStickering.IgnoreNonPrimary:
-      return riiii;
-    case PieceStickering.PermuteNonPrimary:
-      return drrrr;
-    case PieceStickering.Ignoriented:
-      return diiii;
-    case PieceStickering.OrientationWithoutPermutation:
-      return oiiii;
-  }
-}
-
-export class PuzzleStickering extends PieceAnnotation<PieceStickering> {
-  constructor(def: KPuzzleDefinition) {
-    super(def, PieceStickering.Regular);
-  }
-
-  set(pieceSet: PieceSet, pieceStickering: PieceStickering): PuzzleStickering {
-    for (const [orbitName, pieces] of this.stickerings.entries()) {
-      for (let i = 0; i < pieces.length; i++) {
-        if (pieceSet.stickerings.get(orbitName)![i]) {
-          pieces[i] = pieceStickering;
-        }
-      }
-    }
-    return this;
-  }
-
-  toAppearance(): PuzzleAppearance {
-    const appearance: PuzzleAppearance = { orbits: {} };
-    for (const [orbitName, pieceStickerings] of this.stickerings.entries()) {
-      const pieces: PieceAppearance[] = [];
-      const orbitAppearance: OrbitAppearance = {
-        pieces,
-      };
-      appearance.orbits[orbitName] = orbitAppearance;
-      for (const pieceStickering of pieceStickerings) {
-        pieces.push(getPieceAppearance(pieceStickering));
-      }
-    }
-    return appearance;
-  }
-}
-
-export type PieceSet = PieceAnnotation<boolean>;
-
-export class StickeringManager {
-  constructor(private def: KPuzzleDefinition) {}
-
-  and(pieceSets: PieceSet[]): PieceSet {
-    const newPieceSet = new PieceAnnotation<boolean>(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      pieceLoop: for (let i = 0; i < orbitDef.numPieces; i++) {
-        newPieceSet.stickerings.get(orbitName)![i] = true;
-        for (const pieceSet of pieceSets) {
-          if (!pieceSet.stickerings.get(orbitName)![i]) {
-            newPieceSet.stickerings.get(orbitName)![i] = false;
-            continue pieceLoop;
-          }
-        }
-      }
-    }
-    return newPieceSet;
-  }
-
-  or(pieceSets: PieceSet[]): PieceSet {
-    // TODO: unify impl with and?
-    const newPieceSet = new PieceAnnotation<boolean>(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      pieceLoop: for (let i = 0; i < orbitDef.numPieces; i++) {
-        newPieceSet.stickerings.get(orbitName)![i] = false;
-        for (const pieceSet of pieceSets) {
-          if (pieceSet.stickerings.get(orbitName)![i]) {
-            newPieceSet.stickerings.get(orbitName)![i] = true;
-            continue pieceLoop;
-          }
-        }
-      }
-    }
-    return newPieceSet;
-  }
-
-  not(pieceSet: PieceSet): PieceSet {
-    const newPieceSet = new PieceAnnotation<boolean>(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      for (let i = 0; i < orbitDef.numPieces; i++) {
-        newPieceSet.stickerings.get(orbitName)![i] =
-          !pieceSet.stickerings.get(orbitName)![i];
-      }
-    }
-    return newPieceSet;
-  }
-
-  all(): PieceSet {
-    return this.and(this.moves([])); // TODO: are the degenerate cases for and/or the wrong way around
-  }
-
-  move(moveSource: Move | string): PieceSet {
-    const transformation = transformationForMove(
-      this.def,
-      experimentalIs(moveSource, Move)
-        ? (moveSource as Move)
-        : Move.fromString(moveSource as string),
-    );
-    const newPieceSet = new PieceAnnotation<boolean>(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      for (let i = 0; i < orbitDef.numPieces; i++) {
-        if (
-          transformation[orbitName].permutation[i] !== i ||
-          transformation[orbitName].orientation[i] !== 0
-        ) {
-          newPieceSet.stickerings.get(orbitName)![i] = true;
-        }
-      }
-    }
-    return newPieceSet;
-  }
-
-  moves(moveSources: (Move | string)[]): PieceSet[] {
-    return moveSources.map((moveSource) => this.move(moveSource));
-  }
-
-  // orbits(orbitNames: string[]): PieceSet {
-  //   const pieceSet = new PieceAnnotation<boolean>(this.def, false);
-  //   for (const orbitName of orbitNames) {
-  //     pieceSet.stickerings.get(orbitName)!.fill(true);
-  //   }
-  //   return pieceSet;
-  // }
-
-  // trueCounts(pieceSet: PieceSet): Record<string, number> {
-  //   const counts: Record<string, number> = {};
-  //   for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-  //     let count = 0;
-  //     for (let i = 0; i < orbitDef.numPieces; i++) {
-  //       if (pieceSet.stickerings.get(orbitName)![i]) {
-  //         count++;
-  //       }
-  //     }
-  //     counts[orbitName] = count;
-  //   }
-  //   return counts;
-  // }
-}

package/src/cubing/puzzles/stickerings/cube-stickerings.ts

@@ -1,304 +0,0 @@
-import type { ExperimentalStickering } from "../../twisty";
-import type { PuzzleLoader } from "../PuzzleLoader";
-import {
-  PuzzleAppearance,
-  PuzzleStickering,
-  StickeringManager,
-  PieceSet,
-  PieceStickering,
-} from "./appearance";
-import { useGlobalCustomStickerer } from "./global-custom-stickering-hack";
-
-// TODO: cache calculations?
-export async function cubeAppearance(
-  puzzleLoader: PuzzleLoader,
-  stickering: ExperimentalStickering,
-): Promise<PuzzleAppearance> {
-  const def = await puzzleLoader.def();
-  const puzzleStickering = new PuzzleStickering(def);
-  const m = new StickeringManager(def);
-
-  const LL = (): PieceSet => m.move("U");
-  const orUD = (): PieceSet => m.or(m.moves(["U", "D"]));
-  const E = (): PieceSet => m.not(orUD());
-  const orLR = (): PieceSet => m.or(m.moves(["L", "R"]));
-  const M = (): PieceSet => m.not(orLR());
-  const orFB = (): PieceSet => m.or(m.moves(["F", "B"]));
-  const S = (): PieceSet => m.not(orFB());
-
-  const F2L = (): PieceSet => m.not(LL());
-
-  const centerU = (): PieceSet => m.and([LL(), M(), S()]);
-
-  const edgeFR = (): PieceSet =>
-    m.and([m.and(m.moves(["F", "R"])), m.not(orUD())]);
-  const cornerDFR = (): PieceSet => m.and(m.moves(["D", "R", "F"]));
-  const slotFR = (): PieceSet => m.or([cornerDFR(), edgeFR()]);
-
-  const CENTERS = (): PieceSet =>
-    m.or([m.and([M(), E()]), m.and([M(), S()]), m.and([E(), S()])]);
-  const EDGES = (): PieceSet =>
-    m.or([
-      m.and([M(), orUD(), orFB()]),
-      m.and([E(), orLR(), orFB()]),
-      m.and([S(), orUD(), orLR()]),
-    ]);
-  const CORNERS = (): PieceSet => m.not(m.or([CENTERS(), EDGES()]));
-  const L6E = (): PieceSet => m.or([M(), m.and([LL(), EDGES()])]);
-
-  function dimF2L(): void {
-    puzzleStickering.set(F2L(), PieceStickering.Dim);
-  }
-
-  function setPLL(): void {
-    puzzleStickering.set(LL(), PieceStickering.PermuteNonPrimary);
-    puzzleStickering.set(centerU(), PieceStickering.Dim); // TODO: why is this needed?
-  }
-
-  function setOLL(): void {
-    puzzleStickering.set(LL(), PieceStickering.IgnoreNonPrimary);
-    puzzleStickering.set(centerU(), PieceStickering.Regular); // TODO: why is this needed?
-  }
-
-  function dimOLL(): void {
-    puzzleStickering.set(LL(), PieceStickering.Ignoriented);
-    puzzleStickering.set(centerU(), PieceStickering.Dim); // TODO: why is this needed?
-  }
-
-  switch (stickering) {
-    case "full":
-      break;
-    case "PLL":
-      dimF2L();
-      setPLL();
-      break;
-    case "CLS":
-      dimF2L();
-      puzzleStickering.set(
-        m.and(m.moves(["D", "R", "F"])),
-        PieceStickering.Regular,
-      );
-      puzzleStickering.set(LL(), PieceStickering.Ignoriented);
-      puzzleStickering.set(
-        m.and([LL(), CORNERS()]),
-        PieceStickering.IgnoreNonPrimary,
-      );
-      break;
-    case "OLL":
-      dimF2L();
-      setOLL();
-      break;
-    case "COLL":
-      dimF2L();
-      setPLL();
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Regular);
-      break;
-    case "OCLL":
-      dimF2L();
-      dimOLL();
-      puzzleStickering.set(
-        m.and([LL(), CORNERS()]),
-        PieceStickering.IgnoreNonPrimary,
-      );
-      break;
-    case "CLL":
-      dimF2L();
-      puzzleStickering.set(
-        m.not(m.and([CORNERS(), LL()])),
-        PieceStickering.Dim,
-      );
-      break;
-    case "ELL":
-      dimF2L();
-      puzzleStickering.set(LL(), PieceStickering.Dim);
-      puzzleStickering.set(m.and([LL(), EDGES()]), PieceStickering.Regular);
-      break;
-    case "ELS":
-      dimF2L();
-      setOLL();
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Ignored);
-      puzzleStickering.set(edgeFR(), PieceStickering.Regular);
-      puzzleStickering.set(cornerDFR(), PieceStickering.Ignored);
-      break;
-    case "LL":
-      dimF2L();
-      break;
-    case "F2L":
-      puzzleStickering.set(LL(), PieceStickering.Ignored);
-      break;
-    case "ZBLL":
-      dimF2L();
-      puzzleStickering.set(LL(), PieceStickering.PermuteNonPrimary);
-      puzzleStickering.set(centerU(), PieceStickering.Dim); // why is this needed?
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Regular);
-      break;
-    case "ZBLS":
-      dimF2L();
-      puzzleStickering.set(slotFR(), PieceStickering.Regular);
-      setOLL();
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Ignored);
-      break;
-    case "WVLS":
-    // fallthrough
-    case "VLS":
-      dimF2L();
-      puzzleStickering.set(slotFR(), PieceStickering.Regular);
-      setOLL();
-      break;
-    case "LS":
-      dimF2L();
-      puzzleStickering.set(slotFR(), PieceStickering.Regular);
-      puzzleStickering.set(LL(), PieceStickering.Ignored);
-      puzzleStickering.set(centerU(), PieceStickering.Dim);
-      break;
-    case "EO":
-      puzzleStickering.set(CORNERS(), PieceStickering.Ignored);
-      puzzleStickering.set(
-        EDGES(),
-        PieceStickering.OrientationWithoutPermutation,
-      );
-      break;
-    case "EOline":
-      puzzleStickering.set(CORNERS(), PieceStickering.Ignored);
-      puzzleStickering.set(
-        EDGES(),
-        PieceStickering.OrientationWithoutPermutation,
-      );
-      puzzleStickering.set(m.and(m.moves(["D", "M"])), PieceStickering.Regular);
-      break;
-    case "EOcross":
-      puzzleStickering.set(
-        EDGES(),
-        PieceStickering.OrientationWithoutPermutation,
-      );
-      puzzleStickering.set(m.move("D"), PieceStickering.Regular);
-      puzzleStickering.set(CORNERS(), PieceStickering.Ignored);
-      break;
-    case "CMLL":
-      puzzleStickering.set(F2L(), PieceStickering.Dim);
-      puzzleStickering.set(L6E(), PieceStickering.Ignored);
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Regular);
-      break;
-    case "L6E":
-      puzzleStickering.set(m.not(L6E()), PieceStickering.Dim);
-      break;
-    case "L6EO":
-      puzzleStickering.set(m.not(L6E()), PieceStickering.Dim);
-      puzzleStickering.set(
-        L6E(),
-        PieceStickering.OrientationWithoutPermutation,
-      );
-      puzzleStickering.set(
-        m.and([CENTERS(), orUD()]),
-        PieceStickering.OrientationStickers,
-      ); // TODO: why is this needed?
-      break;
-    case "Daisy":
-      puzzleStickering.set(m.all(), PieceStickering.Ignored);
-      puzzleStickering.set(CENTERS(), PieceStickering.Dim);
-      puzzleStickering.set(
-        m.and([m.move("D"), CENTERS()]),
-        PieceStickering.Regular,
-      );
-      puzzleStickering.set(
-        m.and([m.move("U"), EDGES()]),
-        PieceStickering.IgnoreNonPrimary,
-      );
-      break;
-    case "Cross":
-      puzzleStickering.set(m.all(), PieceStickering.Ignored);
-      puzzleStickering.set(CENTERS(), PieceStickering.Dim);
-      puzzleStickering.set(
-        m.and([m.move("D"), CENTERS()]),
-        PieceStickering.Regular,
-      );
-      puzzleStickering.set(
-        m.and([m.move("D"), EDGES()]),
-        PieceStickering.Regular,
-      );
-      break;
-    case "2x2x2":
-      puzzleStickering.set(
-        m.or(m.moves(["U", "F", "R"])),
-        PieceStickering.Ignored,
-      );
-      puzzleStickering.set(
-        m.and([m.or(m.moves(["U", "F", "R"])), CENTERS()]),
-        PieceStickering.Dim,
-      );
-      break;
-    case "2x2x3":
-      puzzleStickering.set(m.all(), PieceStickering.Dim);
-      puzzleStickering.set(
-        m.or(m.moves(["U", "F", "R"])),
-        PieceStickering.Ignored,
-      );
-      puzzleStickering.set(
-        m.and([m.or(m.moves(["U", "F", "R"])), CENTERS()]),
-        PieceStickering.Dim,
-      );
-      puzzleStickering.set(
-        m.and([m.move("F"), m.not(m.or(m.moves(["U", "R"])))]),
-        PieceStickering.Regular,
-      );
-      break;
-    case "Void Cube":
-      puzzleStickering.set(CENTERS(), PieceStickering.Invisible);
-      break;
-    case "picture":
-    // fallthrough
-    case "invisible":
-      puzzleStickering.set(m.all(), PieceStickering.Invisible);
-      break;
-    case "centers-only":
-      puzzleStickering.set(m.not(CENTERS()), PieceStickering.Ignored);
-      break;
-    case "experimental-global-custom-1":
-    // fallthrough
-    case "experimental-global-custom-2":
-      useGlobalCustomStickerer(puzzleStickering, m);
-      break;
-    default:
-      console.warn(
-        `Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`,
-      );
-      puzzleStickering.set(m.and(m.moves([])), PieceStickering.Dim);
-  }
-  return puzzleStickering.toAppearance();
-}
-
-export async function cubeStickerings(): Promise<ExperimentalStickering[]> {
-  return [
-    "full",
-    "PLL",
-    "CLS",
-    "OLL",
-    "COLL",
-    "OCLL",
-    "ELL",
-    "ELS",
-    "LL",
-    "F2L",
-    "ZBLL",
-    "ZBLS",
-    "WVLS",
-    "VLS",
-    "LS",
-    "EO",
-    "EOline",
-    "EOcross",
-    "CMLL",
-    "L6E",
-    "L6EO",
-    "Daisy",
-    "Cross",
-    "2x2x2",
-    "2x2x3",
-    "Void Cube",
-    "picture",
-    "invisible",
-    "centers-only",
-    "experimental-global-custom-1",
-    "experimental-global-custom-2",
-  ];
-}

package/src/cubing/puzzles/stickerings/fto-stickerings.ts

@@ -1,105 +0,0 @@
-import type { ExperimentalStickering } from "../../twisty";
-import type { PuzzleLoader } from "../PuzzleLoader";
-import {
-  PuzzleAppearance,
-  PuzzleStickering,
-  StickeringManager,
-  PieceSet,
-  PieceStickering,
-} from "./appearance";
-
-export async function ftoStickering(
-  puzzleLoader: PuzzleLoader,
-  stickering: ExperimentalStickering,
-): Promise<PuzzleAppearance> {
-  const def = await puzzleLoader.def();
-  const puzzleStickering = new PuzzleStickering(def);
-  const m = new StickeringManager(def);
-
-  const experimentalFTO_FC = (): PieceSet =>
-    m.and([m.move("U"), m.not(m.or(m.moves(["F", "BL", "BR"])))]);
-  const experimentalFTO_F2T = (): PieceSet =>
-    m.and([m.move("U"), m.not(m.move("F"))]);
-  const experimentalFTO_SC = (): PieceSet =>
-    m.or([
-      experimentalFTO_F2T(),
-      m.and([m.move("F"), m.not(m.or(m.moves(["U", "BL", "BR"])))]),
-    ]);
-  const experimentalFTO_L2C = (): PieceSet =>
-    m.not(
-      m.or([
-        m.and([m.move("U"), m.move("F")]),
-        m.and([m.move("F"), m.move("BL")]),
-        m.and([m.move("F"), m.move("BR")]),
-        m.and([m.move("BL"), m.move("BR")]),
-      ]),
-    );
-  const experimentalFTO_LBT = (): PieceSet =>
-    m.not(
-      m.or([
-        m.and([m.move("F"), m.move("BL")]),
-        m.and([m.move("F"), m.move("BR")]),
-        m.and([m.move("BL"), m.move("BR")]),
-      ]),
-    );
-
-  switch (stickering) {
-    case "full":
-      break;
-    case "experimental-fto-fc":
-      puzzleStickering.set(
-        m.not(experimentalFTO_FC()),
-        PieceStickering.Ignored,
-      );
-      break;
-    case "experimental-fto-f2t":
-      puzzleStickering.set(
-        m.not(experimentalFTO_F2T()),
-        PieceStickering.Ignored,
-      );
-      puzzleStickering.set(experimentalFTO_FC(), PieceStickering.Dim);
-      break;
-    case "experimental-fto-sc":
-      puzzleStickering.set(
-        m.not(experimentalFTO_SC()),
-        PieceStickering.Ignored,
-      );
-      puzzleStickering.set(experimentalFTO_F2T(), PieceStickering.Dim);
-      break;
-    case "experimental-fto-l2c":
-      puzzleStickering.set(
-        m.not(experimentalFTO_L2C()),
-        PieceStickering.Ignored,
-      );
-      puzzleStickering.set(experimentalFTO_SC(), PieceStickering.Dim);
-      break;
-    case "experimental-fto-lbt":
-      puzzleStickering.set(
-        m.not(experimentalFTO_LBT()),
-        PieceStickering.Ignored,
-      );
-      puzzleStickering.set(experimentalFTO_L2C(), PieceStickering.Dim);
-      break;
-    case "experimental-fto-l3t":
-      puzzleStickering.set(experimentalFTO_LBT(), PieceStickering.Dim);
-      break;
-    default:
-      console.warn(
-        `Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`,
-      );
-      puzzleStickering.set(m.and(m.moves([])), PieceStickering.Dim);
-  }
-  return puzzleStickering.toAppearance();
-}
-
-export async function ftoStickerings(): Promise<ExperimentalStickering[]> {
-  return [
-    "full",
-    "experimental-fto-fc",
-    "experimental-fto-f2t",
-    "experimental-fto-sc",
-    "experimental-fto-l2c",
-    "experimental-fto-lbt",
-    "experimental-fto-l3t",
-  ];
-}