cubing 0.23.0 → 0.24.0-pre4

package/dist/esm/{chunk-N3RNWU5T.js → 3d-dynamic-inside-OGANXBOW.js}

@@ -1,14 +1,15 @@
+import {
+  TAU,
+  THREEJS,
+  experimentalStickerings,
+  hintFaceletStyles
+} from "./chunk-UYT3253Q.js";
 import {
   cube3x3x3,
   getFaceletAppearance,
   puzzles
-} from "./chunk-DK6PXBB2.js";
-import {
-  KPuzzle,
-  areTransformationsEquivalent,
-  transformationForQuantumMove,
-  transformationOrder
-} from "./chunk-X6JHXPDX.js";
+} from "./chunk-2IHGN4YF.js";
+import "./chunk-Z36TNZT2.js";
 import {
   Move
 } from "./chunk-EWRBHQFX.js";
@@ -16,8 +17,7 @@ import {
   __privateAdd,
   __privateGet,
   __privateMethod,
-  __privateSet,
-  __privateWrapper
+  __privateSet
 } from "./chunk-WO2AXYFE.js";
 
 // src/cubing/twisty/views/3D/puzzles/Cube3D.ts
@@ -39,402 +39,11 @@ import {
   Vector3
 } from "three";
 
-// src/cubing/vendor/p-lazy/p-lazy.ts
-var PLazy = class extends Promise {
-  constructor(executor) {
-    super((resolve) => {
-      resolve();
-    });
-    this._executor = executor;
-  }
-  static from(function_) {
-    return new PLazy((resolve) => {
-      resolve(function_());
-    });
-  }
-  static resolve(value) {
-    return new PLazy((resolve) => {
-      resolve(value);
-    });
-  }
-  static reject(error) {
-    return new PLazy((_resolve, reject) => {
-      reject(error);
-    });
-  }
-  then(onFulfilled, onRejected) {
-    this._promise = this._promise || new Promise(this._executor);
-    return this._promise.then(onFulfilled, onRejected);
-  }
-  catch(onRejected) {
-    this._promise = this._promise || new Promise(this._executor);
-    return this._promise.catch(onRejected);
-  }
-};
-function from(function_) {
-  return new PLazy((resolve) => {
-    resolve(function_());
-  });
-}
-
-// src/cubing/twisty/model/PromiseFreshener.ts
-var _latestAssignedIdx, _latestResolvedIdx;
-var PromiseFreshener = class {
-  constructor() {
-    __privateAdd(this, _latestAssignedIdx, 0);
-    __privateAdd(this, _latestResolvedIdx, 0);
-  }
-  async queue(p) {
-    const idx = ++__privateWrapper(this, _latestAssignedIdx)._;
-    const result = await p;
-    if (idx > __privateGet(this, _latestResolvedIdx)) {
-      __privateSet(this, _latestResolvedIdx, idx);
-      return {
-        fresh: true,
-        result
-      };
-    } else {
-      return { fresh: false };
-    }
-  }
-};
-_latestAssignedIdx = new WeakMap();
-_latestResolvedIdx = new WeakMap();
-var _latestAssignedIdx2, _latestResolvedIdx2;
-var StaleDropper = class {
-  constructor() {
-    __privateAdd(this, _latestAssignedIdx2, 0);
-    __privateAdd(this, _latestResolvedIdx2, 0);
-  }
-  queue(p) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const idx = ++__privateWrapper(this, _latestAssignedIdx2)._;
-        const result = await p;
-        if (idx > __privateGet(this, _latestResolvedIdx2)) {
-          __privateSet(this, _latestResolvedIdx2, idx);
-          resolve(result);
-        }
-      } catch (e) {
-        reject(e);
-      }
-    });
-  }
-};
-_latestAssignedIdx2 = new WeakMap();
-_latestResolvedIdx2 = new WeakMap();
-
-// src/cubing/twisty/model/props/TwistyProp.ts
-var globalSourceGeneration = 0;
-var _children, _rawListeners, _scheduleRawDispatch, scheduleRawDispatch_fn, _rawDispatchPending, _dispatchRawListeners, dispatchRawListeners_fn, _freshListeners;
-var TwistyPropParent = class {
-  constructor() {
-    __privateAdd(this, _scheduleRawDispatch);
-    __privateAdd(this, _dispatchRawListeners);
-    __privateAdd(this, _children, new Set());
-    this.lastSourceGeneration = 0;
-    __privateAdd(this, _rawListeners, new Set());
-    __privateAdd(this, _rawDispatchPending, false);
-    __privateAdd(this, _freshListeners, new Map());
-  }
-  canReuse(v1, v2) {
-    return v1 === v2 || this.canReuseValue(v1, v2);
-  }
-  canReuseValue(_v1, _v2) {
-    return false;
-  }
-  debugGetChildren() {
-    return Array.from(__privateGet(this, _children).values());
-  }
-  addChild(child) {
-    __privateGet(this, _children).add(child);
-  }
-  removeChild(child) {
-    __privateGet(this, _children).delete(child);
-  }
-  markStale(sourceEvent) {
-    if (sourceEvent.detail.generation !== globalSourceGeneration) {
-      throw new Error("A TwistyProp was marked stale too late!");
-    }
-    if (this.lastSourceGeneration === sourceEvent.detail.generation) {
-      return;
-    }
-    this.lastSourceGeneration = sourceEvent.detail.generation;
-    for (const child of __privateGet(this, _children)) {
-      child.markStale(sourceEvent);
-    }
-    __privateMethod(this, _scheduleRawDispatch, scheduleRawDispatch_fn).call(this);
-  }
-  addRawListener(listener, options) {
-    __privateGet(this, _rawListeners).add(listener);
-    if (options?.initial) {
-      listener();
-    }
-  }
-  removeRawListener(listener) {
-    __privateGet(this, _rawListeners).delete(listener);
-  }
-  addFreshListener(listener) {
-    const staleDropper = new StaleDropper();
-    let lastResult = null;
-    const callback = async () => {
-      const result = await staleDropper.queue(this.get());
-      if (lastResult !== null && this.canReuse(lastResult, result)) {
-        return;
-      }
-      lastResult = result;
-      listener(result);
-    };
-    __privateGet(this, _freshListeners).set(listener, callback);
-    this.addRawListener(callback, { initial: true });
-  }
-  removeFreshListener(listener) {
-    this.removeRawListener(__privateGet(this, _freshListeners).get(listener));
-    __privateGet(this, _freshListeners).delete(listener);
-  }
-};
-_children = new WeakMap();
-_rawListeners = new WeakMap();
-_scheduleRawDispatch = new WeakSet();
-scheduleRawDispatch_fn = function() {
-  if (!__privateGet(this, _rawDispatchPending)) {
-    __privateSet(this, _rawDispatchPending, true);
-    setTimeout(() => __privateMethod(this, _dispatchRawListeners, dispatchRawListeners_fn).call(this), 0);
-  }
-};
-_rawDispatchPending = new WeakMap();
-_dispatchRawListeners = new WeakSet();
-dispatchRawListeners_fn = function() {
-  if (!__privateGet(this, _rawDispatchPending)) {
-    throw new Error("Invalid dispatch state!");
-  }
-  for (const listener of __privateGet(this, _rawListeners)) {
-    listener();
-  }
-  __privateSet(this, _rawDispatchPending, false);
-};
-_freshListeners = new WeakMap();
-var _value;
-var TwistyPropSource = class extends TwistyPropParent {
-  constructor(initialValue) {
-    super();
-    __privateAdd(this, _value, void 0);
-    __privateSet(this, _value, from(() => this.getDefaultValue()));
-    if (initialValue) {
-      __privateSet(this, _value, this.deriveFromPromiseOrValue(initialValue, __privateGet(this, _value)));
-    }
-  }
-  set(input) {
-    __privateSet(this, _value, this.deriveFromPromiseOrValue(input, __privateGet(this, _value)));
-    const sourceEventDetail = {
-      sourceProp: this,
-      value: __privateGet(this, _value),
-      generation: ++globalSourceGeneration
-    };
-    this.markStale(new CustomEvent("stale", {
-      detail: sourceEventDetail
-    }));
-  }
-  async get() {
-    return __privateGet(this, _value);
-  }
-  async deriveFromPromiseOrValue(input, oldValuePromise) {
-    return this.derive(await input, oldValuePromise);
-  }
-};
-_value = new WeakMap();
-var SimpleTwistyPropSource = class extends TwistyPropSource {
-  derive(input) {
-    return input;
-  }
-};
-var NO_VALUE = Symbol("no value");
-var _parents, _cachedLastSuccessfulCalculation, _cachedLatestGenerationCalculation, _getParents, getParents_fn, _cacheDerive, cacheDerive_fn;
-var TwistyPropDerived = class extends TwistyPropParent {
-  constructor(parents, userVisibleErrorTracker) {
-    super();
-    this.userVisibleErrorTracker = userVisibleErrorTracker;
-    __privateAdd(this, _getParents);
-    __privateAdd(this, _cacheDerive);
-    __privateAdd(this, _parents, void 0);
-    __privateAdd(this, _cachedLastSuccessfulCalculation, null);
-    __privateAdd(this, _cachedLatestGenerationCalculation, null);
-    __privateSet(this, _parents, parents);
-    for (const parent of Object.values(parents)) {
-      parent.addChild(this);
-    }
-  }
-  async get() {
-    const generation = this.lastSourceGeneration;
-    if (__privateGet(this, _cachedLatestGenerationCalculation)?.generation === generation) {
-      return __privateGet(this, _cachedLatestGenerationCalculation).output;
-    }
-    const latestGenerationCalculation = {
-      generation,
-      output: __privateMethod(this, _cacheDerive, cacheDerive_fn).call(this, __privateMethod(this, _getParents, getParents_fn).call(this), generation, __privateGet(this, _cachedLastSuccessfulCalculation))
-    };
-    __privateSet(this, _cachedLatestGenerationCalculation, latestGenerationCalculation);
-    this.userVisibleErrorTracker?.reset();
-    return latestGenerationCalculation.output;
-  }
-};
-_parents = new WeakMap();
-_cachedLastSuccessfulCalculation = new WeakMap();
-_cachedLatestGenerationCalculation = new WeakMap();
-_getParents = new WeakSet();
-getParents_fn = async function() {
-  const inputValuePromises = {};
-  for (const [key, parent] of Object.entries(__privateGet(this, _parents))) {
-    inputValuePromises[key] = parent.get();
-  }
-  const inputs = {};
-  for (const key in __privateGet(this, _parents)) {
-    inputs[key] = await inputValuePromises[key];
-  }
-  return inputs;
-};
-_cacheDerive = new WeakSet();
-cacheDerive_fn = async function(inputsPromise, generation, cachedLatestGenerationCalculation = null) {
-  const inputs = await inputsPromise;
-  const cache = (output) => {
-    __privateSet(this, _cachedLastSuccessfulCalculation, {
-      inputs,
-      output: Promise.resolve(output),
-      generation
-    });
-    return output;
-  };
-  if (!cachedLatestGenerationCalculation) {
-    return cache(await this.derive(inputs));
-  }
-  const cachedInputs = cachedLatestGenerationCalculation.inputs;
-  for (const key in __privateGet(this, _parents)) {
-    const parent = __privateGet(this, _parents)[key];
-    if (!parent.canReuse(inputs[key], cachedInputs[key])) {
-      return cache(await this.derive(inputs));
-    }
-  }
-  return cachedLatestGenerationCalculation.output;
-};
-var _disconnectionFunctions;
-var FreshListenerManager = class {
-  constructor() {
-    __privateAdd(this, _disconnectionFunctions, []);
-  }
-  addListener(prop, listener) {
-    let disconnected = false;
-    const wrappedListener = (value) => {
-      if (disconnected) {
-        return;
-      }
-      listener(value);
-    };
-    prop.addFreshListener(wrappedListener);
-    __privateGet(this, _disconnectionFunctions).push(() => {
-      prop.removeFreshListener(wrappedListener);
-      disconnected = true;
-    });
-  }
-  addMultiListener(props, listener) {
-    let disconnected = false;
-    const wrappedListener = async (_) => {
-      if (disconnected) {
-        return;
-      }
-      const promises = props.map((prop) => prop.get());
-      const values = await Promise.all(promises);
-      listener(values);
-    };
-    for (const prop of props) {
-      prop.addFreshListener(wrappedListener);
-    }
-    __privateGet(this, _disconnectionFunctions).push(() => {
-      for (const prop of props) {
-        prop.removeFreshListener(wrappedListener);
-      }
-      disconnected = true;
-    });
-  }
-  disconnect() {
-    for (const disconnectionFunction of __privateGet(this, _disconnectionFunctions)) {
-      disconnectionFunction();
-    }
-  }
-};
-_disconnectionFunctions = new WeakMap();
-
-// src/cubing/twisty/model/props/puzzle/display/HintFaceletProp.ts
-var hintFaceletStyles = {
-  floating: true,
-  none: true
-};
-var HintFaceletProp = class extends SimpleTwistyPropSource {
-  getDefaultValue() {
-    return "auto";
-  }
-};
-
-// src/cubing/twisty/model/props/puzzle/display/StickeringProp.ts
-var experimentalStickerings = {
-  "full": true,
-  "centers-only": true,
-  "PLL": true,
-  "CLS": true,
-  "OLL": true,
-  "COLL": true,
-  "OCLL": true,
-  "CLL": true,
-  "ELL": true,
-  "ELS": true,
-  "LL": true,
-  "F2L": true,
-  "ZBLL": true,
-  "ZBLS": true,
-  "WVLS": true,
-  "VLS": true,
-  "LS": true,
-  "EO": true,
-  "EOline": true,
-  "EOcross": true,
-  "CMLL": true,
-  "L6E": true,
-  "L6EO": true,
-  "Daisy": true,
-  "Cross": true,
-  "2x2x2": true,
-  "2x2x3": true,
-  "Void Cube": true,
-  "invisible": true,
-  "picture": true,
-  "experimental-centers-U": true,
-  "experimental-centers-U-D": true,
-  "experimental-centers-U-L-D": true,
-  "experimental-centers-U-L-B-D": true,
-  "experimental-centers": true,
-  "experimental-fto-fc": true,
-  "experimental-fto-f2t": true,
-  "experimental-fto-sc": true,
-  "experimental-fto-l2c": true,
-  "experimental-fto-lbt": true,
-  "experimental-fto-l3t": true,
-  "experimental-global-custom-1": true,
-  "experimental-global-custom-2": true
-};
-var StickeringProp = class extends SimpleTwistyPropSource {
-  getDefaultValue() {
-    return "full";
-  }
-};
-
 // src/cubing/twisty/controllers/easing.ts
 function smootherStep(x) {
   return x * x * x * (10 - x * (15 - 6 * x));
 }
 
