index

Classes#

Class	Description
AdjustPhase	Tween-only phase between SPIN and STOP for MultiWays slots.
AnimatedSpriteSymbol	Symbol implementation using PixiJS AnimatedSprite. Swaps frame arrays on activate. Win animation plays the full sequence.
AnticipationPhase	Anticipation phase: the tease before a reel stops.
BoardGrid	A grid of cells that each spin independently - the generic “board of reels” primitive. Every cell is its own 1×1 ReelSet, so it inherits the engine’s phases, speed modes and pooling rather than a parallel lighter reel.
CardSymbol	One visible cell on a reel. the thing that actually draws.
CascadeDropInPhase	Drop-in half of the tumble cascade. Animates each visible symbol from its computed origin (above the viewport for new symbols, its old grid cell for survivors) down to its current grid position.
CascadeFallPhase	Fall-out half of the tumble cascade. Replaces `StartPhase` when the builder was configured with `.tumble(...)`.
CascadeMode	Cascade/tumble spinning mode. Symbols fall from above with gravity-like acceleration, used for tumble/avalanche mechanics.
CascadePlacePhase	Identity-swap half of the tumble cascade. Runs after `CascadeFallPhase` (Moment A) or right at the start of `refill()` (Moment B).
EmptySymbol	A ReelSymbol that renders nothing and never animates.
EventEmitter	Typed event emitter with zero dependencies.
FrameBuilder	Builds symbol frames using a middleware pipeline.
HoldAndWinBoard	A Hold & Win board: a grid of independently spinning cells plus the round choreography every H&W game repeats - spin the free cells, lock the hits, reset-or-decrement the respin counter, detect the full board.
HoldAndWinBuilder	Fluent builder for HoldAndWinBoard.
HoldAndWinState	The pure Hold & Win state machine - the single source of truth for board state, with zero PixiJS. It owns the locked-coin ledger, the respin counter, the round number, the set of dormant cells and the feature HwPhase; every derived value (`freeCells`, `isFull`, `capacity`) is computed from that state, never stored in parallel, so nothing can drift out of sync.
ImmediateMode	Immediate placement mode for super-turbo skip. Symbols snap to position instantly. no actual spinning animation.
ObjectPool	Generic object pool for reusing expensive-to-create objects.
PathMaskStrategy	Any mask you can draw, without the class.
PhaseCardSymbol	Debug / prototyping symbol - NOT for production.
PhaseFactory	Factory for creating reel phase instances.
RectMaskStrategy	v1 default: a per-reel rectangular mask. Each reel is clipped to its own `(mainOffset, extent)` box so pyramid shapes clip cleanly without buffer-cell peek above or below short reels.
Reel	One vertical column of a slot board.
ReelCurve	The curvature of one reel: a camera looking at a drum.
ReelPhase	Abstract base for reel spin phases.
ReelSet	The whole slot board as one object.
ReelSetBuilder	The configurator you call before every reel set.
ReelSymbol	One visible cell on a reel. the thing that actually draws.
ReelViewport	The clipping window + layering tricks for a reel set.
ReelWarp	Bend a whole reel, whatever is inside it.
RoundedRectMaskStrategy	Rounded-corner rectangles, per reel or per set.
SharedRectMaskStrategy	Single bounding-box mask covering every reel. Use this when symbols need to overlap across reel boundaries. typical for slots with big symbols that span multiple reels (a 2x2 bonus, a 3x3 giant) AND a non-zero cross-axis gap. Per-reel rects would clip those symbols at the gaps; a single shared rect keeps them visible.
SilhouetteMaskStrategy	Rounds the OUTLINE of the whole reel set, staircase and all.
SpeedManager	The tempo of your reels, as named presets.
SpineSymbol	Symbol implementation using Spine 2D skeletal animation.
SpinPhase	Continuous spinning at constant speed.
SpinTextureCache	Per-symbolId cache of “spin textures”. flat snapshots a reel shows instead of the live symbol (Spine skeleton, animated sprite, …) while it spins.
SpriteSymbol	Symbol implementation using a simple PixiJS Sprite. Swaps texture on activate. Win animation is a scale pulse via GSAP.
StandardMode	Standard top-to-bottom reel spinning. Symbols scroll downward at constant speed, wrapping around.
StartPhase	Accelerates the reel from rest to full spin speed.
StaticSpinSymbol	Wraps any `ReelSymbol` and swaps it for a cached snapshot texture while the reel spins. “spin static, not Spine.”
StopPhase	Stops the reel on the target frame.
SymbolRegistry	Registry that maps symbolIds to their constructors and options.
SymbolSpotlight	The “we just won” visual primitive.
TickerRef	Safe wrapper around PixiJS Ticker subscriptions.
WinPresenter	Highlights winning cells on a reel set. One job: animate the symbols.

