@duyquangnvx/spindle 1.0.0-beta.1

package/README.md

@@ -0,0 +1,211 @@
+# Spindle
+
+Headless TypeScript slot game framework. Zero runtime dependencies.
+
+Spindle orchestrates the entire spin lifecycle of a slot game — reels, wilds, wins, cascades, features — without knowing anything about your rendering layer. You implement async delegate methods; Spindle calls them in the right order and waits for your animations to finish.
+
+## Install
+
+```sh
+npm install @jagaming/spindle
+```
+
+Subpath exports:
+
+```ts
+import { createSpindle } from "@jagaming/spindle";           // core engine
+import { createSlotRenderer } from "@jagaming/spindle/renderer"; // abstract renderer
+import { recording } from "@jagaming/spindle/testing";          // test utilities
+```
+
+## Quick Start
+
+```ts
+import { createSpindle, createSymbolId } from "@jagaming/spindle";
+import type { SpindleDelegate } from "@jagaming/spindle";
+
+// Config is minimal — just grid dimensions
+const config = { reels: 5, rows: 3 };
+
+// Implement only the delegate methods your game needs.
+// Core + Data are required; everything else is optional.
+// If a method is present, the feature is enabled.
+const delegate: SpindleDelegate = {
+  // Core (always required)
+  async onSpinStart() { /* dim UI, disable buttons */ },
+  async presentReelStop({ reelIndex, symbols }) { /* animate reel stopping */ },
+  async onSpinEnd({ totalWin }) { /* show total, re-enable buttons */ },
+
+  // Data (always required)
+  async requestSpinResult(context) {
+    const res = await fetch("/api/spin", { method: "POST" });
+    return res.json(); // must match SpinResult shape
+  },
+
+  // Ways wins — present because your game uses ways evaluation
+  async presentWaysWin(win) { /* highlight winning positions */ },
+
+  // Expanding wilds — present because your game has expanding wilds
+  async presentExpandingWild({ position, expandedPositions }) { /* animate */ },
+
+  // Scatter — present because your game has scatter wins
+  async presentScatterWin(win) { /* scatter animation */ },
+
+  // Free spins — present because your game has free spins
+  async onFreeSpinsEnter({ totalSpins }) { /* transition to free spins mode */ },
+  async onFreeSpinStart({ currentSpin, totalSpins }) { /* update counter */ },
+  async onFreeSpinsRetrigger({ added, totalSpins }) { /* retrigger animation */ },
+  async onFreeSpinsExit({ totalWin }) { /* show summary, transition back */ },
+};
+
+const spindle = await createSpindle(config, delegate);
+await spindle.spin();
+```
+
+## How It Works
+
+Spindle is a **presentation orchestrator**. Your game server computes the spin result; Spindle drives the visual flow:
+
+```
+spindle.spin()
+  |
+  +-- onSpinStart()
+  +-- requestSpinResult()          <- you call your server here
+  +-- presentAnticipation()        <- if data + delegate present
+  +-- presentReelStop() x N        <- left to right
+  +-- presentSymbolTransform()     <- if data + delegate present
+  +-- presentExpandingWild()       <- wild animations (per type)
+  +-- presentWaysWin() x N         <- each winning combo
+  +-- presentCascadeDestroy/Drop/Fill loop
+  +-- presentScatterWin()          <- after cascade
+  +-- presentBigWin()              <- if data + delegate present
+  +-- presentJackpotTrigger()      <- if data + delegate present
+  +-- [feature runner]             <- free spins / hold-and-spin / etc.
+  +-- onSpinEnd({ spinWin, featureWin, totalWin })
+  +-- [gamble loop]                <- if delegate present and win > 0
+```
+
+Every delegate method returns `Promise<void>`. Spindle `await`s each one, so you control animation timing completely.
+
+## Data-Driven Architecture
+
+Spindle uses a **data-driven** approach: `SpinResult` is the single runtime source of truth, and **delegate method presence** drives behavior. There is no config-driven type inference — you simply implement the methods your game needs.
+
+| Data in SpinResult | Delegate method needed | What happens |
+|---|---|---|
+| `wins` with `type: "ways"` | `presentWaysWin` | Ways win animation |
+| `wildEvents` with `type: "expanding"` | `presentExpandingWild` | Expanding wild animation |
+| `cascadeSteps` | `presentCascadeDestroy` | Cascade sequence |
+| `scatterWin` | `presentScatterWin` | Scatter animation |
+| `bigWinTier` | `presentBigWin` | Big win celebration |
+| `jackpotWin` | `presentJackpotTrigger` | Jackpot celebration |
+| `featureTrigger` with `type: "freeSpins"` | `onFreeSpinsEnter` | Free spins loop |
+| `gambleAvailable !== false` | `onGambleStart` | Gamble loop |
+
+If data is present but the delegate method is missing, the feature is **silently skipped**. This means:
+- No config arrays to maintain in sync with your server
+- Adding a feature = implement the delegate method + have your server send the data
+- Removing a feature = remove the delegate method
+
+## Game Mechanics
+
+### Win Types
+
+- **Ways** — 243/1024+ ways to win (symbol matching across adjacent reels)
+- **Payline** — Classic fixed payline patterns
+- **Cluster** — Groups of adjacent matching symbols
+
+### Wild Types
+
+`regular` | `expanding` | `sticky` | `walking` | `stacked` | `multiplier` | `random`
+
+### Capabilities
+
+| Capability | Description |
+|---|---|
+| Cascade | Tumbling reels — destroy wins, drop new symbols, re-evaluate |
+| Scatter | Scatter symbol wins (independent of paylines/ways) |
+| Big Win | Celebration tiers (big, mega, super mega, etc.) |
+| Anticipation | Suspense animation before specific reel stops |
+| Symbol Transform | Mystery symbols that reveal after landing |
+| Jackpot | Progressive jackpot trigger and award |
+
+### Features
+
+| Feature | Description |
+|---|---|
+| Free Spins | Bonus spin loop with retrigger support |
+| Hold and Spin | Lock symbols, respin remaining positions |
+| Pick Bonus | Interactive pick-and-reveal mini-game |
+| Wheel Bonus | Spinning wheel with nested inner wheels |
+
+### Modifiers
+
+| Modifier | Description |
+|---|---|
+| Gamble | Post-spin double-or-nothing loop |
+| Buy Feature | Purchase direct entry into any feature |
+
+## API
+
+### `createSpindle(config, delegate): Promise<Spindle>`
+
+Factory function. Config only requires `{ reels, rows }`. Validates at construction time (fail-fast).
+
+### `spindle.spin(): Promise<SpinFlowResult>`
+
+Runs a full spin cycle. Returns `{ totalWin: number }`.
+
+### `spindle.buyFeature(featureType): Promise<SpinFlowResult>`
+
+Buys direct entry into a feature. Requires `requestBuyFeatureResult` delegate method.
+
+### `spindle.isSpinning: boolean`
+
+Concurrent spin protection. `spin()` and `buyFeature()` share the same mutex.
+
+## Delegate Conventions
+
+| Prefix | Direction | Purpose |
+|---|---|---|
+| `request` | Spindle <- Consumer | Pull data (server calls, player choices) |
+| `on` | Spindle -> Consumer | Lifecycle notification (update UI state) |
+| `present` | Spindle -> Consumer | Animate/display something |
+
+## SpinResult
+
+The `SpinResult` type is the server contract — everything Spindle needs to drive the presentation:
+
+```ts
+interface SpinResult {
+  grid: SymbolGrid;            // reel x row symbol array
+  wins: WinResult[];           // line/ways/cluster wins
+  spinWin: number;             // total win for this spin
+  scatterWin?: ScatterWin;
+  featureTrigger?: FeatureTrigger;
+  wildEvents?: WildEvent[];
+  symbolTransforms?: SymbolTransform[];
+  cascadeSteps?: CascadeStep[];
+  bigWinTier?: string;
+  anticipationReels?: number[];
+  jackpotWin?: JackpotWin;
+  newLockedSymbols?: LockedSymbol[];
+  gambleAvailable?: boolean;   // opt out of gamble for this spin
+  metadata?: unknown;          // consumer-defined passthrough data
+}
+```
+
+Spindle does **not** call your server. You call it in `requestSpinResult()` and return data in this shape.
+
+## Development
+
+```sh
+npm test            # Run all 203 tests
+npm run lint        # Biome lint + format check
+npm run build       # ESM + CJS dual output via tsdown
+npm run typecheck   # tsc --noEmit
+```
+
+## License
+
+UNLICENSED

