cubing 0.22.0 → 0.24.0-pre2

package/dist/types/stream/index.d.ts

@@ -1,4 +1,3 @@
 export type { ProxyEvent, ProxyMoveEvent, ProxyOrientationEvent, ProxyResetEvent, } from "./proxy-event";
 export { WebSocketProxyReceiver, WebSocketProxySender, } from "./websocket-proxy";
 export { TwizzleStreamServer } from "./twizzle/TwizzleStream";
-//# sourceMappingURL=index.d.ts.map

package/dist/types/stream/process/ReorientedStream.d.ts

@@ -1,5 +1,4 @@
 import { Move } from "../../alg";
-import { KPuzzle } from "../../kpuzzle";
 export interface PuzzleStreamMoveEventDetail {
     move: Move;
 }
@@ -9,7 +8,7 @@ export interface PuzzleStreamMoveEvent {
 }
 export declare type PuzzleStreamMoveEventRegisterCompatible = CustomEvent<PuzzleStreamMoveEventDetail>;
 declare class OrientationTracker {
-    kpuzzle: KPuzzle;
+    state: import("../../kpuzzle").KState;
     processMove(move: Move): Move[];
 }
 export declare class ReorientedStream extends EventTarget {
@@ -19,4 +18,3 @@ export declare class ReorientedStream extends EventTarget {
     onMove(event: PuzzleStreamMoveEvent): void;
 }
 export {};
-//# sourceMappingURL=ReorientedStream.d.ts.map

package/dist/types/stream/proxy-event.d.ts

@@ -11,4 +11,3 @@ export interface ProxyResetEvent {
     event: "reset";
 }
 export declare type ProxyEvent = ProxyMoveEvent | ProxyOrientationEvent | ProxyResetEvent;
-//# sourceMappingURL=proxy-event.d.ts.map

package/dist/types/stream/twizzle/TwizzleStream.d.ts

@@ -16,4 +16,3 @@ export declare class TwizzleStreamServer {
     connect(streamID: string): TwizzleStream;
 }
 export {};
-//# sourceMappingURL=TwizzleStream.d.ts.map

package/dist/types/stream/twizzle/stream-types.d.ts

@@ -30,4 +30,3 @@ export declare type StreamMessageEvent = {
     event: "reset";
     data: ResetEvent;
 };
-//# sourceMappingURL=stream-types.d.ts.map

package/dist/types/stream/websocket-proxy.d.ts

@@ -19,4 +19,3 @@ export declare abstract class WebSocketProxyReceiver {
     protected onmessage(e: MessageEvent): void;
     abstract onProxyEvent(e: ProxyEvent): void;
 }
-//# sourceMappingURL=websocket-proxy.d.ts.map

package/dist/types/twisty/controllers/AnimationTypes.d.ts

@@ -1,5 +1,5 @@
 import type { Move } from "../../alg";
-import type { Transformation as KPuzzleState } from "../../kpuzzle";
+import type { KState } from "../../kpuzzle/KState";
 export declare type MillisecondTimestamp = number;
 export declare type Duration = MillisecondTimestamp;
 export declare type Timestamp = MillisecondTimestamp;
@@ -16,7 +16,7 @@ export interface MoveInProgress {
     fraction: number;
 }
 export declare type PuzzlePosition = {
-    state: KPuzzleState;
+    state: KState;
     movesInProgress: MoveInProgress[];
 };
 export declare enum BoundaryType {
@@ -30,4 +30,3 @@ export interface TimeRange {
 export interface PositionListener {
     onPositionChange(position: PuzzlePosition): void;
 }
-//# sourceMappingURL=AnimationTypes.d.ts.map

package/dist/types/twisty/controllers/RenderScheduler.d.ts

@@ -10,4 +10,3 @@ export declare class RenderScheduler {
 export interface Schedulable {
     scheduleRender(): void;
 }
-//# sourceMappingURL=RenderScheduler.d.ts.map

package/dist/types/twisty/controllers/TwistyAnimationController.d.ts

@@ -34,4 +34,3 @@ export declare class TwistyAnimationController {
     pause(): void;
     animFrame(frameDatestamp: MillisecondTimestamp): Promise<void>;
 }
-//# sourceMappingURL=TwistyAnimationController.d.ts.map

package/dist/types/twisty/controllers/TwistyPlayerController.d.ts

@@ -13,4 +13,3 @@ export declare class TwistyPlayerController {
     togglePlay(play?: boolean): void;
     visitTwizzleLink(): Promise<void>;
 }
-//# sourceMappingURL=TwistyPlayerController.d.ts.map

package/dist/types/twisty/controllers/easing.d.ts

@@ -1,2 +1 @@
 export declare function smootherStep(x: number): number;
-//# sourceMappingURL=easing.d.ts.map

package/dist/types/twisty/controllers/indexer/AlgDuration.d.ts

@@ -15,4 +15,3 @@ export declare class AlgDuration extends TraversalUp<Duration> {
     traverseNewline(_newline: Newline): Duration;
     traverseLineComment(_comment: LineComment): Duration;
 }
-//# sourceMappingURL=AlgDuration.d.ts.map

package/dist/types/twisty/controllers/indexer/AlgIndexer.d.ts

@@ -1,5 +1,6 @@
 import type { Move } from "../../../alg/units";
-import type { PuzzleWrapper, State } from "../../views/3D/puzzles/KPuzzleWrapper";
+import type { KTransformation } from "../../../kpuzzle";
+import type { KState } from "../../../kpuzzle/KState";
 import type { Direction, Duration, MillisecondTimestamp, PuzzlePosition, Timestamp } from "../AnimationTypes";
 import type { AnimatedLeafUnit } from "./simultaneous-moves/simul-moves";
 export interface CurrentMove {
@@ -21,16 +22,15 @@ export interface CurrentMoveInfo {
     earliestEnd: number;
 }
 export declare function currentMoveInfoEquals(c1: CurrentMoveInfo, c2: CurrentMoveInfo): boolean;
-export interface AlgIndexer<P extends PuzzleWrapper> {
+export interface AlgIndexer {
     getAnimLeaf(index: number): AnimatedLeafUnit | null;
     indexToMoveStartTimestamp(index: number): Timestamp;
-    stateAtIndex(index: number, startTransformation?: State<P>): State<P>;
-    transformAtIndex(index: number): State<P>;
+    stateAtIndex(index: number, startSTate?: KState): KState;
+    transformationAtIndex(index: number): KTransformation;
     numAnimatedLeaves(): number;
     timestampToIndex(timestamp: Timestamp): number;
     algDuration(): Duration;
     moveDuration(index: number): number;
-    timestampToPosition?: (timestamp: Timestamp, startTransformation?: State<P>) => PuzzlePosition;
+    timestampToPosition?: (timestamp: Timestamp, startState?: KState) => PuzzlePosition;
     currentMoveInfo?: (timestamp: Timestamp) => CurrentMoveInfo;
 }
-//# sourceMappingURL=AlgIndexer.d.ts.map

package/dist/types/twisty/controllers/indexer/SimpleAlgIndexer.d.ts

@@ -1,19 +1,19 @@
 import { Alg, Move } from "../../../alg";
-import type { PuzzleWrapper, State } from "../../views/3D/puzzles/KPuzzleWrapper";
+import type { KPuzzle, KTransformation } from "../../../kpuzzle";
+import type { KState } from "../../../kpuzzle/KState";
 import type { Duration, Timestamp } from "../AnimationTypes";
 import type { AlgIndexer } from "./AlgIndexer";
-export declare class SimpleAlgIndexer<P extends PuzzleWrapper> implements AlgIndexer<P> {
-    private puzzle;
+export declare class SimpleAlgIndexer implements AlgIndexer {
+    private kpuzzle;
     private moves;
     private durationFn;
-    constructor(puzzle: P, alg: Alg);
+    constructor(kpuzzle: KPuzzle, alg: Alg);
     getAnimLeaf(index: number): Move;
     indexToMoveStartTimestamp(index: number): Timestamp;
     timestampToIndex(timestamp: Timestamp): number;
-    stateAtIndex(index: number): State<P>;
-    transformAtIndex(index: number): State<P>;
+    stateAtIndex(index: number): KState;
+    transformationAtIndex(index: number): KTransformation;
     algDuration(): Duration;
     numAnimatedLeaves(): number;
     moveDuration(index: number): number;
 }
-//# sourceMappingURL=SimpleAlgIndexer.d.ts.map

package/dist/types/twisty/controllers/indexer/simultaneous-moves/SimultaneousMoveIndexer.d.ts

@@ -1,21 +1,21 @@
 import { Alg } from "../../../../alg";
-import type { PuzzleWrapper, State } from "../../../views/3D/puzzles/KPuzzleWrapper";
+import type { KPuzzle, KTransformation } from "../../../../kpuzzle";
+import type { KState } from "../../../../kpuzzle/KState";
 import { Duration, PuzzlePosition, Timestamp } from "../../AnimationTypes";
 import type { AlgIndexer } from "../AlgIndexer";
 import { AnimatedLeafUnit } from "./simul-moves";
-export declare class SimultaneousMoveIndexer<P extends PuzzleWrapper> implements AlgIndexer<P> {
-    private puzzle;
+export declare class SimultaneousMoveIndexer implements AlgIndexer {
+    private kpuzzle;
     private animLeaves;
-    constructor(puzzle: P, alg: Alg);
+    constructor(kpuzzle: KPuzzle, alg: Alg);
     getAnimLeaf(index: number): AnimatedLeafUnit | null;
     private getAnimLeafWithRange;
     indexToMoveStartTimestamp(index: number): Timestamp;
     timestampToIndex(timestamp: Timestamp): number;
-    timestampToPosition(timestamp: Timestamp, startTransformation?: State<P>): PuzzlePosition;
-    stateAtIndex(index: number, startTransformation?: State<P>): State<P>;
-    transformAtIndex(index: number): State<P>;
+    timestampToPosition(timestamp: Timestamp, startTransformation?: KState): PuzzlePosition;
+    stateAtIndex(index: number, startTransformation?: KState): KState;
+    transformationAtIndex(index: number): KTransformation;
     algDuration(): Duration;
     numAnimatedLeaves(): number;
     moveDuration(index: number): number;
 }
-//# sourceMappingURL=SimultaneousMoveIndexer.d.ts.map

package/dist/types/twisty/controllers/indexer/simultaneous-moves/SimultaneousMoveIndexerV2.d.ts

@@ -1,22 +1,22 @@
 import { Alg } from "../../../../alg";
-import type { PuzzleWrapper, State } from "../../../views/3D/puzzles/KPuzzleWrapper";
+import type { KPuzzle, KTransformation } from "../../../../kpuzzle";
+import type { KState } from "../../../../kpuzzle/KState";
 import { Duration, PuzzlePosition, Timestamp } from "../../AnimationTypes";
-import type { AlgIndexer, CurrentMoveInfo } from "../AlgIndexer";
+import type { CurrentMoveInfo } from "../AlgIndexer";
 import { AnimatedLeafUnit } from "./simul-moves";
-export declare class SimultaneousMoveIndexerV2<P extends PuzzleWrapper> implements AlgIndexer<P> {
-    private puzzle;
+export declare class SimultaneousMoveIndexerV2 {
+    private kpuzzle;
     private animLeaves;
-    constructor(puzzle: P, alg: Alg);
+    constructor(kpuzzle: KPuzzle, alg: Alg);
     getAnimLeaf(index: number): AnimatedLeafUnit | null;
     private getAnimLeafWithRange;
     indexToMoveStartTimestamp(index: number): Timestamp;
     timestampToIndex(timestamp: Timestamp): number;
-    timestampToPosition(timestamp: Timestamp, startTransformation?: State<P>): PuzzlePosition;
+    timestampToPosition(timestamp: Timestamp, startState?: KState): PuzzlePosition;
     currentMoveInfo(timestamp: Timestamp): CurrentMoveInfo;
-    stateAtIndex(index: number, startTransformation?: State<P>): State<P>;
-    transformAtIndex(index: number): State<P>;
+    stateAtIndex(index: number, startState?: KState): KState;
+    transformationAtIndex(index: number): KTransformation;
     algDuration(): Duration;
     numAnimatedLeaves(): number;
     moveDuration(index: number): number;
 }
-//# sourceMappingURL=SimultaneousMoveIndexerV2.d.ts.map

package/dist/types/twisty/controllers/indexer/simultaneous-moves/simul-moves.d.ts

@@ -23,4 +23,3 @@ export declare class LocalSimulMoves extends TraversalUp<LocalAnimLeavesWithRang
     traverseLineComment(_comment: LineComment): LocalAnimLeavesWithRange[];
 }
 export declare function simulMoves(a: Alg): AnimLeafWithRange[];
-//# sourceMappingURL=simul-moves.d.ts.map

package/dist/types/twisty/controllers/indexer/tree/AlgWalker.d.ts

@@ -1,64 +1,63 @@
-import { Alg, Grouping, LineComment, Commutator, Conjugate, Move, Newline, Pause, TraversalDownUp, TraversalUp, Unit } from "../../../../alg";
-import type { PuzzleWrapper, State } from "../../../views/3D/puzzles/KPuzzleWrapper";
-export declare class AlgPartDecoration<P extends PuzzleWrapper> {
+import { Alg, Commutator, Conjugate, Grouping, LineComment, Move, Newline, Pause, TraversalDownUp, TraversalUp, Unit } from "../../../../alg";
+import type { KPuzzle, KTransformation } from "../../../../kpuzzle";
+export declare class AlgPartDecoration {
     moveCount: number;
     duration: number;
-    forward: State<P>;
-    backward: State<P>;
-    children: Array<AlgPartDecoration<P>>;
-    constructor(_puz: PuzzleWrapper, moveCount: number, duration: number, forward: State<P>, backward: State<P>, children?: Array<AlgPartDecoration<P>>);
+    forward: KTransformation;
+    backward: KTransformation;
+    children: Array<AlgPartDecoration>;
+    constructor(moveCount: number, duration: number, forward: KTransformation, backward: KTransformation, children?: Array<AlgPartDecoration>);
 }
-export declare class DecoratorConstructor<P extends PuzzleWrapper> extends TraversalUp<AlgPartDecoration<P>> {
-    private puz;
+export declare class DecoratorConstructor extends TraversalUp<AlgPartDecoration> {
+    private kpuzzle;
     private identity;
     private dummyLeaf;
     private durationFn;
     private cache;
-    constructor(puz: PuzzleWrapper);
-    traverseAlg(alg: Alg): AlgPartDecoration<P>;
-    traverseGrouping(grouping: Grouping): AlgPartDecoration<P>;
-    traverseMove(move: Move): AlgPartDecoration<P>;
-    traverseCommutator(commutator: Commutator): AlgPartDecoration<P>;
-    traverseConjugate(conjugate: Conjugate): AlgPartDecoration<P>;
-    traversePause(pause: Pause): AlgPartDecoration<P>;
-    traverseNewline(_newline: Newline): AlgPartDecoration<P>;
-    traverseLineComment(_comment: LineComment): AlgPartDecoration<P>;
+    constructor(kpuzzle: KPuzzle);
+    traverseAlg(alg: Alg): AlgPartDecoration;
+    traverseGrouping(grouping: Grouping): AlgPartDecoration;
+    traverseMove(move: Move): AlgPartDecoration;
+    traverseCommutator(commutator: Commutator): AlgPartDecoration;
+    traverseConjugate(conjugate: Conjugate): AlgPartDecoration;
+    traversePause(pause: Pause): AlgPartDecoration;
+    traverseNewline(_newline: Newline): AlgPartDecoration;
+    traverseLineComment(_comment: LineComment): AlgPartDecoration;
     private mult;
 }
-declare class WalkerDown<P extends PuzzleWrapper> {
-    apd: AlgPartDecoration<P>;
+declare class WalkerDown {
+    apd: AlgPartDecoration;
     back: boolean;
-    constructor(apd: AlgPartDecoration<P>, back: boolean);
+    constructor(apd: AlgPartDecoration, back: boolean);
 }
-export declare class AlgWalker<P extends PuzzleWrapper> extends TraversalDownUp<WalkerDown<P>, boolean> {
-    puz: P;
+export declare class AlgWalker extends TraversalDownUp<WalkerDown, boolean> {
+    kpuzzle: KPuzzle;
     algOrUnit: Alg | Unit;
-    apd: AlgPartDecoration<P>;
+    apd: AlgPartDecoration;
     move?: Unit;
     moveDuration: number;
     back: boolean;
-    st: State<P>;
-    root: WalkerDown<P>;
+    st: KTransformation;
+    root: WalkerDown;
     i: number;
     dur: number;
     private goali;
     private goaldur;
-    constructor(puz: P, algOrUnit: Alg | Unit, // TODO: can we keep these separate?
-    apd: AlgPartDecoration<P>);
+    constructor(kpuzzle: KPuzzle, algOrUnit: Alg | Unit, // TODO: can we keep these separate?
+    apd: AlgPartDecoration);
     moveByIndex(loc: number): boolean;
     moveByDuration(dur: number): boolean;
     dosearch(loc: number, dur: number): boolean;
-    traverseAlg(alg: Alg, wd: WalkerDown<P>): boolean;
-    traverseGrouping(grouping: Grouping, wd: WalkerDown<P>): boolean;
-    traverseMove(move: Move, wd: WalkerDown<P>): boolean;
-    traverseCommutator(commutator: Commutator, wd: WalkerDown<P>): boolean;
-    traverseConjugate(conjugate: Conjugate, wd: WalkerDown<P>): boolean;
-    traversePause(pause: Pause, wd: WalkerDown<P>): boolean;
-    traverseNewline(_newline: Newline, _wd: WalkerDown<P>): boolean;
-    traverseLineComment(_lineComment: LineComment, _wd: WalkerDown<P>): boolean;
+    traverseAlg(alg: Alg, wd: WalkerDown): boolean;
+    traverseGrouping(grouping: Grouping, wd: WalkerDown): boolean;
+    traverseMove(move: Move, wd: WalkerDown): boolean;
+    traverseCommutator(commutator: Commutator, wd: WalkerDown): boolean;
+    traverseConjugate(conjugate: Conjugate, wd: WalkerDown): boolean;
+    traversePause(pause: Pause, wd: WalkerDown): boolean;
+    traverseNewline(_newline: Newline, _wd: WalkerDown): boolean;
+    traverseLineComment(_lineComment: LineComment, _wd: WalkerDown): boolean;
     private firstcheck;
     private domult;
     private keepgoing;
 }
 export {};
-//# sourceMappingURL=AlgWalker.d.ts.map

package/dist/types/twisty/controllers/indexer/tree/TreeAlgIndexer.d.ts

@@ -1,20 +1,20 @@
 import type { Alg, Move } from "../../../../alg";
-import type { PuzzleWrapper, State } from "../../../views/3D/puzzles/KPuzzleWrapper";
+import type { KPuzzle, KTransformation } from "../../../../kpuzzle";
+import type { KState } from "../../../../kpuzzle/KState";
 import type { Duration, Timestamp } from "../../AnimationTypes";
 import type { AlgIndexer } from "../AlgIndexer";
-export declare class TreeAlgIndexer implements AlgIndexer<PuzzleWrapper> {
-    private puzzle;
+export declare class TreeAlgIndexer implements AlgIndexer {
+    private kpuzzle;
     private decoration;
     private walker;
-    constructor(puzzle: PuzzleWrapper, alg: Alg);
+    constructor(kpuzzle: KPuzzle, alg: Alg);
     getAnimLeaf(index: number): Move | null;
     indexToMoveStartTimestamp(index: number): Timestamp;
     indexToMovesInProgress(index: number): Timestamp;
-    stateAtIndex(index: number, startTransformation?: State<PuzzleWrapper>): State<PuzzleWrapper>;
-    transformAtIndex(index: number): State<PuzzleWrapper>;
+    stateAtIndex(index: number, startState?: KState): KState;
+    transformationAtIndex(index: number): KTransformation;
     numAnimatedLeaves(): number;
     timestampToIndex(timestamp: Timestamp): number;
     algDuration(): Duration;
     moveDuration(index: number): number;
 }
-//# sourceMappingURL=TreeAlgIndexer.d.ts.map

package/dist/types/twisty/controllers/indexer/tree/chunkAlgs.d.ts

@@ -1,3 +1,2 @@
 import { Alg } from "../../../../alg";
 export declare const chunkAlgs: (alg: Alg) => Alg;
-//# sourceMappingURL=chunkAlgs.d.ts.map

package/dist/types/twisty/controllers/stream/timeline-move-calculation-draft.d.ts

@@ -13,4 +13,3 @@ declare type Timeline = TimelineEntry[];
 export declare function toAxes(events: Event[], diameterMs: Duration): TimelineEntry[][];
 export declare function toTimeline(events: Event[], diameterMs?: number): Timeline;
 export {};
-//# sourceMappingURL=timeline-move-calculation-draft.d.ts.map

package/dist/types/twisty/heavy-code-imports/3d.d.ts

@@ -1,3 +1,2 @@
 export declare function proxy3D(): Promise<typeof import("./dynamic-entries/3d")>;
 export declare const THREEJS: Promise<typeof import("three")>;
-//# sourceMappingURL=3d.d.ts.map

package/dist/types/twisty/heavy-code-imports/dynamic-entries/3d.d.ts

@@ -8,4 +8,3 @@ export { PG3D } from "../../views/3D/puzzles/PG3D";
 export { Twisty3DScene } from "../../views/3D/Twisty3DScene";
 export declare function cube3DShim(options?: Cube3DOptions): Promise<Cube3D>;
 export declare function pg3dShim(puzzleLoader: PuzzleLoader, hintFacelets: HintFaceletStyle): Promise<PG3D>;
-//# sourceMappingURL=3d.d.ts.map

package/dist/types/twisty/index.d.ts

@@ -14,5 +14,4 @@ export { PG3D } from "./views/3D/puzzles/PG3D";
 export type { AlgIndexer } from "./controllers/indexer/AlgIndexer";
 export { SimpleAlgIndexer } from "./controllers/indexer/SimpleAlgIndexer";
 export { TreeAlgIndexer } from "./controllers/indexer/tree/TreeAlgIndexer";
-export { KPuzzleWrapper as KSolvePuzzle } from "./views/3D/puzzles/KPuzzleWrapper";
-//# sourceMappingURL=index.d.ts.map
+export { KPuzzleSVGWrapper as ExperimentalKPuzzleSVGWrapper } from "./views/2D/KPuzzleSVGWrapper";

package/dist/types/twisty/model/PromiseFreshener.d.ts

@@ -11,4 +11,3 @@ export declare class StaleDropper<T> {
     #private;
     queue(p: Promise<T>): Promise<T>;
 }
-//# sourceMappingURL=PromiseFreshener.d.ts.map

package/dist/types/twisty/model/TwistyPlayerModel.d.ts

@@ -29,12 +29,12 @@ import { AnchoredStartProp } from "./props/puzzle/state/AnchoredStartProp";
 import { TimeRangeProp } from "./props/viewer/TimeRangeProp";
 import { DetailedTimelineInfoProp } from "./props/timeline/DetailedTimelineInfoProp";
 import { CoarseTimelineInfoProp } from "./props/timeline/CoarseTimelineInfoProp";
-import { CurrentLeavesProp } from "./props/puzzle/state/CurrentLeavesProp";
+import { CurrentMoveInfoProp } from "./props/puzzle/state/CurrentMoveInfoProp";
 import { ButtonAppearanceProp } from "./props/viewer/ButtonAppearanceProp";
 import { CurrentLeavesSimplifiedProp } from "./props/puzzle/state/CurrentLeavesSimplified";
-import { CurrentTransformationProp } from "./props/puzzle/state/CurrentTransformationProp";
+import { CurrentStateProp as CurrentStateProp } from "./props/puzzle/state/CurrentStateProp";
 import { LegacyPositionProp } from "./props/puzzle/state/LegacyPositionProp";
-import { PuzzleDefProp } from "./props/puzzle/structure/PuzzleDefProp";
+import { KPuzzleProp } from "./props/puzzle/structure/KPuzzleProp";
 import { UserVisibleErrorTracker } from "./UserVisibleErrorTracker";
 import { CatchUpMoveProp } from "./props/puzzle/state/CatchUpMoveProp";
 import { Move } from "../../alg";
@@ -69,7 +69,7 @@ export declare class TwistyPlayerModel {
     foundationStickerSprite: SpriteProp;
     hintStickerSprite: SpriteProp;
     puzzleLoaderProp: PuzzleLoaderProp;
-    puzzleDefProp: PuzzleDefProp;
+    kpuzzleProp: KPuzzleProp;
     puzzleIDProp: PuzzleIDProp;
     puzzleAlgProp: PuzzleAlgProp;
     puzzleSetupProp: PuzzleAlgProp;
@@ -83,10 +83,10 @@ export declare class TwistyPlayerModel {
     timeRangeProp: TimeRangeProp;
     detailedTimelineInfoProp: DetailedTimelineInfoProp;
     coarseTimelineInfoProp: CoarseTimelineInfoProp;
-    currentLeavesProp: CurrentLeavesProp;
+    currentMoveInfoProp: CurrentMoveInfoProp;
     buttonAppearanceProp: ButtonAppearanceProp;
     currentLeavesSimplifiedProp: CurrentLeavesSimplifiedProp;
-    currentTransformationProp: CurrentTransformationProp;
+    currentStateProp: CurrentStateProp;
     legacyPositionProp: LegacyPositionProp;
     twizzleLink(): Promise<string>;
     experimentalAddMove(flexibleMove: Move | string, options?: {
@@ -94,4 +94,3 @@ export declare class TwistyPlayerModel {
         mod?: number;
     }): void;
 }
-//# sourceMappingURL=TwistyPlayerModel.d.ts.map

package/dist/types/twisty/model/UserVisibleErrorTracker.d.ts

@@ -8,4 +8,3 @@ export declare class UserVisibleErrorTracker extends SimpleTwistyPropSource<User
     canReuseValue(_v1: UserVisibleError, _v2: UserVisibleError): boolean;
 }
 export {};
-//# sourceMappingURL=UserVisibleErrorTracker.d.ts.map

package/dist/types/twisty/model/helpers.d.ts

@@ -2,4 +2,3 @@ export declare function arrayEquals<T>(a: readonly T[], b: readonly T[]): boolea
 export declare function arrayEqualsCompare<T>(a: readonly T[], b: readonly T[], compare: (a: T, b: T) => boolean): boolean;
 export declare function mod(v: number, m: number, offset?: number): number;
 export declare function modIntoRange(v: number, rangeMin: number, rangeMax: number): number;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/types/twisty/model/props/TwistyProp.d.ts

@@ -57,4 +57,3 @@ export declare class FreshListenerManager {
     disconnect(): void;
 }
 export {};
-//# sourceMappingURL=TwistyProp.d.ts.map

package/dist/types/twisty/model/props/TwistyProp.spec.d.ts

@@ -2,4 +2,3 @@
  * @jest-environment jsdom
  */
 export {};
-//# sourceMappingURL=TwistyProp.spec.d.ts.map

package/dist/types/twisty/model/props/TwistyPropDebugger.d.ts

@@ -25,4 +25,3 @@ export declare class TwistyPlayerDebugger extends ManagedCustomElement {
     getDescendants(prop: TwistyPropDebugger, accumulator?: Set<TwistyPropDebugger>): Set<TwistyPropDebugger>;
     getAncestors(prop: TwistyPropDebugger, accumulator?: Set<TwistyPropDebugger>): Set<TwistyPropDebugger>;
 }
-//# sourceMappingURL=TwistyPropDebugger.d.ts.map

package/dist/types/twisty/model/props/general/URLProp.d.ts

@@ -3,4 +3,3 @@ export declare class URLProp extends TwistyPropSource<URL | null, URL | string |
     getDefaultValue(): URL | null;
     derive(input: URL | string | null): URL | null;
 }
-//# sourceMappingURL=URLProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/display/FoundationDisplayProp.d.ts

@@ -3,4 +3,3 @@ export declare type FoundationDisplay = "auto" | "opaque" | "none";
 export declare class FoundationDisplayProp extends SimpleTwistyPropSource<FoundationDisplay> {
     getDefaultValue(): FoundationDisplay;
 }
-//# sourceMappingURL=FoundationDisplayProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/display/HintFaceletProp.d.ts

@@ -8,4 +8,3 @@ export declare type HintFaceletStyleWithAuto = HintFaceletStyle | "auto";
 export declare class HintFaceletProp extends SimpleTwistyPropSource<HintFaceletStyleWithAuto> {
     getDefaultValue(): HintFaceletStyleWithAuto;
 }
-//# sourceMappingURL=HintFaceletProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/display/SpriteProp.d.ts

@@ -7,4 +7,3 @@ export declare class SpriteProp extends TwistyPropDerived<SpritePropInputs, Text
     derive(inputs: SpritePropInputs): Promise<Texture | null>;
 }
 export {};
-//# sourceMappingURL=SpriteProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/display/StickeringProp.d.ts

@@ -18,6 +18,8 @@ export declare const experimentalStickerings: {
     VLS: boolean;
     LS: boolean;
     EO: boolean;
+    EOline: boolean;
+    EOcross: boolean;
     CMLL: boolean;
     L6E: boolean;
     L6EO: boolean;
@@ -46,4 +48,3 @@ export declare type ExperimentalStickering = keyof typeof experimentalStickering
 export declare class StickeringProp extends SimpleTwistyPropSource<ExperimentalStickering> {
     getDefaultValue(): ExperimentalStickering;
 }
-//# sourceMappingURL=StickeringProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/state/AlgProp.d.ts

@@ -24,4 +24,3 @@ export declare class AlgProp extends TwistyPropSource<AlgWithIssues, Alg | strin
     canReuseValue(v1: AlgWithIssues, v2: AlgWithIssues): boolean;
     derive(newAlg: Alg | string): Promise<AlgWithIssues>;
 }
-//# sourceMappingURL=AlgProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/state/AlgTransformationProp.d.ts

@@ -1,14 +1,11 @@
-import type { Alg } from "../../../../../alg";
-import type { KPuzzleDefinition, Transformation } from "../../../../../kpuzzle";
-import type { AlgWithIssues } from "./AlgProp";
+import type { KPuzzle, KTransformation } from "../../../../../kpuzzle";
 import { TwistyPropDerived } from "../../TwistyProp";
+import type { AlgWithIssues } from "./AlgProp";
 declare type AlgTransformationPropInputs = {
     alg: AlgWithIssues;
-    def: KPuzzleDefinition;
+    kpuzzle: KPuzzle;
 };
-export declare class AlgTransformationProp extends TwistyPropDerived<AlgTransformationPropInputs, Transformation> {
-    derive(input: AlgTransformationPropInputs): Transformation;
-    applyAlg(def: KPuzzleDefinition, alg: Alg): Transformation;
+export declare class AlgTransformationProp extends TwistyPropDerived<AlgTransformationPropInputs, KTransformation> {
+    derive(input: AlgTransformationPropInputs): KTransformation;
 }
 export {};
-//# sourceMappingURL=AlgTransformationProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/state/AnchoredStartProp.d.ts

@@ -1,15 +1,13 @@
-import { KPuzzleDefinition, Transformation } from "../../../../../kpuzzle";
+import type { KTransformation } from "../../../../../kpuzzle";
 import type { AlgIndexer } from "../../../../controllers/indexer/AlgIndexer";
 import { TwistyPropDerived } from "../../TwistyProp";
 import type { SetupToLocation } from "./SetupAnchorProp";
 interface AnchoredStartPropInputs {
     setupAnchor: SetupToLocation;
-    setupTransformation: Transformation;
-    indexer: AlgIndexer<any>;
-    def: KPuzzleDefinition;
+    setupTransformation: KTransformation;
+    indexer: AlgIndexer;
 }
-export declare class AnchoredStartProp extends TwistyPropDerived<AnchoredStartPropInputs, Transformation> {
-    derive(inputs: AnchoredStartPropInputs): Transformation;
+export declare class AnchoredStartProp extends TwistyPropDerived<AnchoredStartPropInputs, KTransformation> {
+    derive(inputs: AnchoredStartPropInputs): KTransformation;
 }
 export {};
-//# sourceMappingURL=AnchoredStartProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/state/CatchUpMoveProp.d.ts

@@ -8,4 +8,3 @@ export declare class CatchUpMoveProp extends SimpleTwistyPropSource<CatchUpMove>
     getDefaultValue(): CatchUpMove;
     canReuseValue(v1: CatchUpMove, v2: CatchUpMove): boolean;
 }
-//# sourceMappingURL=CatchUpMoveProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/state/CurrentLeavesSimplified.d.ts

@@ -14,4 +14,3 @@ export declare class CurrentLeavesSimplifiedProp extends TwistyPropDerived<Curre
     canReuse(v1: CurrentLeavesSimplified, v2: CurrentLeavesSimplified): boolean;
 }
 export {};
-//# sourceMappingURL=CurrentLeavesSimplified.d.ts.map

package/dist/types/twisty/model/props/puzzle/state/{CurrentLeavesProp.d.ts → CurrentMoveInfoProp.d.ts}

@@ -3,12 +3,11 @@ import type { DetailedTimelineInfo } from "../../timeline/DetailedTimelineInfoPr
 import { TwistyPropDerived } from "../../TwistyProp";
 import type { CatchUpMove } from "./CatchUpMoveProp";
 interface PositionPropInputs {
-    indexer: AlgIndexer<any>;
+    indexer: AlgIndexer;
     detailedTimelineInfo: DetailedTimelineInfo;
     catchUpMove: CatchUpMove;
 }
-export declare class CurrentLeavesProp extends TwistyPropDerived<PositionPropInputs, CurrentMoveInfo> {
+export declare class CurrentMoveInfoProp extends TwistyPropDerived<PositionPropInputs, CurrentMoveInfo> {
     derive(inputs: PositionPropInputs): CurrentMoveInfo;
 }
 export {};
-//# sourceMappingURL=CurrentLeavesProp.d.ts.map

package/dist/types/twisty/model/props/puzzle/state/CurrentStateProp.d.ts

@@ -0,0 +1,14 @@
+import type { KTransformation } from "../../../../../kpuzzle";
+import type { KState } from "../../../../../kpuzzle/KState";
+import type { AlgIndexer } from "../../../../controllers/indexer/AlgIndexer";
+import { TwistyPropDerived } from "../../TwistyProp";
+import type { CurrentLeavesSimplified } from "./CurrentLeavesSimplified";
+interface CurrentTransformationPropInputs {
+    anchoredStart: KTransformation;
+    currentLeavesSimplified: CurrentLeavesSimplified;
+    indexer: AlgIndexer;
+}
+export declare class CurrentStateProp extends TwistyPropDerived<CurrentTransformationPropInputs, KState> {
+    derive(inputs: CurrentTransformationPropInputs): KState;
+}
+export {};