Interfaces#

Interface	Description
AdjustPhaseConfig	-
AnimatedSpriteSymbolOptions	-
AnticipationOptions	Full anticipation configuration. The object form of `setAnticipation`’s second argument.
AnticipationPhaseConfig	-
AnticipationPhaseOptions	What a game hands `AnticipationPhase` through `f.register('anticipation', AnticipationPhase, options)`.
AnticipationSegment	One leg of an AnticipationCurve: reach a speed, optionally sit there.
AnticipationSlowdown	Progressive slow-down across the tease sequence. Values interpolate linearly across tease-order (first anticipation reel → last), so each successive reel decelerates deeper and/or holds longer than the one before it. This is what turns a flat “everyone drops to 30%” tease into an escalating “each reel crawls slower than the last” build-up.
BoardCell	A cell coordinate in the grid.
BoardCellMaskInfo	What a cell-mask factory is told about the cell it builds for.
BoardCellZIndexContext	What a BoardCellZIndexResolver is asked about.
BoardGridOptions	-
BoardSpinTarget	A landing target: spin `cell` and stop it showing `id`.
BounceContext	What a custom bounce animation receives. See BounceOptions.animation.
BounceOptions	Shape of one landing bounce, for ReelPhase.bounce. Every field falls back to the phase’s speed profile, so a phase that wants the profile’s own bounce passes nothing.
Cancellable	Something a step may hand back to be waited on and cancelled.
CardSymbolOptions	Debug / prototyping symbol - NOT for production.
CascadeDropInPhaseConfig	-
CascadeFallPhaseConfig	-
CascadePlacePhaseConfig	-
Cell	A cell coordinate on the reel set. `reel` is column, `cell` is visible cell.
CellBounds	Axis-aligned bounding box of a single grid cell in ReelSet-local coordinates. Returned by `reelSet.getCellBounds(reel, cell)`.
CellCoord	A grid coordinate.
CellPin	-
CellPinOptions	Options accepted by `reelSet.pin()`.
ColumnTarget	Per-reel target shape for `ReelSet.setResult` and `ReelSetBuilder.initialFrame`. One object per reel.
CycleOptions	-
DebugOverlayHandle	Handle returned by debugOverlay. Owns its display objects.
DebugOverlayOptions	-
DebugOverlayReelInfo	What the axis-family layers drew for one reel, as plain numbers.
DebugOverlaySnapshot	Serializable summary of the overlay. the text half of a visual debugger.
DebugReelSnapshot	-
DebugSnapshot	Debug snapshot. plain JSON representation of the entire reel state.
DestroySymbolsOptions	Options for ReelSet.destroySymbols. Every field is optional; the defaults produce the canonical “winners poof” look (no stagger, no viewport dim, zIndex bumped to 1000 so destroy effects render above neighbouring cells).
Disposable	Contract for objects that allocate resources and need cleanup. Every class that subscribes to tickers, creates display objects, or holds references must implement this to prevent memory leaks.
DrawableMaskStrategy	A MaskStrategy that can draw into a Graphics somebody else owns.
DropOffset	-
FrameAPI	The runtime-mutable frame-builder pipeline exposed on `reelSet.frame`. Matches `FrameBuilder.use/remove`. the internal machinery that already exists; this is the ergonomic surface.
FrameContext	Context passed through the middleware pipeline.
FrameMiddleware	Middleware that participates in frame building.
HoldAndWinBoardConfig	Internal config produced by HoldAndWinBuilder.build.
HwCell	Grid coordinate of a board cell.
HwCellSizeOptions	-
HwCoin	A coin somewhere on the board. `id` selects the registered symbol art; `data` is an opaque game-layer payload the board never interprets.
HwRespinResult	Resolution of one HoldAndWinBoard.respin wave.
InsetSides	Per-side inset for inset. SCREEN sides in every orientation, so `top` trims the top edge of the drawn mask on a horizontal set too. A side left out is `0`; negative grows that side.
MaskConfig	Mask configuration for the reel viewport.
MaskContext	Everything a mask strategy is given. Passed as one object so the axis cannot be forgotten, and so later additions do not break the signature.
MaskCorners	Which corners of a box a RoundedRectMaskStrategy may round. SCREEN corners in every orientation: `topLeft` is the top-left of the drawn rect on a horizontal set too. Only the keys set to `true` round; `{}` rounds nothing. Absent (`undefined`) means all four.
MaskStrategy	Strategy for building the viewport’s clip mask. Public. pass a custom implementation to `ReelSetBuilder.maskStrategy(...)` to clip the reels with any shape PixiJS Graphics can express (rounded frames, hex grids, etc.). Two ship with the engine:
MotionBlurOptions	Tuning for the baked motion-blur variant of a snapshot.
MovePinOptions	Options for `reelSet.movePin()`. flight animation tuning + lifecycle hooks.
MultiWaysConfig	MultiWays configuration knobs. Set via `builder.multiways({ ... })`. mutually exclusive with big-symbol registration.
NoOffsetConfig	No offset configuration.
Notice	One notice as onNotice hands it over.
NudgeOptions	Options for `Reel.nudge()` / `ReelSet.nudge()`. a post-stop reposition that shifts the reel by `distance` symbol positions and reveals new caller-supplied symbols.
PhaseCardSymbolOptions	-
PhaseStep	One step of a phase: a name to address it by, and what it does.
PhaseWatchedReel	The slice of a `Reel` that PhaseCardSymbol.watch reads. Every entry of `ReelSet.reels` satisfies it.
PinOverlayTween	Descriptor for one pin overlay’s animation across a MultiWays reshape.
Position	2D position.
PrewarmSpinTexturesOptions	-
RandomSymbolControl	Runtime control over the random symbol draw, reachable as `reelSet.randomSymbols`.
RecordedFrame	One captured frame from `startRecording()`. a `DebugSnapshot` plus the tag the recording was started with and the spin event that triggered the capture.
ReelAxis	Immutable projection between screen space and a reel’s travel/cross axes.
ReelBounce	A landing bounce in flight, returned by ReelPhase.bounce.
ReelCellInset	The part of its cell a symbol’s art actually covers, as fractions of the flat cell box in SCREEN space (`0,0` top-left to `1,1` bottom-right).
ReelCellQuad	One cell’s projected footprint on a curved reel: the four corners of the quad the symbol should render into, replacing its flat rectangle.
ReelConfig	-
ReelCurveConfig	Fake the curvature of a spinning reel cylinder.
ReelDriveConfig	Acceleration bounds for a reel under the `'drive'` motion model.
ReelDriveState	A drive’s live state. Owned by `Reel`; stepped once per tick.
ReelEvents	Events emitted by an individual Reel.
ReelExtraSymbols	Extra symbols above/below config per reel.
ReelGridConfig	Configuration for the reel grid layout.
ReelLandingContext	What a symbol is told about where it landed. Handed to `ReelSymbol.onReelLanded(ctx)` by the engine on every landing path, so a symbol can decide what its landing beat is on THIS reel and cell - or that it has none here - without the game reaching into the reel to find out.
ReelMaskRect	Bounding rectangle for one reel. what `MaskStrategy` builds the clip geometry from. SCREEN-space and viewport-local (origin = viewport top-left), in reel order.
ReelSetEvents	Events emitted by a ReelSet.
RefillOptions	Options for ReelSet.refill. The two required fields encode what just happened (`winners`) and what the next visible state should be (`grid`). Everything else is timing / cancellation / animation flavor with sensible defaults.
RefillResult	Summary returned by ReelSet.refill. Symmetric with RunCascadeResult. same vocabulary, narrower scope (one stage vs. the full chain).
ResolvedDriveConfig	Acceleration bounds with every default filled in. px/frame^2, px/frame^3.
ResolvedTumbleConfig	Resolved config with defaults applied. Internal type.
RoundedRectMaskOptions	-
RunCascadeOptions	Options for ReelSet.runCascade. The two required callbacks (`detectWinners`, `nextGrid`) encode game rules; everything else is timing / cancellation / forwarded-to-destroy plumbing with sensible defaults.
RunningStep	A step in flight, from runStep.
ScatterAnticipationOptions	-
SilhouetteMaskOptions	-
SkipContext	What a phase receives in `onSkip(ctx)`: the mode of the press that reached it, the profile it should finish on (a `'quicken'` that named one), and whatever the game attached. See SkipOptions. The same press rides on `skip:requested` / `skip:completed` (as `SkipInfo`, with the reels) and ends up in `SpinResult.skipContext`.
SkipInfo	What `skip:requested` and `skip:completed` carry: the press as every phase saw it in `onSkip(ctx)` (`mode`, the `speed` profile a quicken named, the game’s `payload`), plus the reels it freed and whether reels are still spinning after it. An engine slam (an abort, a timeout, error recovery, `slamStop()`) has no press behind it: `mode: 'slam'`, no `speed`, no `payload`. Keys the press did not set are absent, not `undefined`.
SkipOptions	Options for `requestSkip()` / `skipSpin()`, and for `board.skip()`.
SlamOptions	Which reels a `slamStop()` call lands. Omit the argument entirely to land every un-landed reel (the default hard slam).
SnapshotRenderer	The slice of a PixiJS renderer the cache needs. `Renderer` (WebGL or WebGPU) satisfies it structurally; tests can pass a stub.
SpeedProfile	Timing and animation profile for a speed mode.
SpineSymbolOptions	-
SpinningMode	Strategy interface for different reel spinning behaviors.
SpinOptions	Options accepted by `reelSet.spin(options?)`. All fields are optional. passing nothing reproduces the legacy “every reel spins” behaviour.
SpinPhaseConfig	-
SpinResult	Result returned when a spin completes.
SpinTextureCacheOptions	-
SpotlightOptions	-
SpriteSymbolOptions	-
StartPhaseConfig	-
StartPhaseOptions	What a game hands `StartPhase` through `f.register('start', StartPhase, options)`.
StartRecordingOptions	Options for startRecording.
StaticSpinSymbolOptions	-
StepContext	What every step of a phase receives. The reel and the numbers a step needs, plus two ways to wait that a slam can cut: `wait` for time, `until` for a condition the reel reaches on some frame.
StopPhaseConfig	-
StopPhaseOptions	What a game hands `StopPhase` through `f.register('stop', StopPhase, options)`.
SwapSymbolsOptions	Options for ReelSet.swapSymbols. Every field is optional; the defaults play every cell out together, swap, and play every cell in together.
SymbolData	Per-symbol configuration data.
SymbolPool	What the engine is allowed to draw when it needs a random symbol.
SymbolPoolScope	Which draws a pool applies to.
SymbolPosition	A cell on the visible grid. `reelIndex` is the column; `cellIndex` is the cell from the top.
SymbolSwap	One cell to re-skin. See ReelSet.swapSymbols.
SymbolZIndexContext	Everything a SymbolZIndexResolver is asked about. Built by the reel once per symbol per z-index refresh.
TrapezoidConfig	Trapezoid perspective configuration.
TumbleConfig	-
TumbleDropInConfig	-
TumbleFallConfig	-
Win	One “win” as the presenter sees it: an ordered set of cells to highlight.
WinLine	-
WinPresenterOptions	-

