@rb-games/core 0.1.0

package/dist/plugins/sound/SoundPlugin.types.d.ts

@@ -0,0 +1,102 @@
+import type { PluginConfig } from '../Plugin.types';
+import type { SoundChannel } from '../resource/ResourcePlugin.types';
+/**
+ * Sound sprite data for defining segments within a sound file.
+ *
+ * @public
+ */
+export interface SoundSpriteData {
+    /** Start time in seconds */
+    start: number;
+    /** End time in seconds */
+    end: number;
+    /** Whether this sprite should loop */
+    loop?: boolean;
+}
+/**
+ * Channel configuration for volume and instance management.
+ *
+ * @public
+ */
+export interface ChannelConfig {
+    /** Default volume for this channel (0-1) */
+    volume: number;
+    /** Maximum concurrent instances for this channel */
+    maxInstances?: number;
+    /** Whether this channel is muted by default */
+    muted?: boolean;
+}
+/**
+ * Play options for sound playback.
+ *
+ * @public
+ */
+export interface PlayOptions {
+    /** Whether to loop the sound (native seamless loop) */
+    loop?: boolean;
+    /** Volume override (0-1) */
+    volume?: number;
+    /** Playback speed (1 = normal) */
+    speed?: number;
+    /** Start time offset in seconds */
+    start?: number;
+    /** End time in seconds */
+    end?: number;
+    /**
+     * Interval loop: wait before replaying the sound.
+     * Overrides native `loop` when set.
+     *
+     * - `number` — fixed delay in ms (e.g. `1000` = 1s gap between plays)
+     * - `[min, max]` — random delay in ms (e.g. `[5000, 10000]` = 5-10s random gap)
+     */
+    loopInterval?: number | [number, number];
+    /** Optional logical group to group this playback under (for stopGroup) */
+    group?: string;
+    /** If true and group is set, auto-stop previous sounds under the same group before playing */
+    stopPreviousGroup?: boolean;
+    /** Callback when playback completes */
+    complete?: () => void;
+}
+/**
+ * Configuration for SoundPlugin.
+ *
+ * @public
+ */
+export interface SoundPluginConfig extends PluginConfig {
+    /** Channel configurations */
+    channels?: Partial<Record<SoundChannel, ChannelConfig>>;
+    /** Master volume (0-1) */
+    masterVolume?: number;
+    /** Auto-unlock audio context on user interaction */
+    autoUnlock?: boolean;
+    /** Disable auto-pause when window loses focus */
+    disableAutoPause?: boolean;
+}
+/**
+ * Internal sprite registry entry.
+ *
+ * @internal
+ */
+export interface SpriteRegistryEntry {
+    /** The sound alias that contains this sprite */
+    soundAlias: string;
+    /** The sprite key within the sound */
+    spriteKey: string;
+    /** The channel this sprite belongs to */
+    channel?: SoundChannel;
+}
+/**
+ * Options for queueIn method - fades out existing sounds and fades in a new one.
+ *
+ * @public
+ */
+export interface QueueInOptions extends PlayOptions {
+    /** Duration for fade out of existing sounds (defaults to main duration if not specified) */
+    fadeOutDuration?: number;
+    /** Transition type: crossfade (simultaneous) or sequential (fade out first, then fade in) */
+    type?: 'crossfade' | 'sequential';
+    /** Override channel (uses alias's registered channel if not provided) */
+    channel?: SoundChannel;
+}
+export { SoundChannel };
+//# sourceMappingURL=SoundPlugin.types.d.ts.map

package/dist/plugins/sound/SoundPlugin.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoundPlugin.types.d.ts","sourceRoot":"","sources":["../../../plugins/sound/SoundPlugin.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,0BAA0B;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACrD,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC;IACxD,0BAA0B;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,4FAA4F;IAC5F,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC;IAClC,yEAAyE;IACzE,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/plugins/sound/SoundTestGUI.d.ts