package/dist/delegates-DOwv3sAL.d.cts

@@ -0,0 +1,463 @@
+//#region src/types.d.ts
+/**
+ * Core type contracts for Spindle.
+ *
+ * These are the PUBLIC types consumers interact with.
+ */
+/** Opaque string identifier for a symbol on the reels. */
+type SymbolId = string & {
+  readonly __brand: unique symbol;
+};
+/** Create a SymbolId from a raw string. */
+declare function createSymbolId(value: string): SymbolId;
+/** A specific cell on the reel grid. */
+interface GridPosition {
+  readonly reel: number;
+  readonly row: number;
+}
+/**
+ * Complete grid state — symbols per reel.
+ * Jagged array to support variable row counts (e.g., Megaways).
+ * Outer = reel index, inner = row symbols.
+ */
+type SymbolGrid = SymbolId[][];
+/** Discriminator for win evaluation method. */
+type WinType = "ways" | "payline" | "cluster";
+type WildType = "regular" | "expanding" | "sticky" | "walking" | "stacked" | "multiplier" | "random";
+type CapabilityType = "cascade" | "scatter" | "bigWin" | "anticipation" | "symbolTransform" | "jackpot";
+type FeatureType = "freeSpins" | "holdAndSpin" | "pickBonus" | "wheelBonus";
+interface GameConfig {
+  readonly reels: number;
+  readonly rows: number;
+}
+type SpinRequestContext = {
+  readonly mode: "base";
+} | {
+  readonly mode: "freeSpin";
+  readonly currentSpin: number;
+  readonly totalSpins: number;
+} | {
+  readonly mode: "holdAndSpin";
+  readonly round: number;
+  readonly lockedSymbols: LockedSymbol[];
+};
+/** Current game mode during a spin. */
+type SpinMode = "base" | "freeSpin" | "holdAndSpin";
+/** Context injected into all spin-pipeline presentation delegates. */
+interface PresentationContext {
+  readonly mode: SpinMode;
+  readonly metadata?: unknown;
+}
+/** Base fields shared by all winning combinations. */
+interface WinBase {
+  readonly symbol: SymbolId;
+  readonly positions: GridPosition[];
+  readonly amount: number;
+  readonly multiplier?: number;
+}
+interface WaysWin extends WinBase {
+  readonly type: "ways";
+  readonly count: number;
+}
+interface PaylineWin extends WinBase {
+  readonly type: "payline";
+  readonly paylineIndex: number;
+  readonly matchCount: number;
+}
+interface ClusterWin extends WinBase {
+  readonly type: "cluster";
+  readonly size: number;
+}
+type WinResult = WaysWin | PaylineWin | ClusterWin;
+interface ScatterWin {
+  readonly symbol: SymbolId;
+  readonly count: number;
+  readonly amount: number;
+  readonly positions: GridPosition[];
+}
+interface FreeSpinsParams {
+  readonly totalSpins: number;
+}
+interface HoldAndSpinParams {
+  readonly totalRounds: number;
+  readonly lockedSymbols: LockedSymbol[];
+}
+interface LockedSymbol {
+  readonly position: GridPosition;
+  readonly symbol: SymbolId;
+  readonly value?: number;
+}
+interface PickBonusParams {
+  readonly itemCount: number;
+}
+interface PickChoice {
+  readonly choiceIndex: number;
+}
+interface PickReveal {
+  readonly choiceIndex: number;
+  readonly prize: number;
+  readonly done: boolean;
+}
+interface WheelSegment {
+  readonly prize: number;
+  readonly innerWheel?: WheelBonusParams;
+}
+interface WheelBonusParams {
+  readonly segments: readonly WheelSegment[];
+}
+interface WheelSpinResult {
+  readonly segmentIndex: number;
+  readonly prize: number;
+  readonly innerWheel?: WheelBonusParams;
+}
+type FeatureTrigger = {
+  readonly type: "freeSpins";
+  readonly params: FreeSpinsParams;
+} | {
+  readonly type: "holdAndSpin";
+  readonly params: HoldAndSpinParams;
+} | {
+  readonly type: "pickBonus";
+  readonly params: PickBonusParams;
+} | {
+  readonly type: "wheelBonus";
+  readonly params: WheelBonusParams;
+};
+interface RegularWildEvent {
+  readonly type: "regular";
+  readonly position: GridPosition;
+}
+interface ExpandingWildEvent {
+  readonly type: "expanding";
+  readonly position: GridPosition;
+  readonly expandedPositions: GridPosition[];
+}
+interface StickyWildEvent {
+  readonly type: "sticky";
+  readonly position: GridPosition;
+}
+interface WalkingWildEvent {
+  readonly type: "walking";
+  readonly from: GridPosition;
+  readonly to: GridPosition;
+}
+interface StackedWildEvent {
+  readonly type: "stacked";
+  readonly positions: GridPosition[];
+}
+interface MultiplierWildEvent {
+  readonly type: "multiplier";
+  readonly position: GridPosition;
+  readonly multiplier: number;
+}
+interface RandomWildEvent {
+  readonly type: "random";
+  readonly positions: GridPosition[];
+}
+type WildEvent = RegularWildEvent | ExpandingWildEvent | StickyWildEvent | WalkingWildEvent | StackedWildEvent | MultiplierWildEvent | RandomWildEvent;
+interface HoldAndSpinRoundResult {
+  readonly grid: SymbolGrid;
+  readonly newLockedSymbols: LockedSymbol[];
+  readonly roundWin: number;
+}
+/** Player's decision during a gamble round. */
+interface GambleChoice {
+  readonly action: "gamble" | "collect";
+}
+/** Server-provided outcome of a gamble round. */
+interface GambleResult {
+  readonly won: boolean;
+  readonly amount: number;
+}
+/** Jackpot win outcome determined by server. */
+interface JackpotWin {
+  readonly tier: string;
+  readonly amount: number;
+}
+/** A single symbol transformation on the grid, provided by the server. */
+interface SymbolTransform {
+  readonly position: GridPosition;
+  readonly from: SymbolId;
+  readonly to: SymbolId;
+}
+/** Server response for a spin — canonical SDK type. */
+interface SpinResult {
+  readonly grid: SymbolGrid;
+  readonly wins: WinResult[];
+  /**
+   * Win amount from this spin's evaluations only.
+   * Includes: line/ways/cluster wins, scatter win, cascade step wins.
+   * Excludes: jackpot wins (reported separately via {@link jackpotWin}).
+   * For feature spins, this is the win for THIS spin only, not cumulative.
+   */
+  readonly spinWin: number;
+  readonly scatterWin?: ScatterWin;
+  readonly featureTrigger?: FeatureTrigger;
+  readonly wildEvents?: WildEvent[];
+  /** Symbols that locked this round — present in holdAndSpin mode responses. */
+  readonly newLockedSymbols?: LockedSymbol[];
+  /** Server-provided big win tier string (e.g., "big", "mega", "super_mega"). */
+  readonly bigWinTier?: string;
+  /** Reel indices (0-based) that should receive anticipation before stopping. */
+  readonly anticipationReels?: number[];
+  /** Symbol transforms to present after reel stops, before wild events. */
+  readonly symbolTransforms?: SymbolTransform[];
+  /** Cascade sequence — present when capabilities includes "cascade". */
+  readonly cascadeSteps?: CascadeStep[];
+  /** Jackpot win — present when a jackpot triggers on this spin. */
+  readonly jackpotWin?: JackpotWin;
+  /** Whether gamble is available for this spin (default: true when gamble delegate is present). */
+  readonly gambleAvailable?: boolean;
+  /** Consumer-defined opaque data. Passed through to all presentation delegates unchanged. */
+  readonly metadata?: unknown;
+}
+/** A single step in a cascade sequence, provided by the server. */
+interface CascadeStep {
+  /** Positions of symbols to destroy (winning symbols from previous evaluation). */
+  readonly destroyPositions: GridPosition[];
+  /** Grid state after symbols drop and new symbols fill. */
+  readonly grid: SymbolGrid;
+  /** Wins evaluated on the new grid (empty array if no wins -> cascade ends). */
+  readonly wins: WinResult[];
+  /** Optional multiplier for this cascade step (progressive multiplier from server). */
+  readonly multiplier?: number;
+}
+/**
+ * Summary returned from spindle.spin() after full flow completes.
+ *
+ * {@link totalWin} reflects spin-related wins only (base + features),
+ * optionally modified by gamble. Jackpot wins are excluded — consumers
+ * track those via {@link JackpotDelegate.onJackpotAwarded} callbacks.
+ */
+interface SpinFlowResult {
+  readonly totalWin: number;
+}
+//#endregion
+//#region src/delegates.d.ts
+/**
+ * Single delegate interface for Spindle.
+ * Core + Data methods are required; all others are optional.
+ * Method presence drives behavior — if a method exists, the feature is enabled.
+ */
+type SpindleDelegate = CoreDelegate & DataDelegate & Partial<WaysWinDelegate & PaylineWinDelegate & ClusterWinDelegate & ScatterWinDelegate & CascadeDelegate & BigWinDelegate & AnticipationDelegate & SymbolTransformDelegate & JackpotDelegate & GambleDelegate & BuyFeatureDelegate & PickBonusDelegate & WheelBonusDelegate & FreeSpinsDelegate & HoldAndSpinDelegate & ExpandingWildDelegate & StickyWildDelegate & WalkingWildDelegate & StackedWildDelegate & MultiplierWildDelegate & RandomWildDelegate>;
+/** Consumer implements this to provide spin results to Spindle. */
+interface DataDelegate {
+  requestSpinResult(context: SpinRequestContext): Promise<SpinResult>;
+}
+/** Every game MUST implement these lifecycle and presentation callbacks. */
+interface CoreDelegate {
+  onSpinStart(): Promise<void>;
+  presentReelStop(data: {
+    reelIndex: number;
+    symbols: SymbolId[];
+  } & PresentationContext): Promise<void>;
+  onSpinEnd(data: {
+    spinWin: number;
+    featureWin: number;
+    totalWin: number;
+  }): Promise<void>;
+}
+/** Present when game uses ways win evaluation. */
+interface WaysWinDelegate {
+  presentWaysWin(data: WaysWin & PresentationContext): Promise<void>;
+}
+/** Present when game uses payline win evaluation. */
+interface PaylineWinDelegate {
+  presentPaylineWin(data: PaylineWin & PresentationContext): Promise<void>;
+}
+/** Present when game uses cluster win evaluation. */
+interface ClusterWinDelegate {
+  presentClusterWin(data: ClusterWin & PresentationContext): Promise<void>;
+}
+/** Present when game has scatter wins. */
+interface ScatterWinDelegate {
+  presentScatterWin(data: ScatterWin & PresentationContext): Promise<void>;
+}
+/** Present when game has cascade/tumble mechanics. */
+interface CascadeDelegate {
+  presentCascadeDestroy(data: {
+    step: number;
+    positions: GridPosition[];
+  } & PresentationContext): Promise<void>;
+  presentCascadeDrop(data: {
+    step: number;
+  } & PresentationContext): Promise<void>;
+  presentCascadeFill(data: {
+    step: number;
+    grid: SymbolGrid;
+    multiplier?: number;
+  } & PresentationContext): Promise<void>;
+}
+/** Present when game has free spins feature. */
+interface FreeSpinsDelegate {
+  onFreeSpinsEnter(data: {
+    totalSpins: number;
+  }): Promise<void>;
+  onFreeSpinStart(data: {
+    currentSpin: number;
+    totalSpins: number;
+    remaining: number;
+    accumulated: number;
+  }): Promise<void>;
+  onFreeSpinsRetrigger(data: {
+    added: number;
+    totalSpins: number;
+  }): Promise<void>;
+  onFreeSpinsExit(data: {
+    totalSpins: number;
+    totalWin: number;
+  }): Promise<void>;
+}
+/** Present when game has hold-and-spin feature. */
+interface HoldAndSpinDelegate {
+  onHoldAndSpinEnter(data: {
+    totalRounds: number;
+    lockedSymbols: LockedSymbol[];
+  }): Promise<void>;
+  onHoldAndSpinRound(data: {
+    round: number;
+    remaining: number;
+    grid: SymbolGrid;
+    newLocked: LockedSymbol[];
+    allLocked: LockedSymbol[];
+  }): Promise<void>;
+  onHoldAndSpinExit(data: {
+    totalRounds: number;
+    totalWin: number;
+    fullGrid: boolean;
+  }): Promise<void>;
+}
+/** Present when game has big win celebrations. */
+interface BigWinDelegate {
+  presentBigWin(data: {
+    tier: string;
+    amount: number;
+  } & PresentationContext): Promise<void>;
+}
+/** Present when game has reel anticipation. */
+interface AnticipationDelegate {
+  presentAnticipation(data: {
+    reelIndex: number;
+  } & PresentationContext): Promise<void>;
+}
+/** Present when game has symbol transforms. */
+interface SymbolTransformDelegate {
+  presentSymbolTransform(data: {
+    transforms: SymbolTransform[];
+  } & PresentationContext): Promise<void>;
+}
+/** Present when game has jackpot feature. */
+interface JackpotDelegate {
+  presentJackpotTrigger(data: {
+    tier: string;
+    amount: number;
+  } & PresentationContext): Promise<void>;
+  onJackpotAwarded(data: {
+    tier: string;
+    amount: number;
+  } & PresentationContext): Promise<void>;
+}
+/** Present when game has pick bonus feature. */
+interface PickBonusDelegate {
+  onPickBonusEnter(data: {
+    itemCount: number;
+  }): Promise<void>;
+  requestPickChoice(data: {
+    round: number;
+    accumulated: number;
+  }): Promise<PickChoice>;
+  requestPickReveal(data: {
+    choiceIndex: number;
+  }): Promise<PickReveal>;
+  presentPickReveal(data: {
+    choiceIndex: number;
+    prize: number;
+    done: boolean;
+  }): Promise<void>;
+  onPickBonusExit(data: {
+    totalWin: number;
+  }): Promise<void>;
+}
+/** Present when game has wheel bonus feature. */
+interface WheelBonusDelegate {
+  onWheelBonusEnter(data: {
+    segments: readonly WheelSegment[];
+  }): Promise<void>;
+  requestWheelSpinResult(data: {
+    segments: readonly WheelSegment[];
+  }): Promise<WheelSpinResult>;
+  presentWheelResult(data: {
+    segmentIndex: number;
+    prize: number;
+  }): Promise<void>;
+  onWheelBonusExit(data: {
+    totalWin: number;
+  }): Promise<void>;
+}
+/** Present when game has gamble (double-up) feature. */
+interface GambleDelegate {
+  onGambleStart(data: {
+    currentWin: number;
+  }): Promise<void>;
+  requestGambleChoice(data: {
+    currentWin: number;
+  }): Promise<GambleChoice>;
+  requestGambleResult(data: {
+    currentWin: number;
+  }): Promise<GambleResult>;
+  presentGambleResult(data: {
+    won: boolean;
+    amount: number;
+  }): Promise<void>;
+  onGambleEnd(data: {
+    finalWin: number;
+  }): Promise<void>;
+}
+/** Present when game has buy feature functionality. */
+interface BuyFeatureDelegate {
+  requestBuyFeatureResult(data: {
+    featureType: FeatureType;
+  }): Promise<FeatureTrigger>;
+  onBuyFeatureStart(data: {
+    featureType: FeatureType;
+  }): Promise<void>;
+  onBuyFeatureEnd(data: {
+    totalWin: number;
+  }): Promise<void>;
+}
+interface ExpandingWildDelegate {
+  presentExpandingWild(data: {
+    position: GridPosition;
+    expandedPositions: GridPosition[];
+  } & PresentationContext): Promise<void>;
+}
+interface StickyWildDelegate {
+  presentStickyWild(data: {
+    position: GridPosition;
+  } & PresentationContext): Promise<void>;
+}
+interface WalkingWildDelegate {
+  presentWalkingWild(data: {
+    from: GridPosition;
+    to: GridPosition;
+  } & PresentationContext): Promise<void>;
+}
+interface StackedWildDelegate {
+  presentStackedWild(data: {
+    positions: GridPosition[];
+  } & PresentationContext): Promise<void>;
+}
+interface MultiplierWildDelegate {
+  presentMultiplierWild(data: {
+    position: GridPosition;
+    multiplier: number;
+  } & PresentationContext): Promise<void>;
+}
+interface RandomWildDelegate {
+  presentRandomWild(data: {
+    positions: GridPosition[];
+  } & PresentationContext): Promise<void>;
+}
+//#endregion
+export { StackedWildEvent as $, FeatureType as A, MultiplierWildEvent as B, WaysWinDelegate as C, ClusterWin as D, CascadeStep as E, GridPosition as F, PresentationContext as G, PickBonusParams as H, HoldAndSpinParams as I, ScatterWin as J, RandomWildEvent as K, HoldAndSpinRoundResult as L, GambleChoice as M, GambleResult as N, ExpandingWildEvent as O, GameConfig as P, SpinResult as Q, JackpotWin as R, WalkingWildDelegate as S, CapabilityType as T, PickChoice as U, PaylineWin as V, PickReveal as W, SpinMode as X, SpinFlowResult as Y, SpinRequestContext as Z, ScatterWinDelegate as _, ClusterWinDelegate as a, WaysWin as at, StickyWildDelegate as b, ExpandingWildDelegate as c, WheelSpinResult as ct, HoldAndSpinDelegate as d, WinResult as dt, StickyWildEvent as et, JackpotDelegate as f, WinType as ft, RandomWildDelegate as g, PickBonusDelegate as h, CascadeDelegate as i, WalkingWildEvent as it, FreeSpinsParams as j, FeatureTrigger as k, FreeSpinsDelegate as l, WildEvent as lt, PaylineWinDelegate as m, BigWinDelegate as n, SymbolId as nt, CoreDelegate as o, WheelBonusParams as ot, MultiplierWildDelegate as p, createSymbolId as pt, RegularWildEvent as q, BuyFeatureDelegate as r, SymbolTransform as rt, DataDelegate as s, WheelSegment as st, AnticipationDelegate as t, SymbolGrid as tt, GambleDelegate as u, WildType as ut, SpindleDelegate as v, WheelBonusDelegate as w, SymbolTransformDelegate as x, StackedWildDelegate as y, LockedSymbol as z };
+//# sourceMappingURL=delegates-DOwv3sAL.d.cts.map

package/dist/delegates-DOwv3sAL.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegates-DOwv3sAL.d.cts","names":[],"sources":["../src/types.ts","../src/delegates.ts"],"mappings":"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"}