Type Aliases#

Type Alias	Description
AnticipationCells	How far a tease runs, in symbol pitches.
AnticipationCurve	The shape of a tease, as a list of speed legs played in order.
AnticipationProtect	How a tease resists a skip press. Skip granularity is otherwise all-or-nothing: a slam force-completes every phase including `AnticipationPhase`, so a player who presses skip never sees that the spin was teasing at all.
AnticipationStagger	How the START of each anticipation reel’s slow-down is spaced (offsets are by tease-order, i.e. position within the anticipation set, not raw reel index): - `0` (default) — every anticipation reel begins slowing together. - `number` — reel at tease-order `k` starts `k * value` ms after the first. - `number[]` — explicit per-tease-order offset in ms. - `'sequential'` — each reel waits until the previous anticipation reel has fully landed before it starts.
AnticipationStepContext	-
BoardCellZIndexResolver	Orders the cells’ lifted art. See the `cellZIndex` option of BoardGridOptions.
BoardProfile	A speed profile, or a per-cell function of one (e.g. a stagger wave).
CrossOffsetMode	Offset modes for X-axis symbol positioning.
CurveFocus	Where the camera sits across the strip.
CurveMode	How the curve is drawn.
DebugOverlayLayer	A single visual debug layer.
Direction	Which way along the travel axis symbols move. `'forward'` heads toward the larger coordinate (down / right), `'reverse'` toward the smaller (up / left). Per-reel, overridable per spin.
Gsap	The gsap namespace type, as the engine passes it around.
HoldAndWinBoardEvents	-
HwEffect	One state-change the reducer (HoldAndWinState) decided, ready for the driver to emit. A tagged pair of `{ type, payload }` for every board event the reducer owns - the driver replays them onto its emitter and keys visual side effects (e.g. `playWin()` on `coin:locked`) off the type. `respin:start` and `feature:skip` are driver-owned (they describe in-flight reels, not ledger state) and are not produced here.
HwLockAnimation	What the board plays on a coin’s symbol the moment it locks.
HwLockAnimationRule	A lock animation for every coin, or a function of the coin that just locked - so a collector can celebrate while a plain coin only settles, or a seed from `enter()` stays quiet. See `HoldAndWinBuilder.lockAnimation`.
HwPhase	-
HwRespinReason	Why the respin counter changed - disambiguates a `respins:changed` event.
LogLevel	How much the library is allowed to say. Each level includes the ones before it.
MaskPathFn	Draws a mask however you like. See PathMaskStrategy.
Matrix	2D matrix type (reel × cell).
OffsetConfig	-
Orientation	Which screen axis a reel’s strip travels along. `'vertical'` runs the strip on Y with reels marched along X; `'horizontal'` runs the strip on X with reels marched along Y. ReelSet-level: one shared orientation per set.
PhaseConstructor	-
PhaseCreatorFn	-
PhaseStepStatus	Where a step of a phase on `runSteps()` is, as `reel.events` reports it in `phase:step`.
PinExpireReason	Reason a pin expired. Fired with `pin:expired`. - `'turns'` - its turn counter reached zero. - `'explicit'` - removed via `unpin()`. - `'eval'` - an eval callback returned false. - `'collision'` - a reshape clamped it onto a cell another pin already holds, so it was dropped deterministically.
PinMigration	How a pin behaves when a MultiWays reshape changes the cell count of its reel. Non-MultiWays slots never reshape, so this value is irrelevant there.
ReelAnchor	How to vertically align reels of differing pixel heights.
ReelCurveInput	`curve(0.35)` and `curve({ amount: 0.35 })` mean the same thing.
RoundedMaskScope	Which corners of a reel box a RoundedRectMaskStrategy rounds.
RunCascadeResult	Summary returned by ReelSet.runCascade. Re-exported from the canonical definition in `events/ReelEvents.ts` so the events module stays the single source of truth for shared shapes.
SkipMode	What a skip press does to the reels it frees.
Stacking	Render order along an axis.
StartStepContext	-
StepResult	What a step returns: a gsap tween or timeline (killed on cancel), a promise (told to stop through `ctx.signal`), a Cancellable such as the object `phase.bounce()` returns, or nothing for a step that is instant.
StepsEditor	The list a phase runs, after the game’s edit. Passed the built-in list, returns the list to run.
StopStepContext	-
SymbolPoolSlots	Which slots a pool applies to.
SymbolZIndexResolver	Replaces the engine’s z-index formula for symbol views. See `ReelSetBuilder.symbolZIndex`. Must be pure and cheap: it is called once per symbol per refresh, and a refresh follows every wrap, snap, swap and rest transition.
TickerCallback	-
WinSymbolAnim	What to play on each cell being highlighted.