-// src/cubing/twisty/views/3D/TAU.ts
-var TAU = Math.PI * 2;
-var DEGREES_PER_RADIAN = 360 / TAU;
-
 // src/cubing/twisty/views/3D/puzzles/Cube3D.ts
 var svgLoader = new TextureLoader();
 var ignoredMaterial = new MeshBasicMaterial({
@@ -801,9 +410,9 @@ function sharedStickerGeometry() {
   return sharedStickerGeometryCache ?? (sharedStickerGeometryCache = newStickerGeometry());
 }
 var Cube3D = class extends Object3D {
-  constructor(def, scheduleRenderCallback, options = {}) {
+  constructor(kpuzzle, scheduleRenderCallback, options = {}) {
     super();
-    this.def = def;
+    this.kpuzzle = kpuzzle;
     this.scheduleRenderCallback = scheduleRenderCallback;
     this.pieces = {};
     this.experimentalHintStickerMeshes = [];
@@ -820,8 +429,8 @@ var Cube3D = class extends Object3D {
     });
     this.options = { ...cube3DOptionsDefaults };
     Object.assign(this.options, options);
-    if (this.def.name !== "3x3x3") {
-      throw new Error(`Invalid puzzle for this Cube3D implementation: ${this.def.name}`);
+    if (this.kpuzzle.name() !== "3x3x3") {
+      throw new Error(`Invalid puzzle for this Cube3D implementation: ${this.kpuzzle.name()}`);
     }
     if (options.foundationSprite) {
       this.setSprite(options.foundationSprite);
@@ -914,18 +523,18 @@ var Cube3D = class extends Object3D {
     for (const orbit in pieceDefs) {
       const pieces = pieceDefs[orbit];
       for (let i = 0; i < pieces.length; i++) {
-        const j = reid333[orbit].permutation[i];
+        const j = reid333.stateData[orbit].pieces[i];
         this.pieces[orbit][j].matrix.copy(pieceDefs[orbit][i].matrix);
-        this.pieces[orbit][j].matrix.multiply(orientationRotation[orbit][reid333[orbit].orientation[i]]);
+        this.pieces[orbit][j].matrix.multiply(orientationRotation[orbit][reid333.stateData[orbit].orientation[i]]);
       }
       for (const moveProgress of p.movesInProgress) {
         const move = moveProgress.move;
         const turnNormal = axesInfo[familyToAxis[move.family]].vector;
         const moveMatrix = new Matrix4().makeRotationAxis(turnNormal, -this.ease(moveProgress.fraction) * moveProgress.direction * move.amount * TAU / 4);
         for (let i = 0; i < pieces.length; i++) {
-          const k = this.def.moves[move.family][orbit].permutation[i];
-          if (i !== k || this.def.moves[move.family][orbit].orientation[i] !== 0) {
-            const j = reid333[orbit].permutation[i];
+          const k = this.kpuzzle.definition.moves[move.family][orbit].permutation[i];
+          if (i !== k || this.kpuzzle.definition.moves[move.family][orbit].orientation[i] !== 0) {
+            const j = reid333.stateData[orbit].pieces[i];
             this.pieces[orbit][j].matrix.premultiply(moveMatrix);
           }
         }
@@ -1380,15 +989,14 @@ var AxisInfo2 = class {
 };
 var DEFAULT_COLOR_FRACTION = 0.71;
 var PG_SCALE = 0.5;
-var _pendingStickeringUpdate, _cachedKPuzzle, _kpuzzle, kpuzzle_get, _isValidMove, isValidMove_fn;
+var _pendingStickeringUpdate, _isValidMove, isValidMove_fn;
 var PG3D = class extends Object3D2 {
-  constructor(scheduleRenderCallback, definition, stickerDat, enableFoundationOpt = false, enableHintStickersOpt = false, hintStickerHeightScale = 1, params = {}) {
+  constructor(scheduleRenderCallback, kpuzzle, stickerDat, enableFoundationOpt = false, enableHintStickersOpt = false, hintStickerHeightScale = 1, params = {}) {
     super();
     this.scheduleRenderCallback = scheduleRenderCallback;
-    this.definition = definition;
+    this.kpuzzle = kpuzzle;
     this.stickerDat = stickerDat;
     this.params = params;
-    __privateAdd(this, _kpuzzle);
     __privateAdd(this, _isValidMove);
     this.stickerTargets = [];
     this.controlTargets = [];
@@ -1396,7 +1004,6 @@ var PG3D = class extends Object3D2 {
     this.showHintStickers = false;
     this.showFoundations = false;
     __privateAdd(this, _pendingStickeringUpdate, false);
-    __privateAdd(this, _cachedKPuzzle, void 0);
     if (stickerDat.stickers.length === 0) {
       throw Error("Reuse of stickerdat from pg; please don't do that.");
     }
@@ -1550,15 +1157,13 @@ var PG3D = class extends Object3D2 {
     if (transformations.invert) {
       closestMove = closestMove.invert();
     }
-    __privateGet(this, _kpuzzle, kpuzzle_get).reset();
-    __privateGet(this, _kpuzzle, kpuzzle_get).applyMove(closestMove);
-    const order = transformationOrder(this.definition, __privateGet(this, _kpuzzle, kpuzzle_get).state);
+    const order = this.kpuzzle.moveToTransformation(closestMove).repetitionOrder();
     return { move: closestMove, order };
   }
   experimentalSetAppearance(appearance) {
     this.params.appearance = appearance;
-    for (const orbitName in this.definition.orbits) {
-      const { numPieces, orientations } = this.definition.orbits[orbitName];
+    for (const orbitName in this.kpuzzle.definition.orbits) {
+      const { numPieces, numOrientations: orientations } = this.kpuzzle.definition.orbits[orbitName];
       for (let pieceIdx = 0; pieceIdx < numPieces; pieceIdx++) {
         for (let faceletIdx = 0; faceletIdx < orientations; faceletIdx++) {
           const faceletAppearance = getFaceletAppearance(appearance, orbitName, pieceIdx, faceletIdx, false);
@@ -1576,16 +1181,19 @@ var PG3D = class extends Object3D2 {
     }
   }
   onPositionChange(p) {
-    const state = p.state;
+    const transformation = p.state.experimentalToTransformation();
+    if (!transformation) {
+      throw new Error("indistinguishable pieces are not supported by PG3D yet");
+    }
     const noRotation = new Euler2();
     this.movingObj.rotation.copy(noRotation);
     let colormods = 0;
     const filler = this.filler;
     const ind = filler.ind;
-    if (!this.lastPos || __privateGet(this, _pendingStickeringUpdate) || !areTransformationsEquivalent(this.definition, this.lastPos.state, state)) {
+    if (!this.lastPos || __privateGet(this, _pendingStickeringUpdate) || !this.lastPos.state.experimentalToTransformation().isIdentical(transformation)) {
       for (const orbit in this.stickers) {
         const pieces = this.stickers[orbit];
-        const pos2 = state[orbit];
+        const pos2 = transformation.transformationData[orbit];
         const orin = pieces.length;
         if (orin === 1) {
           const pieces2 = pieces[0];
@@ -1619,20 +1227,17 @@ var PG3D = class extends Object3D2 {
     for (const moveProgress of p.movesInProgress) {
       const externalMove = moveProgress.move;
       const unswizzled = this.stickerDat.unswizzle(externalMove);
-      const move = this.stickerDat.notationMapper.notationToInternal(externalMove);
-      if (move === null) {
-        throw Error("Bad blockmove " + externalMove.family);
-      }
-      const quantumTransformation = transformationForQuantumMove(this.definition, externalMove.quantum);
+      const move = externalMove;
+      const quantumTransformation = this.kpuzzle.moveToTransformation(move.modified({ amount: 1 }));
       const ax = this.axesInfo[unswizzled];
       const turnNormal = ax.axis;
       const angle = -this.ease(moveProgress.fraction) * moveProgress.direction * move.amount * TAU / ax.order;
       this.movingObj.rotateOnAxis(turnNormal, angle);
-      if (this.lastMove !== quantumTransformation) {
+      if (this.lastMoveTransformation !== quantumTransformation) {
         for (const orbit in this.stickers) {
           const pieces = this.stickers[orbit];
           const orin = pieces.length;
-          const bmv = quantumTransformation[orbit];
+          const bmv = quantumTransformation.transformationData[orbit];
           for (let ori = 0; ori < orin; ori++) {
             const pieces2 = pieces[ori];
             for (let i = 0; i < pieces2.length; i++) {
@@ -1670,7 +1275,7 @@ var PG3D = class extends Object3D2 {
             }
           }
         }
-        this.lastMove = quantumTransformation;
+        this.lastMoveTransformation = quantumTransformation;
       }
     }
     if (vismods) {
@@ -1827,31 +1432,25 @@ var PG3D = class extends Object3D2 {
   }
 };
 _pendingStickeringUpdate = new WeakMap();
-_cachedKPuzzle = new WeakMap();
-_kpuzzle = new WeakSet();
-kpuzzle_get = function() {
-  return __privateGet(this, _cachedKPuzzle) ?? __privateSet(this, _cachedKPuzzle, new KPuzzle(this.definition));
-};
 _isValidMove = new WeakSet();
 isValidMove_fn = function(move) {
   try {
-    __privateGet(this, _kpuzzle, kpuzzle_get).applyMove(move);
+    this.kpuzzle.moveToTransformation(move);
     return true;
   } catch (_) {
     return false;
   }
 };
 
-// src/cubing/twisty/heavy-code-imports/dynamic-entries/3d.ts
+// src/cubing/twisty/heavy-code-imports/dynamic-entries/3d-dynamic-inside.ts
 import * as T3I from "three";
 
 // src/cubing/twisty/views/3D/Twisty3DScene.ts
-import { Scene as ThreeScene } from "three";
-var Twisty3DScene = class extends ThreeScene {
+var Twisty3DScene = class {
   constructor() {
-    super();
     this.renderTargets = new Set();
     this.twisty3Ds = new Set();
+    this.threeJSScene = (async () => new (await THREEJS).Scene())();
   }
   addRenderTarget(renderTarget) {
     this.renderTargets.add(renderTarget);
@@ -1861,50 +1460,39 @@ var Twisty3DScene = class extends ThreeScene {
       renderTarget.scheduleRender();
     }
   }
-  addTwisty3DPuzzle(twisty3DPuzzle) {
+  async addTwisty3DPuzzle(twisty3DPuzzle) {
     this.twisty3Ds.add(twisty3DPuzzle);
-    this.add(twisty3DPuzzle);
+    (await this.threeJSScene).add(twisty3DPuzzle);
   }
-  removeTwisty3DPuzzle(twisty3DPuzzle) {
+  async removeTwisty3DPuzzle(twisty3DPuzzle) {
     this.twisty3Ds.delete(twisty3DPuzzle);
-    this.remove(twisty3DPuzzle);
+    (await this.threeJSScene).remove(twisty3DPuzzle);
   }
-  clearPuzzles() {
+  async clearPuzzles() {
     for (const puz of this.twisty3Ds) {
-      this.remove(puz);
+      (await this.threeJSScene).remove(puz);
     }
     this.twisty3Ds.clear();
   }
 };
 
-// src/cubing/twisty/heavy-code-imports/dynamic-entries/3d.ts
+// src/cubing/twisty/heavy-code-imports/dynamic-entries/3d-dynamic-inside.ts
 async function cube3DShim(options) {
   const renderCallbackShim = () => {
   };
-  return new Cube3D(await cube3x3x3.def(), renderCallbackShim, options);
+  return new Cube3D(await cube3x3x3.kpuzzle(), renderCallbackShim, options);
 }
 async function pg3dShim(puzzleLoader, hintFacelets) {
   const renderCallbackShim = () => {
   };
-  return new PG3D(renderCallbackShim, await puzzleLoader.def(), (await puzzleLoader.pg()).get3d(), true, hintFacelets === "floating");
+  return new PG3D(renderCallbackShim, await puzzleLoader.kpuzzle(), (await puzzleLoader.pg()).get3d(), true, hintFacelets === "floating");
 }
-
 export {
-  StaleDropper,
-  from,
-  TwistyPropSource,
-  SimpleTwistyPropSource,
-  NO_VALUE,
-  TwistyPropDerived,
-  FreshListenerManager,
-  HintFaceletProp,
-  StickeringProp,
-  DEGREES_PER_RADIAN,
   Cube3D,
   PG3D,
+  T3I,
   Twisty3DScene,
   cube3DShim,
-  pg3dShim,
-  T3I
+  pg3dShim
 };
-//# sourceMappingURL=chunk-N3RNWU5T.js.map
+//# sourceMappingURL=3d-dynamic-inside-OGANXBOW.js.map