@@ -0,0 +1,42 @@
+import type { SoundPlugin } from './SoundPlugin';
+/**
+ * Debug GUI for SoundPlugin using Tweakpane.
+ * Provides visual controls for testing sound playback, channels, and stop methods.
+ *
+ * @example
+ * ```typescript
+ * import { SoundTestGUI } from './SoundTestGUI';
+ *
+ * // After soundPlugin is initialized:
+ * if (isDevelopment) {
+ *   new SoundTestGUI(soundPlugin);
+ * }
+ * ```
+ */
+export declare class SoundTestGUI {
+    private pane;
+    private plugin;
+    private playingFolder;
+    private soundsFolder;
+    private updateInterval;
+    private lastSoundCount;
+    private params;
+    private channelParams;
+    constructor(soundPlugin: SoundPlugin);
+    private applyCustomStyles;
+    private initMasterControls;
+    private initChannelControls;
+    private initSoundsFolder;
+    private refreshSoundsList;
+    private initPlayingFolder;
+    private expandedAliases;
+    private updatePlayingList;
+    private initGroupControls;
+    private startAutoRefresh;
+    private syncChannelParams;
+    /**
+     * Dispose the GUI and clean up resources.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=SoundTestGUI.d.ts.map

package/dist/plugins/sound/SoundTestGUI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoundTestGUI.d.ts","sourceRoot":"","sources":["../../../plugins/sound/SoundTestGUI.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAY;IAGvB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,cAAc,CAAa;IAEnC,OAAO,CAAC,MAAM,CAIZ;IAEF,OAAO,CAAC,aAAa,CAKnB;gBAEU,WAAW,EAAE,WAAW;IA4BpC,OAAO,CAAC,iBAAiB;IAoCzB,OAAO,CAAC,kBAAkB;IAqB1B,OAAO,CAAC,mBAAmB;IA6C3B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,iBAAiB;IAqEzB,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,eAAe,CAA0B;IAEjD,OAAO,CAAC,iBAAiB;IAyHzB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,iBAAiB;IA8BzB;;OAEG;IACI,OAAO,IAAI,IAAI;CASvB"}

package/dist/plugins/sound/index.d.ts

@@ -0,0 +1,4 @@
+export * from './SoundPlugin';
+export * from './SoundPlugin.types';
+export * from './SoundTestGUI';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/sound/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugins/sound/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}

package/dist/state-machine/ConfigBuilder.d.ts

@@ -0,0 +1,239 @@
+import type { StateKey, ModeKey, ScopeKey, StateMachineConfig, StateHook, TransitionGuard } from './types';
+/**
+ * Fluent API builder for creating state machine configurations
+ *
+ * Provides a chainable interface for defining modes, states, scopes, hooks, and guards.
+ *
+ * @example
+ * ```typescript
+ * const config = createConfig<GameData>()
+ *   .initial('IDLE', 'NORMAL')
+ *   .initialData({ balance: 1000 })
+ *   .mode('NORMAL')
+ *   .state('IDLE')
+ *   .scope('ui', { spinButton: { enabled: true } })
+ *   .state('SPIN')
+ *   .extends('IDLE')
+ *   .guard('canEnter', (ctx) => ctx.data.balance >= ctx.data.bet)
+ *   .build();
+ * ```
+ *
+ * @template TData - Type of the state machine's data context
+ */
+export declare class ConfigBuilder<TData = any> {
+    constructor(initialData?: TData);
+    private config;
+    private currentMode;
+    private currentState;
+    /**
+     * Define a new mode or switch to an existing mode
+     *
+     * @param name - Mode key (e.g., 'NORMAL', 'FREESPIN', 'BONUS')
+     * @returns This builder for chaining
+     */
+    mode(name: ModeKey): this;
+    /**
+     * Define a new state in the current mode
+     *
+     * @param name - State key (e.g., 'IDLE', 'SPIN', 'MATCH')
+     * @returns This builder for chaining
+     * @throws Error if mode() hasn't been called first
+     */
+    state(name: StateKey): this;
+    /**
+     * Make current state extend from a parent state (inheritance)
+     *
+     * Child state will inherit all properties from parent state using lodash merge.
+     * Child properties override parent properties.
+     *
+     * @param parentState - Parent state key to extend from
+     * @returns This builder for chaining
+     * @throws Error if mode() and state() haven't been called first
+     *
+     * @example
+     * ```typescript
+     * .state('IDLE')
+     * .scope('ui', { spinButton: { enabled: true, icon: 'spin' } })
+     *
+     * .state('SPIN')
+     * .extends('IDLE')  // Inherits from IDLE
+     * .scope('ui', { spinButton: { icon: 'stop' } })  // Only override icon
+     * ```
+     */
+    extends(parentState: StateKey): this;
+    /**
+     * Define scope configuration for current state
+     *
+     * Scopes organize related configuration (ui, scene, audio, etc.).
+     * Values can be static or resolver functions.
+     *
+     * @param scopeName - Scope key (e.g., 'ui', 'scene', 'audio')
+     * @param scopeData - Scope configuration object
+     * @returns This builder for chaining
+     * @throws Error if mode() and state() haven't been called first
+     *
+     * @example
+     * ```typescript
+     * .scope('ui', {
+     *   spinButton: {
+     *     enabled: true,
+     *     icon: (ctx) => ctx.data.isQuickSpin ? 'quick_spin' : 'spin',
+     *   },
+     *   betButtons: { enabled: false },
+     * })
+     * .scope('scene', {
+     *   reels: { spinning: true },
+     * })
+     * ```
+     */
+    scope(scopeName: ScopeKey, scopeData: Record<string, Record<string, any>>): this;
+    /**
+     * Add onEnter lifecycle hook to current state
+     *
+     * Called when entering this state. Can be async.
+     * Transition waits for this hook to complete.
+     *
+     * @param hook - Lifecycle hook function
+     * @returns This builder for chaining
+     * @throws Error if mode() and state() haven't been called first
+     *
+     * @example
+     * ```typescript
+     * .onEnter(async (ctx) => {
+     *   ctx.data.balance -= ctx.data.bet;
+     *   await scene.playAnimation();
+     * })
+     * ```
+     */
+    onEnter(hook: StateHook<TData>): this;
+    /**
+     * Add onExit lifecycle hook to current state
+     *
+     * Called when exiting this state. Can be async.
+     * Transition waits for this hook to complete.
+     *
+     * @param hook - Lifecycle hook function
+     * @returns This builder for chaining
+     * @throws Error if mode() and state() haven't been called first
+     *
+     * @example
+     * ```typescript
+     * .onExit(async (ctx) => {
+     *   await scene.cleanup();
+     * })
+     * ```
+     */
+    onExit(hook: StateHook<TData>): this;
+    /**
+     * Add transition guard to current state
+     *
+     * Guards control whether transitions are allowed.
+     * Return false to block transition.
+     *
+     * @param type - Guard type ('canEnter' or 'canExit')
+     * @param guard - Guard function
+     * @returns This builder for chaining
+     * @throws Error if mode() and state() haven't been called first
+     *
+     * @example
+     * ```typescript
+     * .guard('canEnter', (ctx) => ctx.data.balance >= ctx.data.bet)
+     * .guard('canExit', (ctx) => !ctx.data.isLocked)
+     * ```
+     */
+    guard(type: 'canEnter' | 'canExit', guard: TransitionGuard<TData>): this;
+    /**
+     * Add metadata to current state
+     *
+     * @param data - Metadata object
+     * @returns This builder for chaining
+     * @throws Error if mode() and state() haven't been called first
+     */
+    metadata(data: Record<string, any>): this;
+    /**
+     * Add lifecycle hook to current mode
+     *
+     * @param type - Hook type ('onEnter' or 'onExit')
+     * @param hook - Lifecycle hook function
+     * @returns This builder for chaining
+     * @throws Error if mode() hasn't been called first
+     *
+     * @example
+     * ```typescript
+     * .mode('FREESPIN')
+     * .modeHook('onEnter', (ctx) => {
+     *   ctx.data.freeSpinsRemaining = 10;
+     * })
+     * ```
+     */
+    modeHook(type: 'onEnter' | 'onExit', hook: StateHook<TData>): this;
+    /**
+     * Set initial state and mode
+     *
+     * @param state - Initial state key
+     * @param mode - Initial mode key
+     * @returns This builder for chaining
+     *
+     * @example
+     * ```typescript
+     * .initial('IDLE', 'NORMAL')
+     * ```
+     */
+    initial(state: StateKey, mode: ModeKey): this;
+    /**
+     * Set initial data for state context
+     *
+     * @param data - Initial data object
+     * @returns This builder for chaining
+     *
+     * @example
+     * ```typescript
+     * .initialData({ balance: 1000, bet: 10 })
+     * ```
+     */
+    initialData(data: TData): this;
+    /**
+     * Enable strict mode (throws errors instead of emitting error events)
+     *
+     * @param value - Enable strict mode (default: true)
+     * @returns This builder for chaining
+     */
+    strict(value?: boolean): this;
+    /**
+     * Build and return the final state machine configuration
+     *
+     * @returns Complete state machine configuration
+     * @throws Error if initial state and mode haven't been set
+     *
+     * @example
+     * ```typescript
+     * const config = createConfig()
+     *   .initial('IDLE', 'NORMAL')
+     *   .mode('NORMAL')
+     *   .state('IDLE')
+     *   .build();
+     * ```
+     */
+    build(): StateMachineConfig<TData>;
+}
+/**
+ * Create a new config builder instance
+ *
+ * @template TData - Type of the state machine's data context
+ * @returns New ConfigBuilder instance
+ *
+ * @example
+ * ```typescript
+ * interface GameData {
+ *   balance: number;
+ *   bet: number;
+ * }
+ *
+ * const config = createConfig<GameData>()
+ *   .initial('IDLE', 'NORMAL')
+ *   .initialData({ balance: 1000, bet: 10 })
+ *   .build();
+ * ```
+ */
+export declare function createConfig<TData = any>(initialData?: TData): ConfigBuilder<TData>;
+//# sourceMappingURL=ConfigBuilder.d.ts.map

package/dist/state-machine/ConfigBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigBuilder.d.ts","sourceRoot":"","sources":["../../state-machine/ConfigBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,OAAO,EACP,QAAQ,EAER,kBAAkB,EAClB,SAAS,EACT,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,aAAa,CAAC,KAAK,GAAG,GAAG;gBACxB,WAAW,CAAC,EAAE,KAAK;IAI/B,OAAO,CAAC,MAAM,CAEZ;IACF,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,YAAY,CAAyB;IAE7C;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAQzB;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAY3B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,WAAW,EAAE,QAAQ,GAAG,IAAI;IASpC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI;IAYhF;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI;IASrC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI;IASpC;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,EAAE,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,IAAI;IAYxE;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IASzC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,EAAE,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI;IASlE;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI;IAM7C;;;;;;;;;;OAUG;IACH,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI;IAK9B;;;;;OAKG;IACH,MAAM,CAAC,KAAK,UAAO,GAAG,IAAI;IAK1B;;;;;;;;;;;;;;OAcG;IACH,KAAK,IAAI,kBAAkB,CAAC,KAAK,CAAC;CAMnC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,CAAC,EAAE,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAEnF"}

package/dist/state-machine/StateMachine.d.ts

@@ -0,0 +1,251 @@
+import { EventEmitter } from 'pixi.js';
+import type { StateKey, ModeKey, ScopeKey, StateContext, StateMachineConfig, TransitionOptions, StateMachineEvents } from './types';
+/**
+ * Event-driven state machine with two-level hierarchy (MODE/STATE).
+ *
+ * Features:
+ * - Two-level structure: MODE (NORMAL, FREESPIN, BONUS) → STATE (IDLE, SPIN, MATCH)
+ * - State inheritance with lodash merge
+ * - Scope-based configuration (ui, scene, audio, etc.)
+ * - Dynamic values via resolver functions
+ * - Async lifecycle hooks (onEnter, onExit)
+ * - Transition guards for validation
+ * - Pixi.js EventEmitter for decoupled communication
+ *
+ * @example
+ * ```typescript
+ * const config = createConfig<GameData>()
+ *   .initial('IDLE', 'NORMAL')
+ *   .mode('NORMAL')
+ *   .state('IDLE')
+ *   .scope('ui', { spinButton: { enabled: true } })
+ *   .state('SPIN')
+ *   .extends('IDLE')
+ *   .guard('canEnter', (ctx) => ctx.data.balance >= ctx.data.bet)
+ *   .build();
+ *
+ * const machine = new StateMachine(config);
+ * await machine.transition('SPIN');
+ * ```
+ *
+ * @template TData - Type of the state machine's data context
+ */
+export declare class StateMachine<TData = any> extends EventEmitter<StateMachineEvents<TData>> {
+    private config;
+    private context;
+    private isTransitioning;
+    private resolvedStateCache;
+    constructor(config: StateMachineConfig<TData>);
+    /**
+     * Current state key (e.g., 'IDLE', 'SPIN', 'MATCH')
+     */
+    get state(): StateKey;
+    /**
+     * Current mode key (e.g., 'NORMAL', 'FREESPIN', 'BONUS')
+     */
+    get mode(): ModeKey;
+    /**
+     * Current state data (mutable)
+     */
+    get data(): TData;
+    /**
+     * Get a readonly copy of the current state context
+     *
+     * @returns Readonly state context with current state, mode, data, and metadata
+     */
+    getContext(): Readonly<StateContext<TData>>;
+    /**
+     * Update state data using an updater function
+     *
+     * @param updater - Function that receives current data and optionally returns new data
+     *
+     * @example
+     * ```typescript
+     * machine.updateData(data => {
+     *   data.balance = 1000;
+     *   data.bet = 10;
+     * });
+     * ```
+     */
+    updateData(updater: (data: TData) => TData | void): void;
+    private resolveStateDefinition;
+    private resolveScopeData;
+    private resolveValue;
+    /**
+     * Get resolved scope data for a specific scope
+     *
+     * @param scopeName - Name of the scope (e.g., 'ui', 'scene', 'audio')
+     * @returns Resolved scope data with all resolver functions evaluated
+     *
+     * @example
+     * ```typescript
+     * const uiState = machine.getScope('ui');
+     * console.log(uiState.spinButton.enabled); // true
+     * ```
+     */
+    getScope(scopeName: ScopeKey): any;
+    /**
+     * Get all resolved scope data for the current state
+     *
+     * @returns Object containing all scopes with resolved data
+     *
+     * @example
+     * ```typescript
+     * const scopes = machine.getAllScopes();
+     * console.log(scopes.ui);    // UI scope data
+     * console.log(scopes.scene); // Scene scope data
+     * ```
+     */
+    getAllScopes(): Record<ScopeKey, any>;
+    /**
+     * Transition to a new state within the current mode
+     *
+     * This is an async operation that:
+     * 1. Checks guards (canExit, canEnter)
+     * 2. Calls onExit hook of current state
+     * 3. Changes the state
+     * 4. Calls onEnter hook of target state
+     * 5. Emits events (state:exit, state:enter, state:change, scope:update)
+     *
+     * @param targetState - Target state key to transition to
+     * @param options - Transition options
+     * @param options.force - Skip guard checks and force transition
+     * @param options.silent - Skip event emissions
+     * @returns Promise that resolves to true if transition succeeded, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Normal transition
+     * await machine.transition('SPIN');
+     *
+     * // Force transition (skip guards)
+     * await machine.transition('SPIN', { force: true });
+     *
+     * // Silent transition (no events)
+     * await machine.transition('SPIN', { silent: true });
+     * ```
+     *
+     * @fires state:exit - When exiting current state
+     * @fires state:enter - When entering target state
+     * @fires state:change - After state change completes
+     * @fires scope:update - For each scope after state change
+     * @fires transition:blocked - If guard check fails
+     * @fires error - If an error occurs during transition
+     */
+    transition(targetState: StateKey, options?: TransitionOptions): Promise<boolean>;
+    /**
+     * Change to a different mode with an optional initial state
+     *
+     * This will:
+     * 1. Call onExit hook of current mode
+     * 2. Clear state resolution cache
+     * 3. Change mode and state
+     * 4. Call onEnter hook of target mode
+     * 5. Call onEnter hook of initial state
+     * 6. Emit events
+     *
+     * @param targetMode - Target mode key to switch to
+     * @param initialState - Optional initial state in the target mode (defaults to config.initialState)
+     * @returns Promise that resolves to true if mode change succeeded, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Switch to freespin mode
+     * await machine.changeMode('FREESPIN', 'IDLE');
+     *
+     * // Return to normal mode
+     * await machine.changeMode('NORMAL', 'IDLE');
+     * ```
+     *
+     * @fires mode:exit - When exiting current mode
+     * @fires mode:enter - When entering target mode
+     * @fires mode:change - After mode change completes
+     * @fires state:enter - When entering initial state
+     * @fires scope:update - For each scope after mode change
+     */
+    changeMode(targetMode: ModeKey, initialState?: StateKey): Promise<boolean>;
+    /**
+     * Check if a state exists in the current mode (synchronous, no guard check)
+     *
+     * @param targetState - State key to check
+     * @returns True if state exists in current mode, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (machine.can('SPIN')) {
+     *   console.log('SPIN state exists');
+     * }
+     * ```
+     */
+    can(targetState: StateKey): boolean;
+    /**
+     * Check if transition to a state is allowed (async, includes guard check)
+     *
+     * @param targetState - State key to check
+     * @returns Promise that resolves to true if transition is allowed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (await machine.canAsync('SPIN')) {
+     *   await machine.transition('SPIN');
+     * } else {
+     *   console.log('Cannot transition to SPIN');
+     * }
+     * ```
+     */
+    canAsync(targetState: StateKey): Promise<boolean>;
+    private checkGuards;
+    /**
+     * Check if current state matches the given state key
+     *
+     * @param state - State key to compare
+     * @returns True if current state matches, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (machine.is('SPIN')) {
+     *   console.log('Currently spinning');
+     * }
+     * ```
+     */
+    is(state: StateKey): boolean;
+    /**
+     * Check if current mode matches the given mode key
+     *
+     * @param mode - Mode key to compare
+     * @returns True if current mode matches, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (machine.isMode('FREESPIN')) {
+     *   console.log('In freespin mode');
+     * }
+     * ```
+     */
+    isMode(mode: ModeKey): boolean;
+    /**
+     * Reset state machine to initial state and mode
+     *
+     * Clears cache and resets context to initial configuration
+     *
+     * @example
+     * ```typescript
+     * machine.reset();
+     * console.log(machine.state); // Initial state
+     * console.log(machine.mode);  // Initial mode
+     * ```
+     */
+    reset(): void;
+    /**
+     * Destroy state machine and clean up resources
+     *
+     * Clears cache and removes all event listeners
+     *
+     * @example
+     * ```typescript
+     * machine.destroy();
+     * ```
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=StateMachine.d.ts.map

package/dist/state-machine/StateMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMachine.d.ts","sourceRoot":"","sources":["../../state-machine/StateMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,KAAK,EACV,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EAIjB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,YAAY,CAAC,KAAK,GAAG,GAAG,CAAE,SAAQ,YAAY,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACpF,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,kBAAkB,CAA6C;gBAE3D,MAAM,EAAE,kBAAkB,CAAC,KAAK,CAAC;IA0B7C;;OAEG;IACH,IAAI,KAAK,IAAI,QAAQ,CAEpB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAElB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,KAAK,CAEhB;IAED;;;;OAIG;IACH,UAAU,IAAI,QAAQ,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAI3C;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,KAAK,GAAG,IAAI,GAAG,IAAI;IAOxD,OAAO,CAAC,sBAAsB;IA0D9B,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,YAAY;IAOpB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,GAAG;IAMlC;;;;;;;;;;;OAWG;IACH,YAAY,IAAI,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC;IAKrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACG,UAAU,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC;IAwF1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,UAAU,CAAC,UAAU,EAAE,OAAO,EAAE,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IA0EhF;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,WAAW,EAAE,QAAQ,GAAG,OAAO;IAKnC;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;YAKzC,WAAW;IAwBzB;;;;;;;;;;;;OAYG;IACH,EAAE,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAI5B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAI9B;;;;;;;;;;;OAWG;IACH,KAAK,IAAI,IAAI;IAab;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAIhB"}