Variables#

Variable	Description
CARD_DECK	Standard high-card deck for prototyping. Each card has its own color so a full grid is visually unambiguous at a glance.
CURVE_FOCUS_WEIGHT	How far each focus mode leans from the reel’s centreline toward the set’s.
DEFAULT_DIM_AMOUNT	Default strength for BoardGrid.dim and BoardGrid.dimSymbols. Half way: dark enough to read as background, light enough that the art is still legible behind whatever is in front of it.
DEFAULT_DIM_FADE_MS	How long BoardGrid.dim takes to fade in, and to fade back out. Short enough to read as part of the beat it belongs to rather than as a transition of its own; `fade: 0` cuts instantly.
DEFAULTS	Default values applied when not explicitly set by the builder.
DRIVE_FRAME_MS	Nominal frame length in ms. `Reel.speed` is pixels per FRAME, not per millisecond, so a drive expressed in px/frame^2 has to know what a frame is worth in order to integrate against a real `deltaMs`. 60fps, matching the unit the speed profiles are already written in.
MASK_STRATEGY_VERSION	Version marker every strategy must carry. A v1 strategy has positional `(rects, totalWidth, totalHeight)` parameters and no axis; handed a MaskContext it would read `rects` as an object, find no `.length`, and quietly fall through to a full-bleed rect - clipping nothing, with no error. The marker turns that into a named throw at `maskStrategy()`.
OVERLAY_LABEL	Container / layer label prefix. Used by the Pixi devtools and by tests.
PHASE_CARD_COLORS	Fill per phase for PhaseCardSymbol. Keys are the names phases register under (`'start'`, `'spin'`, `'anticipation'`, `'stop'`, the cascade and MultiWays keys, and any custom key), plus `rest` (at rest, the default) and `landed` (the beat between landing and rest). A phase with no entry draws `other`.
SpeedPresets	Built-in speed profiles covering common slot game needs.
VERTICAL_FORWARD	The v1 default: a vertical strip travelling downward.
WILD_CARD	A pale-yellow `WILD` card for sticky/expanding-wild prototypes.
Z_INDEX_BUDGET	The z-index values the engine reserves, so a SymbolZIndexResolver can be bounds-checked against the library instead of a copied literal.

