cubing 0.23.0 → 0.24.0-pre4

package/dist/esm/twisty/index.js

@@ -1,36 +1,27 @@
 import {
-  Cube3D,
   DEGREES_PER_RADIAN,
   FreshListenerManager,
   HintFaceletProp,
   NO_VALUE,
-  PG3D,
   SimpleTwistyPropSource,
   StaleDropper,
   StickeringProp,
+  THREEJS,
   TwistyPropDerived,
   TwistyPropSource,
-  from
-} from "../chunk-N3RNWU5T.js";
+  proxy3D
+} from "../chunk-UYT3253Q.js";
 import {
   countAnimatedLeaves,
   countMoves
-} from "../chunk-4IUYLRHT.js";
+} from "../chunk-U2TSTTDG.js";
 import {
   cube3x3x3,
   cubeAppearance,
   customPGPuzzleLoader,
   puzzles
-} from "../chunk-DK6PXBB2.js";
-import {
-  KPuzzle,
-  KPuzzleSVGWrapper,
-  areStatesEquivalent,
-  combineTransformations,
-  identityTransformation,
-  invertTransformation,
-  transformationForMove
-} from "../chunk-X6JHXPDX.js";
+} from "../chunk-2IHGN4YF.js";
+import "../chunk-Z36TNZT2.js";
 import {
   Alg,
   AlgBuilder,
@@ -267,7 +258,7 @@ var TwistyAnimationController = class {
       this.lastTimestampPromise,
       this.model.timeRangeProp.get(),
       this.model.tempoScaleProp.get(),
-      this.model.currentLeavesProp.get()
+      this.model.currentMoveInfoProp.get()
     ]));
     const [playingInfo, lastTimestamp, timeRange, tempoScale, currentMoveInfo] = freshenerResult;
     if (!playingInfo.playing) {
@@ -364,37 +355,6 @@ var ControlPanelProp = class extends SimpleTwistyPropSource {
   }
 };
 
-// src/cubing/twisty/views/ClassListManager.ts
-var _currentClassName;
-var ClassListManager = class {
-  constructor(elem, prefix, validSuffixes) {
-    this.elem = elem;
-    this.prefix = prefix;
-    this.validSuffixes = validSuffixes;
-    __privateAdd(this, _currentClassName, null);
-  }
-  clearValue() {
-    if (__privateGet(this, _currentClassName)) {
-      this.elem.contentWrapper.classList.remove(__privateGet(this, _currentClassName));
-    }
-    __privateSet(this, _currentClassName, null);
-  }
-  setValue(suffix) {
-    if (!this.validSuffixes.includes(suffix)) {
-      throw new Error(`Invalid suffix: ${suffix}`);
-    }
-    const newClassName = `${this.prefix}${suffix}`;
-    const changed = __privateGet(this, _currentClassName) !== newClassName;
-    if (changed) {
-      this.clearValue();
-      this.elem.contentWrapper.classList.add(newClassName);
-      __privateSet(this, _currentClassName, newClassName);
-    }
-    return changed;
-  }
-};
-_currentClassName = new WeakMap();
-
 // src/cubing/twisty/views/node-custom-element-shims.ts
 var HTMLElementStub = class {
 };