Functions#

Function	Description
anticipationForScatters	Decide which reels should show anticipation, straight from a result grid.
canProjectTexture	Whether a texture can go through the perspective mesh.
cellKey	`reel,cell` string key for the board’s cell-indexed maps.
clearFrames	Empty the global recording log.
cloneColumnTarget	Deep-clone a `ColumnTarget` one level down, so slots can be rewritten safely.
columnTargetToStrip	Materialize a `ColumnTarget` into strip form: one entry per strip slot, top to bottom. Index `0` is the furthest buffer-above cell, index `bufferStart` is the first visible cell, and the tail holds buffer-below cells. This is the same indexing `FrameBuilder.build` returns and `Reel.placeStrip` consumes.
composeMasks	Union several strategies into one mask.
computeDropOffsets	Compute per-cell drop offsets for one reel given its winner set.
debugGrid	Pretty-print the grid as an ASCII table.
debugOverlay	A layered visual debug overlay for a ReelSet. Draws mask, cell, buffer, symbol-bounds, big-symbol-block, pin and hud layers into a `Container` added to the reel set itself. because `ReelSet extends Container`, that renders the overlay above the viewport (including the spotlight container), unlike the older `showMask` which drew inside the viewport and was covered by the spotlight.
debugSnapshot	Take a plain-JSON snapshot of the entire reel set state.
driveGsapWithTicker	Drive GSAP from a PixiJS ticker instead of its own requestAnimationFrame loop, and return a disposer that restores GSAP’s default loop.
enableDebug	Enable debug mode: attaches debug utilities to `window.__PIXI_REELS_DEBUG`.
getFrames	All recorded frames in capture order. When `tag` is provided, only frames tagged with it are returned. Frames are not cleared between recording sessions. call clearFrames to reset.
getLogLevel	The active LogLevel.
getTargetSlot	Read one slot of a `ColumnTarget` by cell, the engine’s visible-relative coordinate: `0` is the first visible cell, negative cells address `bufferStart` (`-1` is the slot closest to the visible top cell), and cells `>= visible.length` address `bufferEnd`.
insertAfter	A copy of `steps` with `added` placed after the step called `name`. Throws on an unknown name.
insertBefore	A copy of `steps` with `added` placed before the step called `name`. Throws on an unknown name.
inset	Shrink (or grow) any strategy’s mask by a number of pixels - one number for all four sides, or `{ top, right, bottom, left }` for a different trim per screen side.
isDrawableMaskStrategy	True when `s` can draw into a foreign Graphics.
onNotice	Hear every notice the engine raises, whatever the log level: for an events panel, a test, a telemetry hook. The console keeps its own volume knob (`setLogLevel`). Returns the function that unsubscribes.
pinKey	Map key used internally and exposed by `reelSet.pins`.
prewarmSpinTextures	Bake spin textures for every symbolId up front (at load or between rounds) so the first spin never pays a capture hitch. Ids that already have a user-provided or captured texture are skipped by the cache.
reelAxis	Build a `ReelAxis` for the given orientation and travel direction.
removeStep	A copy of `steps` without the step called `name`. Throws on an unknown name.
replaceStep	A copy of `steps` with the step called `name` swapped for `replacement`. Throws on an unknown name.
resolveCurveConfig	Normalize the shorthand and fill in the derived, fold-safe default.
resolveDriveConfig	Turn a drive config into concrete bounds.
resolveTumbleConfig	-
runStep	Run one step with the cancel semantics the built-in phases use: a returned animation is killed on cancel, a cancellable is cancelled, a promise is aborted through `ctx.signal`, and `done` settles either way. Public so a custom phase can run a step of its own the same way. Pass `controller` when `ctx.wait` / `ctx.until` must abort on the same signal.
setLogLevel	Set how much the library prints. Default `'info'`, which is everything. `'warn'` drops the advisory notices (mask auto-picks and the like) and keeps problems; `'silent'` turns the channel off entirely - reasonable for a production build, as long as you have read the warnings once.
setTargetSlot	Write one slot of a `ColumnTarget` by cell, using the same coordinate as getTargetSlot. Creates and extends `bufferStart` / `bufferEnd` as needed, so a caller can address any cell on the strip without knowing whether the target declared a buffer.
sortByValueDesc	Return a new array sorted by `value` descending (non-mutating). Missing values sort as 0.
startRecording	Start recording the reel-set’s frame state at every key spin event (`spin:start`, `spin:reelLanded`, `spin:allLanded`, `spin:complete`). Each event captures a `DebugSnapshot` and pushes it onto a process- wide rolling log readable via getFrames.
step	Build a PhaseStep.
stepDrive	Advance one drive tick: move `state.speed` toward `target` without exceeding the configured acceleration (and, if set, jerk) bounds.
stopRecording	Detach the recorder previously installed by startRecording. No-op if none.
textureCellInset	The slice of its cell a texture’s opaque art really occupies.
whenSpineReady	Resolves once the optional `@esotericsoftware/spine-pixi-v8` import has settled (whether or not it was installed). Await this before constructing `SpineSymbol`s if you build the reel set immediately on app start, so a cold load can’t throw the misleading “not installed” error.