@@ -464,85 +424,6 @@ var ManagedCustomElement = class extends HTMLElementShim {
 _cssSourceMap = new WeakMap();
 customElementsShim.define("twisty-managed-custom-element", ManagedCustomElement);
 
-// src/cubing/twisty/views/TwistyPlayer.css.ts
-var twistyPlayerCSS = new CSSSource(`
-:host {
-  width: 384px;
-  height: 256px;
-  display: grid;
-
-  -webkit-user-select: none;
-  user-select: none;
-}
-
-.wrapper {
-  display: grid;
-  overflow: hidden;
-  grid-template-rows: 7fr 1em 1fr;
-}
-
-.wrapper > * {
-  width: inherit;
-  height: inherit;
-  overflow: hidden;
-}
-
-.wrapper.controls-none {
-  grid-template-rows: 7fr;
-}
-
-.wrapper.controls-none twisty-scrubber,
-.wrapper.controls-none twisty-control-button-panel ,
-.wrapper.controls-none twisty-scrubber-v2,
-.wrapper.controls-none twisty-buttons-v2 {
-  display: none;
-}
-
-twisty-scrubber {
-  background: rgba(196, 196, 196, 0.5);
-}
-
-.wrapper.checkered {
-  background-color: #EAEAEA;
-  background-image: linear-gradient(45deg, #DDD 25%, transparent 25%, transparent 75%, #DDD 75%, #DDD),
-    linear-gradient(45deg, #DDD 25%, transparent 25%, transparent 75%, #DDD 75%, #DDD);
-  background-size: 32px 32px;
-  background-position: 0 0, 16px 16px;
-}
-
-.visualization-wrapper > * {
-  width: 100%;
-  height: 100%;
-}
-
-.error-elem {
-  width: 100%;
-  height: 100%;
-  display: none;
-  place-content: center;
-  font-family: sans-serif;
-  box-shadow: inset 0 0 2em rgb(255, 0, 0);
-  color: red;
-  text-shadow: 0 0 0.2em white;
-  background: rgba(255, 255, 255, 0.25);
-}
-
-.wrapper.error .visualization-wrapper {
-  display: none;
-}
-
-.wrapper.error .error-elem {
-  display: grid;
-}
-`);
-
-// src/cubing/twisty/heavy-code-imports/3d.ts
-var cachedConstructorProxy = null;
-async function proxy3D() {
-  return cachedConstructorProxy ?? (cachedConstructorProxy = import("../3d-Q4WSD4BC.js"));
-}
-var THREEJS = from(async () => (await proxy3D()).T3I);
-
 // src/cubing/twisty/views/TwistyViewerWrapper.css.ts
 var twistyViewerWrapperCSS = new CSSSource(`
 :host {
@@ -609,12 +490,196 @@ svg {
 }
 `);
 
+// src/cubing/twisty/views/2D/KPuzzleSVGWrapper.ts
+var xmlns = "http://www.w3.org/2000/svg";
+var svgCounter = 0;
+function nextSVGID() {
+  svgCounter += 1;
+  return "svg" + svgCounter.toString();
+}
+var colorMaps = {
+  dim: {
+    "white": "#dddddd",
+    "orange": "#884400",
+    "limegreen": "#008800",
+    "red": "#660000",
+    "rgb(34, 102, 255)": "#000088",
+    "yellow": "#888800"
+  },
+  oriented: {
+    "white": "#ff88ff",
+    "orange": "#ff88ff",
+    "limegreen": "#ff88ff",
+    "red": "#ff88ff",
+    "rgb(34, 102, 255)": "#ff88ff",
+    "yellow": "#ff88ff"
+  },
+  ignored: {
+    "white": "#444444",
+    "orange": "#444444",
+    "limegreen": "#444444",
+    "red": "#444444",
+    "rgb(34, 102, 255)": "#444444",
+    "yellow": "#444444"
+  },
+  invisible: {
+    "white": "#00000000",
+    "orange": "#00000000",
+    "limegreen": "#00000000",
+    "red": "#00000000",
+    "rgb(34, 102, 255)": "#00000000",
+    "yellow": "#00000000"
+  }
+};
+var KPuzzleSVGWrapper = class {
+  constructor(kpuzzle, svgSource, experimentalAppearance) {
+    this.kpuzzle = kpuzzle;
+    this.originalColors = {};
+    this.gradients = {};
+    if (!svgSource) {
+      throw new Error(`No SVG definition for puzzle type: ${kpuzzle.name()}`);
+    }
+    this.svgID = nextSVGID();
+    this.element = document.createElement("div");
+    this.element.classList.add("svg-wrapper");
+    this.element.innerHTML = svgSource;
+    const svgElem = this.element.querySelector("svg");
+    if (!svgElem) {
+      throw new Error("Could not get SVG element");
+    }
+    if (xmlns !== svgElem.namespaceURI) {
+      throw new Error("Unexpected XML namespace");
+    }
+    svgElem.style.maxWidth = "100%";
+    svgElem.style.maxHeight = "100%";
+    this.gradientDefs = document.createElementNS(xmlns, "defs");
+    svgElem.insertBefore(this.gradientDefs, svgElem.firstChild);
+    for (const orbitName in kpuzzle.definition.orbits) {
+      const orbitDefinition = kpuzzle.definition.orbits[orbitName];
+      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
+        for (let orientation = 0; orientation < orbitDefinition.numOrientations; orientation++) {
+          const id = this.elementID(orbitName, idx, orientation);
+          const elem = this.elementByID(id);
+          let originalColor = elem.style.fill;
+          if (experimentalAppearance) {
+            (() => {
+              const a = experimentalAppearance.orbits;
+              if (!a) {
+                return;
+              }
+              const orbitAppearance = a[orbitName];
+              if (!orbitAppearance) {
+                return;
+              }
+              const pieceAppearance = orbitAppearance.pieces[idx];
+              if (!pieceAppearance) {
+                return;
+              }
+              const faceletAppearance = pieceAppearance.facelets[orientation];
+              if (!faceletAppearance) {
+                return;
+              }
+              const appearance = typeof faceletAppearance === "string" ? faceletAppearance : faceletAppearance?.appearance;
+              const colorMap = colorMaps[appearance];
+              if (colorMap) {
+                originalColor = colorMap[originalColor];
+              }
+            })();
+          } else {
+            originalColor = elem.style.fill;
+          }
+          this.originalColors[id] = originalColor;
+          this.gradients[id] = this.newGradient(id, originalColor);
+          this.gradientDefs.appendChild(this.gradients[id]);
+          elem.setAttribute("style", `fill: url(#grad-${this.svgID}-${id})`);
+        }
+      }
+    }
+  }
+  drawState(state, nextState, fraction) {
+    this.draw(state, nextState, fraction);
+  }
+  draw(state, nextState, fraction) {
+    const transformation = state.experimentalToTransformation();
+    const nextTransformation = nextState?.experimentalToTransformation();
+    if (!transformation) {
+      throw new Error("Distinguishable pieces are not handled for SVG yet!");
+    }
+    for (const orbitName in transformation.kpuzzle.definition.orbits) {
+      const orbitDefinition = transformation.kpuzzle.definition.orbits[orbitName];
+      const curTransformationOrbit = transformation.transformationData[orbitName];
+      const nextTransformationOrbit = nextTransformation ? nextTransformation.transformationData[orbitName] : null;
+      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
+        for (let orientation = 0; orientation < orbitDefinition.numOrientations; orientation++) {
+          const id = this.elementID(orbitName, idx, orientation);
+          const fromCur = this.elementID(orbitName, curTransformationOrbit.permutation[idx], (orbitDefinition.numOrientations - curTransformationOrbit.orientation[idx] + orientation) % orbitDefinition.numOrientations);
+          let singleColor = false;
+          if (nextTransformationOrbit) {
+            const fromNext = this.elementID(orbitName, nextTransformationOrbit.permutation[idx], (orbitDefinition.numOrientations - nextTransformationOrbit.orientation[idx] + orientation) % orbitDefinition.numOrientations);
+            if (fromCur === fromNext) {
+              singleColor = true;
+            }
+            fraction = fraction || 0;
+            const easedBackwardsPercent = 100 * (1 - fraction * fraction * (2 - fraction * fraction));
+            this.gradients[id].children[0].setAttribute("stop-color", this.originalColors[fromCur]);
+            this.gradients[id].children[1].setAttribute("stop-color", this.originalColors[fromCur]);
+            this.gradients[id].children[1].setAttribute("offset", `${Math.max(easedBackwardsPercent - 5, 0)}%`);
+            this.gradients[id].children[2].setAttribute("offset", `${Math.max(easedBackwardsPercent - 5, 0)}%`);
+            this.gradients[id].children[3].setAttribute("offset", `${easedBackwardsPercent}%`);
+            this.gradients[id].children[4].setAttribute("offset", `${easedBackwardsPercent}%`);
+            this.gradients[id].children[4].setAttribute("stop-color", this.originalColors[fromNext]);
+            this.gradients[id].children[5].setAttribute("stop-color", this.originalColors[fromNext]);
+          } else {
+            singleColor = true;
+          }
+          if (singleColor) {
+            this.gradients[id].children[0].setAttribute("stop-color", this.originalColors[fromCur]);
+            this.gradients[id].children[1].setAttribute("stop-color", this.originalColors[fromCur]);
+            this.gradients[id].children[1].setAttribute("offset", `100%`);
+            this.gradients[id].children[2].setAttribute("offset", `100%`);
+            this.gradients[id].children[3].setAttribute("offset", `100%`);
+            this.gradients[id].children[4].setAttribute("offset", `100%`);
+          }
+        }
+      }
+    }
+  }
+  newGradient(id, originalColor) {
+    const grad = document.createElementNS(xmlns, "radialGradient");
+    grad.setAttribute("id", `grad-${this.svgID}-${id}`);
+    grad.setAttribute("r", `70.7107%`);
+    const stopDefs = [
+      { offset: 0, color: originalColor },
+      { offset: 0, color: originalColor },
+      { offset: 0, color: "black" },
+      { offset: 0, color: "black" },
+      { offset: 0, color: originalColor },
+      { offset: 100, color: originalColor }
+    ];
+    for (const stopDef of stopDefs) {
+      const stop = document.createElementNS(xmlns, "stop");
+      stop.setAttribute("offset", `${stopDef.offset}%`);
+      stop.setAttribute("stop-color", stopDef.color);
+      stop.setAttribute("stop-opacity", "1");
+      grad.appendChild(stop);
+    }
+    return grad;
+  }
+  elementID(orbitName, idx, orientation) {
+    return orbitName + "-l" + idx + "-o" + orientation;
+  }
+  elementByID(id) {
+    return this.element.querySelector("#" + id);
+  }
+};
+
 // src/cubing/twisty/views/2D/Twisty2DPuzzle.ts
 var _cachedPosition, _freshListenerManager;
 var Twisty2DPuzzle = class extends ManagedCustomElement {
-  constructor(model, def, svgSource, options, puzzleLoader) {
+  constructor(model, kpuzzle, svgSource, options, puzzleLoader) {
     super();
     this.model = model;
+    this.kpuzzle = kpuzzle;
     this.svgSource = svgSource;
     this.options = options;
     this.puzzleLoader = puzzleLoader;
@@ -622,7 +687,6 @@ var Twisty2DPuzzle = class extends ManagedCustomElement {
     __privateAdd(this, _cachedPosition, null);
     __privateAdd(this, _freshListenerManager, new FreshListenerManager());
     this.addCSS(twisty2DSVGCSS);
-    this.definition = def;
     this.resetSVG();
     __privateGet(this, _freshListenerManager).addListener(this.model.puzzleIDProp, (puzzleID) => {
       if (puzzleLoader?.id !== puzzleID) {
@@ -641,15 +705,14 @@ var Twisty2DPuzzle = class extends ManagedCustomElement {
     try {
       if (position.movesInProgress.length > 0) {
         const move = position.movesInProgress[0].move;
-        const def = this.definition;
         let partialMove = move;
         if (position.movesInProgress[0].direction === Direction.Backwards) {
           partialMove = move.invert();
         }
-        const newState = combineTransformations(def, position.state, transformationForMove(def, partialMove));
-        this.svg.draw(this.definition, position.state, newState, position.movesInProgress[0].fraction);
+        const newState = position.state.applyMove(partialMove);
+        this.svg.draw(position.state, newState, position.movesInProgress[0].fraction);
       } else {
-        this.svg.draw(this.definition, position.state);
+        this.svg.draw(position.state);
         __privateSet(this, _cachedPosition, position);
       }
     } catch (e) {
@@ -673,10 +736,10 @@ var Twisty2DPuzzle = class extends ManagedCustomElement {
     if (this.svg) {
       this.removeElement(this.svg.element);
     }
-    if (!this.definition) {
+    if (!this.kpuzzle) {
       return;
     }
-    this.svg = new KPuzzleSVGWrapper(this.definition, this.svgSource, appearance);
+    this.svg = new KPuzzleSVGWrapper(this.kpuzzle, this.svgSource, appearance);
     this.addElement(this.svg.element);
     if (__privateGet(this, _cachedPosition)) {
       this.onPositionChange(__privateGet(this, _cachedPosition));
@@ -712,7 +775,7 @@ var Twisty2DPuzzleWrapper = class {
   async twisty2DPuzzle() {
     return __privateGet(this, _cachedTwisty2DPuzzle) ?? __privateSet(this, _cachedTwisty2DPuzzle, (async () => {
       const svgPromise = this.effectiveVisualization === "experimental-2D-LL" ? this.puzzleLoader.llSVG() : this.puzzleLoader.svg();
-      return new Twisty2DPuzzle(this.model, await this.puzzleLoader.def(), await svgPromise, {}, this.puzzleLoader);
+      return new Twisty2DPuzzle(this.model, await this.puzzleLoader.kpuzzle(), await svgPromise, {}, this.puzzleLoader);
     })());
   }
 };
@@ -767,8 +830,36 @@ _cachedScene = new WeakMap();
 _currentTwisty2DPuzzleWrapper = new WeakMap();
 customElementsShim.define("twisty-2d-scene-wrapper", Twisty2DSceneWrapper);
 
-// src/cubing/twisty/views/3D/Twisty3DSceneWrapper.ts
-import { Vector2 } from "three";
+// src/cubing/twisty/views/ClassListManager.ts
+var _currentClassName;
+var ClassListManager = class {
+  constructor(elem, prefix, validSuffixes) {
+    this.elem = elem;
+    this.prefix = prefix;
+    this.validSuffixes = validSuffixes;
+    __privateAdd(this, _currentClassName, null);
+  }
+  clearValue() {
+    if (__privateGet(this, _currentClassName)) {
+      this.elem.contentWrapper.classList.remove(__privateGet(this, _currentClassName));
+    }
+    __privateSet(this, _currentClassName, null);
+  }
+  setValue(suffix) {
+    if (!this.validSuffixes.includes(suffix)) {
+      throw new Error(`Invalid suffix: ${suffix}`);
+    }
+    const newClassName = `${this.prefix}${suffix}`;
+    const changed = __privateGet(this, _currentClassName) !== newClassName;
+    if (changed) {
+      this.clearValue();
+      this.elem.contentWrapper.classList.add(newClassName);
+      __privateSet(this, _currentClassName, newClassName);
+    }
+    return changed;
+  }
+};
+_currentClassName = new WeakMap();
 
 // src/cubing/twisty/views/3D/Twisty3DPuzzleWrapper.ts
 var _freshListenerManager4, _cachedTwisty3DPuzzle;
@@ -871,7 +962,7 @@ var Twisty3DPuzzleWrapper = class {
   }
   async raycastMove(raycasterPromise, transformations) {
     const puzzle = await this.twisty3DPuzzle();
-    if (!(puzzle instanceof PG3D)) {
+    if (!("experimentalGetControlTargets" in puzzle)) {
       console.info("not PG3D! skipping raycast");
       return;
     }
@@ -1171,7 +1262,6 @@ async function newRenderer() {
 }
 
 // src/cubing/twisty/views/3D/TwistyOrbitControls.ts
-import { Spherical } from "three";
 var INERTIA_DEFAULT = true;
 var INERTIA_DURATION_MS = 500;
 var INERTIA_TIMEOUT_MS = 50;
@@ -1533,7 +1623,7 @@ var Twisty3DSceneWrapper = class extends ManagedCustomElement {
         THREEJS
       ]);
       const raycaster = new three.Raycaster();
-      const mouse = new Vector2(e.detail.pressInfo.normalizedX, e.detail.pressInfo.normalizedY);
+      const mouse = new (await THREEJS).Vector2(e.detail.pressInfo.normalizedX, e.detail.pressInfo.normalizedY);
       raycaster.setFromCamera(mouse, camera);
       return raycaster;
     })();
@@ -1993,6 +2083,7 @@ var TwistyScrubberV2 = class extends ManagedCustomElement {
     const inputElem = await this.inputElem();
     inputElem.min = detailedTimelineInfo.timeRange.start.toString();
     inputElem.max = detailedTimelineInfo.timeRange.end.toString();
+    inputElem.disabled = inputElem.min === inputElem.max;
     inputElem.value = detailedTimelineInfo.timestamp.toString();
   }
   async connectedCallback() {
@@ -2003,6 +2094,7 @@ var TwistyScrubberV2 = class extends ManagedCustomElement {
     return __privateGet(this, _inputElem) ?? __privateSet(this, _inputElem, (async () => {
       const elem = document.createElement("input");
       elem.type = "range";
+      elem.disabled = true;
       this.model?.detailedTimelineInfoProp.addFreshListener(this.onDetailedTimelineInfo.bind(this));
       elem.addEventListener("input", this.onInput.bind(this));
       return elem;
@@ -2054,7 +2146,6 @@ _inputElem = new WeakMap();
 customElementsShim.define("twisty-scrubber-v2", TwistyScrubberV2);
 
 // src/cubing/twisty/views/screenshot.ts
-import { WebGLRenderer } from "three";
 var cachedCamera = null;
 async function screenshot(model, options) {
   const width = options?.width ?? 2048;
@@ -2072,7 +2163,7 @@ async function screenshot(model, options) {
   scene.add(await twisty3DWrapper.twisty3DPuzzle());
   const orbitCoordinates = await model.orbitCoordinatesProp.get();
   await setCameraFromOrbitCoordinates(camera, orbitCoordinates);
-  const renderer = new WebGLRenderer({
+  const renderer = new (await THREEJS).WebGLRenderer({
     antialias: true,
     alpha: true
   });
@@ -2101,6 +2192,78 @@ function downloadURL(url, name, extension = "png") {
   a.click();
 }
 
+// src/cubing/twisty/views/TwistyPlayer.css.ts
+var twistyPlayerCSS = new CSSSource(`
+:host {
+  width: 384px;
+  height: 256px;
+  display: grid;
+
+  -webkit-user-select: none;
+  user-select: none;
+}
+
+.wrapper {
+  display: grid;
+  overflow: hidden;
+  grid-template-rows: 7fr 1em 1fr;
+}
+
+.wrapper > * {
+  width: inherit;
+  height: inherit;
+  overflow: hidden;
+}
+
+.wrapper.controls-none {
+  grid-template-rows: 7fr;
+}
+
+.wrapper.controls-none twisty-scrubber,
+.wrapper.controls-none twisty-control-button-panel ,
+.wrapper.controls-none twisty-scrubber-v2,
+.wrapper.controls-none twisty-buttons-v2 {
+  display: none;
+}
+
+twisty-scrubber {
+  background: rgba(196, 196, 196, 0.5);
+}
+
+.wrapper.checkered {
+  background-color: #EAEAEA;
+  background-image: linear-gradient(45deg, #DDD 25%, transparent 25%, transparent 75%, #DDD 75%, #DDD),
+    linear-gradient(45deg, #DDD 25%, transparent 25%, transparent 75%, #DDD 75%, #DDD);
+  background-size: 32px 32px;
+  background-position: 0 0, 16px 16px;
+}
+
+.visualization-wrapper > * {
+  width: 100%;
+  height: 100%;
+}
+
+.error-elem {
+  width: 100%;
+  height: 100%;
+  display: none;
+  place-content: center;
+  font-family: sans-serif;
+  box-shadow: inset 0 0 2em rgb(255, 0, 0);
+  color: red;
+  text-shadow: 0 0 0.2em white;
+  background: rgba(255, 255, 255, 0.25);
+}
+
+.wrapper.error .visualization-wrapper {
+  display: none;
+}
+
+.wrapper.error .error-elem {
+  display: grid;
+}
+`);
+
 // src/cubing/twisty/model/props/puzzle/state/AlgProp.ts
 var AlgIssues = class {
   constructor(issues) {
@@ -2538,8 +2701,8 @@ var AlgDuration = class extends TraversalUp {
 
 // src/cubing/twisty/controllers/indexer/SimpleAlgIndexer.ts
 var SimpleAlgIndexer = class {
-  constructor(puzzle, alg) {
-    this.puzzle = puzzle;
+  constructor(kpuzzle, alg) {
+    this.kpuzzle = kpuzzle;
     this.durationFn = new AlgDuration(defaultDurationForAmount);
     this.moves = new Alg(alg.experimentalExpand());
   }
@@ -2562,12 +2725,12 @@ var SimpleAlgIndexer = class {
     return i;
   }
   stateAtIndex(index) {
-    return this.puzzle.combine(this.puzzle.startState(), this.transformAtIndex(index));
+    return this.kpuzzle.startState().applyTransformation(this.transformationAtIndex(index));
   }
-  transformAtIndex(index) {
-    let state = this.puzzle.identity();
+  transformationAtIndex(index) {
+    let state = this.kpuzzle.identityTransformation();
     for (const move of Array.from(this.moves.units()).slice(0, index)) {
-      state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
+      state = state.applyMove(move);
     }
     return state;
   }
@@ -2760,8 +2923,8 @@ var demos = {
   ]
 };
 var SimultaneousMoveIndexerV2 = class {
-  constructor(puzzle, alg) {
-    this.puzzle = puzzle;
+  constructor(kpuzzle, alg) {
+    this.kpuzzle = kpuzzle;
     this.animLeaves = demos[alg.toString()] ?? simulMoves(alg);
   }
   getAnimLeaf(index) {
@@ -2786,13 +2949,13 @@ var SimultaneousMoveIndexerV2 = class {
     }
     return Math.max(0, i - 1);
   }
-  timestampToPosition(timestamp, startTransformation) {
+  timestampToPosition(timestamp, startState) {
     const currentMoveInfo = this.currentMoveInfo(timestamp);
-    let state = startTransformation ?? this.puzzle.identity();
+    let state = startState ?? this.kpuzzle.identityTransformation().toKState();
     for (const leafWithRange of this.animLeaves.slice(0, currentMoveInfo.stateIndex)) {
       const move = leafWithRange.animLeaf.as(Move);
       if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
+        state = state.applyMove(move);
       }
     }
     return {
@@ -2866,26 +3029,26 @@ var SimultaneousMoveIndexerV2 = class {
       movesFinished
     };
   }
-  stateAtIndex(index, startTransformation) {
-    let state = startTransformation ?? this.puzzle.startState();
+  stateAtIndex(index, startState) {
+    let state = startState ?? this.kpuzzle.startState();
     for (let i = 0; i < this.animLeaves.length && i < index; i++) {
       const leafWithRange = this.animLeaves[i];
       const move = leafWithRange.animLeaf.as(Move);
       if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
+        state = state.applyMove(move);
       }
     }
     return state;
   }
-  transformAtIndex(index) {
-    let state = this.puzzle.identity();
+  transformationAtIndex(index) {
+    let transformation = this.kpuzzle.identityTransformation();
     for (const leafWithRange of this.animLeaves.slice(0, index)) {
       const move = leafWithRange.animLeaf.as(Move);
       if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
+        transformation = transformation.applyMove(move);
       }
     }
-    return state;
+    return transformation;
   }
   algDuration() {
     let max = 0;
@@ -2903,57 +3066,9 @@ var SimultaneousMoveIndexerV2 = class {
   }
 };
 
-// src/cubing/twisty/controllers/indexer/tree/chunkAlgs.ts
-var MIN_CHUNKING_THRESHOLD = 16;
-function chunkifyAlg(alg, chunkMaxLength) {
-  const mainAlgBuilder = new AlgBuilder();
-  const chunkAlgBuilder = new AlgBuilder();
-  for (const unit of alg.units()) {
-    chunkAlgBuilder.push(unit);
-    if (chunkAlgBuilder.experimentalNumUnits() >= chunkMaxLength) {
-      mainAlgBuilder.push(new Grouping(chunkAlgBuilder.toAlg()));
-      chunkAlgBuilder.reset();
-    }
-  }
-  mainAlgBuilder.push(new Grouping(chunkAlgBuilder.toAlg()));
-  return mainAlgBuilder.toAlg();
-}
-var ChunkAlgs = class extends TraversalUp {
-  traverseAlg(alg) {
-    const algLength = alg.experimentalNumUnits();
-    if (algLength < MIN_CHUNKING_THRESHOLD) {
-      return alg;
-    }
-    return chunkifyAlg(alg, Math.ceil(Math.sqrt(algLength)));
-  }
-  traverseGrouping(grouping) {
-    return new Grouping(this.traverseAlg(grouping.alg), grouping.amount);
-  }
-  traverseMove(move) {
-    return move;
-  }
-  traverseCommutator(commutator) {
-    return new Conjugate(this.traverseAlg(commutator.A), this.traverseAlg(commutator.B));
-  }
-  traverseConjugate(conjugate) {
-    return new Conjugate(this.traverseAlg(conjugate.A), this.traverseAlg(conjugate.B));
-  }
-  traversePause(pause) {
-    return pause;
-  }
-  traverseNewline(newline) {
-    return newline;
-  }
-  traverseLineComment(comment) {
-    return comment;
-  }
-};
-var chunkAlgsInstance = new ChunkAlgs();
-var chunkAlgs = chunkAlgsInstance.traverseAlg.bind(chunkAlgsInstance);
-
 // src/cubing/twisty/controllers/indexer/tree/AlgWalker.ts
 var AlgPartDecoration = class {
-  constructor(_puz, moveCount, duration, forward, backward, children = []) {
+  constructor(moveCount, duration, forward, backward, children = []) {
     this.moveCount = moveCount;
     this.duration = duration;
     this.forward = forward;
@@ -2962,31 +3077,31 @@ var AlgPartDecoration = class {
   }
 };
 var DecoratorConstructor = class extends TraversalUp {
-  constructor(puz) {
+  constructor(kpuzzle) {
     super();
-    this.puz = puz;
+    this.kpuzzle = kpuzzle;
     this.durationFn = new AlgDuration(defaultDurationForAmount);
     this.cache = {};
-    this.identity = puz.identity();
-    this.dummyLeaf = new AlgPartDecoration(puz, 0, 0, this.identity, this.identity, []);
+    this.identity = kpuzzle.identityTransformation();
+    this.dummyLeaf = new AlgPartDecoration(0, 0, this.identity, this.identity, []);
   }
   traverseAlg(alg) {
     let moveCount = 0;
     let duration = 0;
-    let state = this.identity;
+    let transformation = this.identity;
     const child = [];
     for (const unit of alg.units()) {
       const apd = this.traverseUnit(unit);
       moveCount += apd.moveCount;
       duration += apd.duration;
-      if (state === this.identity) {
-        state = apd.forward;
+      if (transformation === this.identity) {
+        transformation = apd.forward;
       } else {
-        state = this.puz.combine(state, apd.forward);
+        transformation = transformation.applyTransformation(apd.forward);
       }
       child.push(apd);
     }
-    return new AlgPartDecoration(this.puz, moveCount, duration, state, this.puz.invert(state), child);
+    return new AlgPartDecoration(moveCount, duration, transformation, transformation.invert(), child);
   }
   traverseGrouping(grouping) {
     const dec = this.traverseAlg(grouping.alg);
@@ -2998,29 +3113,30 @@ var DecoratorConstructor = class extends TraversalUp {
     if (r) {
       return r;
     }
-    r = new AlgPartDecoration(this.puz, 1, this.durationFn.traverseUnit(move), this.puz.stateFromMove(move), this.puz.stateFromMove(move.invert()));
+    const transformation = this.kpuzzle.moveToTransformation(move);
+    r = new AlgPartDecoration(1, this.durationFn.traverseUnit(move), transformation, transformation.invert());
     this.cache[key] = r;
     return r;
   }
   traverseCommutator(commutator) {
     const decA = this.traverseAlg(commutator.A);
     const decB = this.traverseAlg(commutator.B);
-    const AB = this.puz.combine(decA.forward, decB.forward);
-    const ApBp = this.puz.combine(decA.backward, decB.backward);
-    const ABApBp = this.puz.combine(AB, ApBp);
-    const dec = new AlgPartDecoration(this.puz, 2 * (decA.moveCount + decB.moveCount), 2 * (decA.duration + decB.duration), ABApBp, this.puz.invert(ABApBp), [decA, decB]);
+    const AB = decA.forward.applyTransformation(decB.forward);
+    const ApBp = decA.backward.applyTransformation(decB.backward);
+    const ABApBp = AB.applyTransformation(ApBp);
+    const dec = new AlgPartDecoration(2 * (decA.moveCount + decB.moveCount), 2 * (decA.duration + decB.duration), ABApBp, ABApBp.invert(), [decA, decB]);
     return this.mult(dec, 1, [dec, decA, decB]);
   }
   traverseConjugate(conjugate) {
     const decA = this.traverseAlg(conjugate.A);
     const decB = this.traverseAlg(conjugate.B);
-    const AB = this.puz.combine(decA.forward, decB.forward);
-    const ABAp = this.puz.combine(AB, decA.backward);
-    const dec = new AlgPartDecoration(this.puz, 2 * decA.moveCount + decB.moveCount, 2 * decA.duration + decB.duration, ABAp, this.puz.invert(ABAp), [decA, decB]);
+    const AB = decA.forward.applyTransformation(decB.forward);
+    const ABAp = AB.applyTransformation(decA.backward);
+    const dec = new AlgPartDecoration(2 * decA.moveCount + decB.moveCount, 2 * decA.duration + decB.duration, ABAp, ABAp.invert(), [decA, decB]);
     return this.mult(dec, 1, [dec, decA, decB]);
   }
   traversePause(pause) {
-    return new AlgPartDecoration(this.puz, 1, this.durationFn.traverseUnit(pause), this.identity, this.identity);
+    return new AlgPartDecoration(1, this.durationFn.traverseUnit(pause), this.identity, this.identity);
   }
   traverseNewline(_newline) {
     return this.dummyLeaf;
@@ -3030,8 +3146,8 @@ var DecoratorConstructor = class extends TraversalUp {
   }
   mult(apd, n, child) {
     const absn = Math.abs(n);
-    const st = this.puz.multiply(apd.forward, n);
-    return new AlgPartDecoration(this.puz, apd.moveCount * absn, apd.duration * absn, st, this.puz.invert(st), child);
+    const st = apd.forward.selfMultiply(n);
+    return new AlgPartDecoration(apd.moveCount * absn, apd.duration * absn, st, st.invert(), child);
   }
 };
 var WalkerDown = class {
@@ -3041,9 +3157,9 @@ var WalkerDown = class {
   }
 };
 var AlgWalker = class extends TraversalDownUp {
-  constructor(puz, algOrUnit, apd) {
+  constructor(kpuzzle, algOrUnit, apd) {
     super();
-    this.puz = puz;
+    this.kpuzzle = kpuzzle;
     this.algOrUnit = algOrUnit;
     this.apd = apd;
     this.i = -1;
@@ -3053,7 +3169,7 @@ var AlgWalker = class extends TraversalDownUp {
     this.move = void 0;
     this.back = false;
     this.moveDuration = 0;
-    this.st = this.puz.identity();
+    this.st = this.kpuzzle.identityTransformation();
     this.root = new WalkerDown(this.apd, false);
   }
   moveByIndex(loc) {
@@ -3076,7 +3192,7 @@ var AlgWalker = class extends TraversalDownUp {
     this.move = void 0;
     this.moveDuration = 0;
     this.back = false;
-    this.st = this.puz.identity();
+    this.st = this.kpuzzle.identityTransformation();
     const r = this.algOrUnit.is(Alg) ? this.traverseAlg(this.algOrUnit, this.root) : this.traverseUnit(this.algOrUnit, this.root);
     return r;
   }
@@ -3173,29 +3289,77 @@ var AlgWalker = class extends TraversalDownUp {
     this.dur += mul * wd.apd.duration;
     if (mul !== 1) {
       if (wd.back) {
-        this.st = this.puz.combine(this.st, this.puz.multiply(wd.apd.backward, mul));
+        this.st = this.st.applyTransformation(wd.apd.backward.selfMultiply(mul));
       } else {
-        this.st = this.puz.combine(this.st, this.puz.multiply(wd.apd.forward, mul));
+        this.st = this.st.applyTransformation(wd.apd.forward.selfMultiply(mul));
       }
     } else {
       if (wd.back) {
-        this.st = this.puz.combine(this.st, wd.apd.backward);
+        this.st = this.st.applyTransformation(wd.apd.backward);
       } else {
-        this.st = this.puz.combine(this.st, wd.apd.forward);
+        this.st = this.st.applyTransformation(wd.apd.forward);
       }
     }
     return false;
   }
 };
 
+// src/cubing/twisty/controllers/indexer/tree/chunkAlgs.ts
+var MIN_CHUNKING_THRESHOLD = 16;
+function chunkifyAlg(alg, chunkMaxLength) {
+  const mainAlgBuilder = new AlgBuilder();
+  const chunkAlgBuilder = new AlgBuilder();
+  for (const unit of alg.units()) {
+    chunkAlgBuilder.push(unit);
+    if (chunkAlgBuilder.experimentalNumUnits() >= chunkMaxLength) {
+      mainAlgBuilder.push(new Grouping(chunkAlgBuilder.toAlg()));
+      chunkAlgBuilder.reset();
+    }
+  }
+  mainAlgBuilder.push(new Grouping(chunkAlgBuilder.toAlg()));
+  return mainAlgBuilder.toAlg();
+}
+var ChunkAlgs = class extends TraversalUp {
+  traverseAlg(alg) {
+    const algLength = alg.experimentalNumUnits();
+    if (algLength < MIN_CHUNKING_THRESHOLD) {
+      return alg;
+    }
+    return chunkifyAlg(alg, Math.ceil(Math.sqrt(algLength)));
+  }
+  traverseGrouping(grouping) {
+    return new Grouping(this.traverseAlg(grouping.alg), grouping.amount);
+  }
+  traverseMove(move) {
+    return move;
+  }
+  traverseCommutator(commutator) {
+    return new Conjugate(this.traverseAlg(commutator.A), this.traverseAlg(commutator.B));
+  }
+  traverseConjugate(conjugate) {
+    return new Conjugate(this.traverseAlg(conjugate.A), this.traverseAlg(conjugate.B));
+  }
+  traversePause(pause) {
+    return pause;
+  }
+  traverseNewline(newline) {
+    return newline;
+  }
+  traverseLineComment(comment) {
+    return comment;
+  }
+};
+var chunkAlgsInstance = new ChunkAlgs();
+var chunkAlgs = chunkAlgsInstance.traverseAlg.bind(chunkAlgsInstance);
+
 // src/cubing/twisty/controllers/indexer/tree/TreeAlgIndexer.ts
 var TreeAlgIndexer = class {
-  constructor(puzzle, alg) {
-    this.puzzle = puzzle;
-    const deccon = new DecoratorConstructor(this.puzzle);
+  constructor(kpuzzle, alg) {
+    this.kpuzzle = kpuzzle;
+    const deccon = new DecoratorConstructor(this.kpuzzle);
     const chunkedAlg = chunkAlgs(alg);
     this.decoration = deccon.traverseAlg(chunkedAlg);
-    this.walker = new AlgWalker(this.puzzle, chunkedAlg, this.decoration);
+    this.walker = new AlgWalker(this.kpuzzle, chunkedAlg, this.decoration);
   }
   getAnimLeaf(index) {
     if (this.walker.moveByIndex(index)) {
@@ -3222,11 +3386,11 @@ var TreeAlgIndexer = class {
     }
     throw new Error(`Out of algorithm: index ${index}`);
   }
-  stateAtIndex(index, startTransformation) {
+  stateAtIndex(index, startState) {
     this.walker.moveByIndex(index);
-    return this.puzzle.combine(startTransformation ?? this.puzzle.startState(), this.walker.st);
+    return (startState ?? this.kpuzzle.startState()).applyTransformation(this.walker.st);
   }
-  transformAtIndex(index) {
+  transformationAtIndex(index) {
     this.walker.moveByIndex(index);
     return this.walker.st;
   }
@@ -3272,8 +3436,7 @@ var IndexerConstructorProp = class extends TwistyPropDerived {
 var PuzzleAlgProp = class extends TwistyPropDerived {
   async derive(inputs) {
     try {
-      const kpuzzle = new KPuzzle(inputs.puzzleDef);
-      kpuzzle.applyAlg(inputs.algWithIssues.alg);
+      inputs.kpuzzle.algToTransformation(inputs.algWithIssues.alg);
       return inputs.algWithIssues;
     } catch (e) {
       return {
@@ -3286,83 +3449,17 @@ var PuzzleAlgProp = class extends TwistyPropDerived {
   }
 };
 
-// src/cubing/twisty/views/3D/puzzles/KPuzzleWrapper.ts
-var PuzzleWrapper = class {
-  multiply(state, amount) {
-    if (amount < 0) {
-      return this.invert(this.multiply(state, -amount));
-    }
-    if (amount === 0) {
-      return this.identity();
-    }
-    while (amount % 2 === 0) {
-      amount = amount / 2;
-      state = this.combine(state, state);
-    }
-    let newState = state;
-    amount--;
-    while (amount > 0) {
-      if (amount % 2 === 1) {
-        newState = this.combine(newState, state);
-      }
-      amount = Math.floor(amount / 2);
-      if (amount > 0) {
-        state = this.combine(state, state);
-      }
-    }
-    return newState;
-  }
-};
-var KPuzzleWrapper = class extends PuzzleWrapper {
-  constructor(definition) {
-    super();
-    this.definition = definition;
-    this.moveCache = {};
-  }
-  static async fromID(id) {
-    return new KPuzzleWrapper(await puzzles[id].def());
-  }
-  startState() {
-    return this.definition.startPieces;
-  }
-  invert(state) {
-    return invertTransformation(this.definition, state);
-  }
-  combine(s1, s2) {
-    return combineTransformations(this.definition, s1, s2);
-  }
-  stateFromMove(move) {
-    const key = move.toString();
-    if (!this.moveCache[key]) {
-      this.moveCache[key] = transformationForMove(this.definition, move);
-    }
-    return this.moveCache[key];
-  }
-  identity() {
-    return identityTransformation(this.definition);
-  }
-  equivalent(s1, s2) {
-    return areStatesEquivalent(this.definition, s1, s2);
-  }
-};
-
 // src/cubing/twisty/model/props/puzzle/state/AlgTransformationProp.ts
 var AlgTransformationProp = class extends TwistyPropDerived {
   derive(input) {
-    return this.applyAlg(input.def, input.alg.alg);
-  }
-  applyAlg(def, alg) {
-    const kpuzzleWrapper = new KPuzzleWrapper(def);
-    const indexer = new TreeAlgIndexer(kpuzzleWrapper, alg);
-    return indexer.transformAtIndex(indexer.numAnimatedLeaves());
+    return input.kpuzzle.algToTransformation(input.alg.alg);
   }
 };
 
 // src/cubing/twisty/model/props/puzzle/state/IndexerProp.ts
 var IndexerProp = class extends TwistyPropDerived {
   derive(input) {
-    const kpuzzleWrapper = new KPuzzleWrapper(input.def);
-    return new input.indexerConstructor(kpuzzleWrapper, input.algWithIssues.alg);
+    return new input.indexerConstructor(input.kpuzzle, input.algWithIssues.alg);
   }
 };
 
@@ -3373,9 +3470,9 @@ var AnchoredStartProp = class extends TwistyPropDerived {
       case "start":
         return inputs.setupTransformation;
       case "end": {
-        const algTransformation = inputs.indexer.transformAtIndex(inputs.indexer.numAnimatedLeaves());
-        const inverseAlgTransformation = invertTransformation(inputs.def, algTransformation);
-        return combineTransformations(inputs.def, inputs.setupTransformation, inverseAlgTransformation);
+        const algTransformation = inputs.indexer.transformationAtIndex(inputs.indexer.numAnimatedLeaves());
+        const inverseAlgTransformation = algTransformation.invert();
+        return inputs.setupTransformation.applyTransformation(inverseAlgTransformation);
       }
       default:
         throw new Error("Unimplemented!");
@@ -3453,8 +3550,8 @@ var CoarseTimelineInfoProp = class extends TwistyPropDerived {
   }
 };
 
-// src/cubing/twisty/model/props/puzzle/state/CurrentLeavesProp.ts
-var CurrentLeavesProp = class extends TwistyPropDerived {
+// src/cubing/twisty/model/props/puzzle/state/CurrentMoveInfoProp.ts
+var CurrentMoveInfoProp = class extends TwistyPropDerived {
   derive(inputs) {
     function addCatchUpMove(currentMoveInfo) {
       if (inputs.detailedTimelineInfo.atEnd && inputs.catchUpMove.move !== null) {
@@ -3526,19 +3623,18 @@ var CurrentLeavesSimplifiedProp = class extends TwistyPropDerived {
   }
 };
 
-// src/cubing/twisty/model/props/puzzle/state/CurrentTransformationProp.ts
-var CurrentTransformationProp = class extends TwistyPropDerived {
+// src/cubing/twisty/model/props/puzzle/state/CurrentStateProp.ts
+var CurrentStateProp = class extends TwistyPropDerived {
   derive(inputs) {
-    let state = inputs.indexer.transformAtIndex(inputs.currentLeavesSimplified.stateIndex);
-    state = combineTransformations(inputs.def, inputs.anchoredStart, state);
-    const ksolvePuzzle = new KPuzzleWrapper(inputs.def);
+    let transformation = inputs.indexer.transformationAtIndex(inputs.currentLeavesSimplified.stateIndex);
+    transformation = inputs.anchoredStart.applyTransformation(transformation);
     for (const finishingMove of inputs.currentLeavesSimplified.movesFinishing) {
-      state = combineTransformations(inputs.def, state, ksolvePuzzle.stateFromMove(finishingMove));
+      transformation = transformation.applyMove(finishingMove);
     }
     for (const finishedMove of inputs.currentLeavesSimplified.movesFinished) {
-      state = combineTransformations(inputs.def, state, ksolvePuzzle.stateFromMove(finishedMove));
+      transformation = transformation.applyMove(finishedMove);
     }
-    return state;
+    return transformation.toKState();
   }
 };
 
@@ -3546,16 +3642,16 @@ var CurrentTransformationProp = class extends TwistyPropDerived {
 var LegacyPositionProp = class extends TwistyPropDerived {
   derive(inputs) {
     return {
-      state: inputs.transformation,
+      state: inputs.state,
       movesInProgress: inputs.currentMoveInfo.currentMoves
     };
   }
 };
 
-// src/cubing/twisty/model/props/puzzle/structure/PuzzleDefProp.ts
-var PuzzleDefProp = class extends TwistyPropDerived {
+// src/cubing/twisty/model/props/puzzle/structure/KPuzzleProp.ts
+var KPuzzleProp = class extends TwistyPropDerived {
   async derive(inputs) {
-    return inputs.puzzleLoader.def();
+    return inputs.puzzleLoader.kpuzzle();
   }
 };
 
@@ -3644,15 +3740,15 @@ var TwistyPlayerModel = class {
       puzzleIDRequest: this.puzzleIDRequestProp,
       puzzleDescriptionRequest: this.puzzleDescriptionRequestProp
     }, this.userVisibleErrorTracker);
-    this.puzzleDefProp = new PuzzleDefProp({ puzzleLoader: this.puzzleLoaderProp });
+    this.kpuzzleProp = new KPuzzleProp({ puzzleLoader: this.puzzleLoaderProp });
     this.puzzleIDProp = new PuzzleIDProp({ puzzleLoader: this.puzzleLoaderProp });
     this.puzzleAlgProp = new PuzzleAlgProp({
       algWithIssues: this.algProp,
-      puzzleDef: this.puzzleDefProp
+      kpuzzle: this.kpuzzleProp
     });
     this.puzzleSetupProp = new PuzzleAlgProp({
       algWithIssues: this.setupProp,
-      puzzleDef: this.puzzleDefProp
+      kpuzzle: this.kpuzzleProp
     });
     this.visualizationStrategyProp = new VisualizationStrategyProp({
       visualizationRequest: this.visualizationFormatProp,
@@ -3673,18 +3769,17 @@ var TwistyPlayerModel = class {
     });
     this.setupTransformationProp = new AlgTransformationProp({
       alg: this.puzzleSetupProp,
-      def: this.puzzleDefProp
+      kpuzzle: this.kpuzzleProp
     });
     this.indexerProp = new IndexerProp({
       indexerConstructor: this.indexerConstructorProp,
       algWithIssues: this.puzzleAlgProp,
-      def: this.puzzleDefProp
+      kpuzzle: this.kpuzzleProp
     });
     this.anchoredStartProp = new AnchoredStartProp({
       setupAnchor: this.setupAnchorProp,
       setupTransformation: this.setupTransformationProp,
-      indexer: this.indexerProp,
-      def: this.puzzleDefProp
+      indexer: this.indexerProp
     });
     this.timeRangeProp = new TimeRangeProp({
       indexer: this.indexerProp
@@ -3698,7 +3793,7 @@ var TwistyPlayerModel = class {
       detailedTimelineInfo: this.detailedTimelineInfoProp,
       playingInfo: this.playingInfoProp
     });
-    this.currentLeavesProp = new CurrentLeavesProp({
+    this.currentMoveInfoProp = new CurrentMoveInfoProp({
       indexer: this.indexerProp,
       detailedTimelineInfo: this.detailedTimelineInfoProp,
       catchUpMove: this.catchUpMoveProp
@@ -3708,17 +3803,16 @@ var TwistyPlayerModel = class {
       viewerLink: this.viewerLinkProp
     });
     this.currentLeavesSimplifiedProp = new CurrentLeavesSimplifiedProp({
-      currentMoveInfo: this.currentLeavesProp
+      currentMoveInfo: this.currentMoveInfoProp
     });
-    this.currentTransformationProp = new CurrentTransformationProp({
+    this.currentStateProp = new CurrentStateProp({
       anchoredStart: this.anchoredStartProp,
       currentLeavesSimplified: this.currentLeavesSimplifiedProp,
-      indexer: this.indexerProp,
-      def: this.puzzleDefProp
+      indexer: this.indexerProp
     });
     this.legacyPositionProp = new LegacyPositionProp({
-      currentMoveInfo: this.currentLeavesProp,
-      transformation: this.currentTransformationProp
+      currentMoveInfo: this.currentMoveInfoProp,
+      state: this.currentStateProp
     });
   }
   async twizzleLink() {
@@ -4378,7 +4472,7 @@ var TwistyAlgViewer = class extends HTMLElementShim {
     const sourceAlg = (await this.twistyPlayer.experimentalModel.algProp.get()).alg;
     const parsedAlg = "startCharIndex" in sourceAlg ? sourceAlg : Alg.fromString(sourceAlg.toString());
     this.setAlg(parsedAlg);
-    twistyPlayer.experimentalModel.currentLeavesProp.addFreshListener((currentMoveInfo) => {
+    twistyPlayer.experimentalModel.currentMoveInfoProp.addFreshListener((currentMoveInfo) => {
       let moveInfo = currentMoveInfo.currentMoves[0];
       moveInfo ?? (moveInfo = currentMoveInfo.movesStarting[0]);
       moveInfo ?? (moveInfo = currentMoveInfo.movesFinishing[0]);
@@ -4916,10 +5010,8 @@ padSuffix_fn = function(s) {
 _highlightedLeaf = new WeakMap();
 customElementsShim.define("twisty-alg-editor", TwistyAlgEditor);
 export {
-  Cube3D,
   NO_VALUE as EXPERIMENTAL_PROP_NO_VALUE,
-  KPuzzleWrapper as KSolvePuzzle,
-  PG3D,
+  KPuzzleSVGWrapper as ExperimentalKPuzzleSVGWrapper,
   SimpleAlgIndexer,
   TreeAlgIndexer,
   TwistyAlgEditor,