koin.js 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,858 @@
+import * as react from 'react';
+import { Nostalgist } from 'nostalgist';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Unified Control System Types
+ *
+ * Single source of truth for all control-related type definitions.
+ */
+/**
+ * All possible button identifiers (superset of all consoles)
+ */
+type ButtonId = 'up' | 'down' | 'left' | 'right' | 'a' | 'b' | 'x' | 'y' | 'l' | 'r' | 'l2' | 'r2' | 'l3' | 'r3' | 'start' | 'select';
+/**
+ * D-pad buttons
+ */
+declare const DPAD_BUTTONS: ButtonId[];
+/**
+ * Face buttons
+ */
+declare const FACE_BUTTONS: ButtonId[];
+/**
+ * Shoulder buttons (L/R only)
+ */
+declare const SHOULDER_BUTTONS: ButtonId[];
+/**
+ * Trigger buttons (L2/R2)
+ */
+declare const TRIGGER_BUTTONS: ButtonId[];
+/**
+ * Stick click buttons
+ */
+declare const STICK_BUTTONS: ButtonId[];
+/**
+ * System buttons
+ */
+declare const SYSTEM_BUTTONS: ButtonId[];
+/**
+ * All buttons in display order
+ */
+declare const ALL_BUTTONS: ButtonId[];
+/**
+ * Keyboard mapping: button → JavaScript KeyboardEvent.code
+ * Partial because not all consoles have all buttons
+ */
+type KeyboardMapping = Partial<Record<ButtonId, string>>;
+/**
+ * Gamepad mapping: button → physical button index (W3C Gamepad API)
+ * Partial because users may not map all buttons
+ */
+type GamepadMapping = Partial<Record<ButtonId, number>>;
+/**
+ * Which buttons a console actually has
+ */
+interface ConsoleCapabilities {
+    /** Console key (e.g., 'NES', 'SNES') */
+    console: string;
+    /** List of buttons this console supports */
+    buttons: ButtonId[];
+}
+/**
+ * Information about a connected gamepad
+ */
+interface GamepadInfo {
+    /** Gamepad index (0-3) */
+    index: number;
+    /** Raw gamepad identifier string */
+    id: string;
+    /** Cleaned up display name */
+    name: string;
+    /** Whether currently connected */
+    connected: boolean;
+    /** Number of buttons */
+    buttons: number;
+    /** Number of axes */
+    axes: number;
+    /** Mapping type from Gamepad API */
+    mapping: GamepadMappingType;
+}
+/**
+ * Detected controller brand for UI theming
+ */
+type ControllerBrand = 'xbox' | 'playstation' | 'nintendo' | 'generic';
+/**
+ * Player index (1-4)
+ */
+type PlayerIndex = 1 | 2 | 3 | 4;
+/**
+ * Full control configuration for the emulator
+ */
+interface ControlConfig {
+    /** Keyboard controls (usually player 1 only) */
+    keyboard?: KeyboardMapping;
+    /** Gamepad controls per player */
+    gamepads?: GamepadMapping[];
+}
+
+/**
+ * Default Control Mappings
+ *
+ * Single source of truth for all default button mappings.
+ */
+
+/**
+ * Standard W3C Gamepad API button indices
+ * https://w3c.github.io/gamepad/#remapping
+ */
+declare const STANDARD_GAMEPAD_BUTTONS: Record<ButtonId, number>;
+/**
+ * Default keyboard mapping (SNES-like, works for most consoles)
+ */
+declare const DEFAULT_KEYBOARD: KeyboardMapping;
+/**
+ * Default gamepad mapping (uses standard W3C indices)
+ */
+declare const DEFAULT_GAMEPAD: GamepadMapping;
+/**
+ * Get a complete keyboard mapping with all buttons filled in
+ * Uses defaults for any missing buttons
+ */
+declare function getFullKeyboardMapping(partial?: Partial<KeyboardMapping>): KeyboardMapping;
+/**
+ * Get a complete gamepad mapping with all buttons filled in
+ * Uses defaults for any missing buttons
+ */
+declare function getFullGamepadMapping(partial?: Partial<GamepadMapping>): GamepadMapping;
+
+/**
+ * Button Labels for UI Display
+ *
+ * Single source of truth for button display names.
+ */
+
+/**
+ * Human-readable labels for each button
+ */
+declare const BUTTON_LABELS: Record<ButtonId, string>;
+/**
+ * Button groups for organized UI display
+ */
+declare const BUTTON_GROUPS: {
+    label: string;
+    buttons: ButtonId[];
+}[];
+/**
+ * Format a JavaScript key code for display
+ */
+declare function formatKeyCode(code: string): string;
+/**
+ * Get human-readable name for a gamepad button index
+ */
+declare function formatGamepadButton(index: number | undefined): string;
+
+/**
+ * Per-Console Control Presets
+ *
+ * Defines which buttons each console supports and
+ * console-specific default keyboard layouts.
+ */
+
+/**
+ * Console capabilities - which buttons each system has
+ */
+declare const CONSOLE_CAPABILITIES: Record<string, ConsoleCapabilities>;
+/**
+ * Console-specific keyboard overrides
+ * Only specify keys that differ from DEFAULT_KEYBOARD
+ */
+declare const CONSOLE_KEYBOARD_OVERRIDES: Partial<Record<string, Partial<KeyboardMapping>>>;
+/**
+ * Get capabilities for a console
+ * Falls back to SNES-like if unknown
+ */
+declare function getConsoleCapabilities(system: string): ConsoleCapabilities;
+/**
+ * Get the list of buttons for a console
+ */
+declare function getConsoleButtons(system: string): ButtonId[];
+/**
+ * Get default keyboard mapping for a console
+ * Merges console-specific overrides with defaults
+ */
+declare function getConsoleKeyboardDefaults(system: string): KeyboardMapping;
+/**
+ * Check if a console supports a specific button
+ */
+declare function consoleHasButton(system: string, button: ButtonId): boolean;
+
+/**
+ * Control Storage Utilities
+ *
+ * Load and save keyboard/gamepad mappings from localStorage.
+ */
+
+/**
+ * Load keyboard mapping from localStorage
+ * Falls back to console-specific defaults if not found
+ */
+declare function loadKeyboardMapping(system?: string): KeyboardMapping;
+/**
+ * Save keyboard mapping to localStorage
+ */
+declare function saveKeyboardMapping(mapping: KeyboardMapping, system?: string): void;
+/**
+ * Load gamepad mapping from localStorage
+ * Falls back to standard defaults if not found
+ */
+declare function loadGamepadMapping(playerIndex?: PlayerIndex): GamepadMapping;
+/**
+ * Save gamepad mapping to localStorage
+ */
+declare function saveGamepadMapping(mapping: GamepadMapping, playerIndex?: PlayerIndex): void;
+/**
+ * Load all gamepad mappings for connected players
+ */
+declare function loadAllGamepadMappings(playerCount: number): GamepadMapping[];
+/**
+ * Clear all saved controls (keyboard and gamepad)
+ */
+declare function clearAllControls(): void;
+
+/**
+ * RetroArch Input Configuration
+ *
+ * Converts our control mappings to RetroArch config format.
+ */
+
+/**
+ * Convert keyboard mapping to RetroArch config for a player
+ */
+declare function keyboardToRetroArchConfig(mapping: KeyboardMapping, playerIndex?: number): Record<string, string>;
+/**
+ * Convert gamepad mapping to RetroArch config for a player
+ * Uses _btn suffix for button indices
+ */
+declare function gamepadToRetroArchConfig(mapping: GamepadMapping, playerIndex?: number): Record<string, number | string>;
+/**
+ * Build complete RetroArch input config from control configuration
+ */
+declare function buildRetroArchConfig(config: ControlConfig): Record<string, unknown>;
+
+type EmulatorStatus = 'idle' | 'loading' | 'ready' | 'running' | 'paused' | 'error';
+type SpeedMultiplier = 1 | 2;
+interface RetroAchievementsConfig {
+    username: string;
+    token: string;
+    hardcore?: boolean;
+}
+
+interface UseNostalgistOptions {
+    system: string;
+    romUrl: string;
+    core?: string;
+    biosUrl?: string | {
+        url: string;
+        name: string;
+        location?: 'system' | 'rom_folder';
+    };
+    initialState?: Blob | Uint8Array;
+    getCanvasElement?: () => HTMLCanvasElement | null;
+    keyboardControls?: KeyboardMapping;
+    gamepadBindings?: GamepadMapping[];
+    retroAchievements?: RetroAchievementsConfig;
+    onReady?: () => void;
+    onError?: (error: Error) => void;
+    initialVolume?: number;
+    romFileName?: string;
+    shader?: string;
+}
+interface UseNostalgistReturn {
+    status: EmulatorStatus;
+    error: string | null;
+    isPaused: boolean;
+    speed: SpeedMultiplier;
+    isRewinding: boolean;
+    rewindBufferSize: number;
+    volume: number;
+    isMuted: boolean;
+    prepare: () => Promise<void>;
+    start: () => Promise<void>;
+    stop: () => void;
+    restart: () => Promise<void>;
+    pause: () => void;
+    resume: () => void;
+    togglePause: () => void;
+    saveState: () => Promise<Uint8Array | null>;
+    saveStateWithBlob: () => Promise<{
+        data: Uint8Array;
+        blob: Blob;
+    } | null>;
+    loadState: (state: Uint8Array) => Promise<boolean>;
+    setSpeed: (multiplier: SpeedMultiplier) => void;
+    startRewind: () => void;
+    stopRewind: () => void;
+    rewindEnabled: boolean;
+    setVolume: (volume: number) => void;
+    toggleMute: () => void;
+    screenshot: () => Promise<string | null>;
+    pressKey: (key: string) => void;
+    resize: (size: {
+        width: number;
+        height: number;
+    }) => void;
+    applyCheat: (code: string) => void;
+    resetCheats: () => void;
+    getNostalgistInstance: () => Nostalgist | null;
+    isPerformanceMode: boolean;
+}
+declare const useNostalgist: ({ system, romUrl, core, biosUrl, initialState, getCanvasElement, keyboardControls, gamepadBindings, retroAchievements, onReady, onError, initialVolume, romFileName, shader, }: UseNostalgistOptions) => UseNostalgistReturn;
+
+/**
+ * Available CRT Shader Presets
+ * ----------------------------
+ * These are loaded from libretro/glsl-shaders via Nostalgist.
+ * Format: { id: shader_path, name: display_name, description: tooltip }
+ */
+declare const SHADER_PRESETS: readonly [{
+    readonly id: "";
+    readonly name: "None";
+    readonly description: "No shader - sharp pixels";
+}, {
+    readonly id: "crt/crt-lottes";
+    readonly name: "CRT Lottes";
+    readonly description: "High-quality arcade monitor look";
+}, {
+    readonly id: "crt/crt-easymode";
+    readonly name: "CRT Easy";
+    readonly description: "Popular, performant CRT effect";
+}, {
+    readonly id: "crt/crt-geom";
+    readonly name: "CRT Geom";
+    readonly description: "Classic CRT shader with curvature";
+}, {
+    readonly id: "crt/crt-hyllian";
+    readonly name: "CRT Hyllian";
+    readonly description: "Attractive with minimal tweaking";
+}, {
+    readonly id: "crt/crt-nes-mini";
+    readonly name: "NES Mini";
+    readonly description: "Simple scanlines like NES Classic";
+}, {
+    readonly id: "crt/zfast-crt";
+    readonly name: "zFast CRT";
+    readonly description: "Lightweight, great for mobile";
+}, {
+    readonly id: "crt/crt-potato-cool";
+    readonly name: "CRT Potato";
+    readonly description: "Fast and good for weak devices";
+}, {
+    readonly id: "handheld/lcd-grid-v2";
+    readonly name: "LCD Grid";
+    readonly description: "Game Boy style LCD effect";
+}, {
+    readonly id: "scanlines";
+    readonly name: "Scanlines";
+    readonly description: "Simple horizontal scanlines";
+}];
+type ShaderPresetId = typeof SHADER_PRESETS[number]['id'];
+interface ShaderSelectorProps {
+    currentShader: ShaderPresetId;
+    onShaderChange: (shaderId: ShaderPresetId) => void;
+    disabled?: boolean;
+    systemColor?: string;
+}
+/**
+ * Shader Selector Component
+ * -------------------------
+ * Dropdown to select CRT/LCD shader effects.
+ */
+declare const ShaderSelector: react.NamedExoticComponent<ShaderSelectorProps>;
+
+declare const RA_MEDIA_BASE = "https://media.retroachievements.org";
+interface RACredentials {
+    username: string;
+    connectToken: string;
+    apiKey?: string;
+    score?: number;
+    softcoreScore?: number;
+    avatarUrl?: string;
+}
+interface RAUser {
+    User: string;
+    Token: string;
+    Score: number;
+    SoftcoreScore: number;
+    Messages: number;
+    Permissions: number;
+    AccountType: string;
+}
+interface RAAchievement {
+    ID: number;
+    NumAwarded: number;
+    NumAwardedHardcore: number;
+    Title: string;
+    Description: string;
+    Points: number;
+    TrueRatio: number;
+    Author: string;
+    DateModified: string;
+    DateCreated: string;
+    BadgeName: string;
+    DisplayOrder: number;
+    MemAddr: string;
+    type: string | null;
+    DateEarned?: string;
+    DateEarnedHardcore?: string;
+}
+interface RAGame {
+    ID: number;
+    Title: string;
+    ConsoleID: number;
+    ConsoleName: string;
+    ForumTopicID: number;
+    Flags: number;
+    ImageIcon: string;
+    ImageTitle: string;
+    ImageIngame: string;
+    ImageBoxArt: string;
+    Publisher: string;
+    Developer: string;
+    Genre: string;
+    Released: string;
+    IsFinal: boolean;
+    RichPresencePatch?: string;
+    NumAchievements?: number;
+    NumDistinctPlayersCasual?: number;
+    NumDistinctPlayersHardcore?: number;
+}
+interface RAGameExtended extends RAGame {
+    Achievements: Record<string, RAAchievement>;
+    NumAwardedToUser?: number;
+    NumAwardedToUserHardcore?: number;
+    UserCompletion?: string;
+    UserCompletionHardcore?: string;
+}
+/**
+ * Get achievement badge URL
+ */
+declare function getAchievementBadgeUrl(badgeName: string, locked?: boolean): string;
+/**
+ * Get user avatar URL
+ */
+declare function getUserAvatarUrl(userPic: string): string;
+
+interface SaveSlot {
+    slot: number;
+    timestamp: string;
+    size: number;
+    screenshot?: string | null;
+}
+/**
+ * @deprecated Use `KeyboardMapping` from `@/lib/controls` instead
+ */
+type ControlMapping = KeyboardMapping;
+/**
+ * @deprecated Use `DEFAULT_KEYBOARD` from `@/lib/controls` instead
+ */
+declare const DEFAULT_CONTROLS: Partial<Record<ButtonId, string>>;
+interface GamePlayerProps {
+    className?: string;
+    style?: React.CSSProperties;
+    romId: string;
+    romUrl: string;
+    romFileName?: string;
+    system: string;
+    title: string;
+    core?: string;
+    biosUrl?: string | {
+        url: string;
+        name: string;
+        location?: 'system' | 'rom_folder';
+    };
+    availableBios?: {
+        id: string;
+        name: string;
+        description?: string;
+    }[];
+    currentBiosId?: string;
+    onSelectBios?: (biosId: string) => void;
+    onReady?: () => void;
+    onError?: (error: Error) => void;
+    onExit?: () => void;
+    systemColor?: string;
+    shader?: string;
+    onShaderChange?: (shader: string, requiresRestart: boolean) => void;
+    initialSlot?: number;
+    onSaveState?: (slot: number, blob: Blob, screenshot?: string) => Promise<void>;
+    onLoadState?: (slot: number) => Promise<Blob | null>;
+    onAutoSave?: (blob: Blob, screenshot?: string) => Promise<void>;
+    onGetSaveSlots?: () => Promise<SaveSlot[]>;
+    onDeleteSaveState?: (slot: number) => Promise<void>;
+    initialSaveState?: Blob;
+    onScreenshotCaptured?: (image: string | Blob) => void;
+    autoSaveInterval?: number;
+    maxSlots?: number;
+    currentTier?: string;
+    onUpgrade?: () => void;
+    retroAchievementsConfig?: {
+        username: string;
+        token: string;
+        hardcore?: boolean;
+    };
+    cheats?: Cheat[];
+    onToggleCheat?: (cheatId: number, active: boolean) => void;
+    onSessionStart?: () => void;
+    onSessionEnd?: () => void;
+    raUser?: RACredentials | null;
+    raGame?: RAGameExtended | null;
+    raAchievements?: RAAchievement[];
+    raUnlockedAchievements?: Set<number>;
+    raIsLoading?: boolean;
+    raError?: string | null;
+    onRALogin?: (username: string, password: string) => Promise<boolean>;
+    onRALogout?: () => void;
+    onRAHardcoreChange?: (enabled: boolean) => void;
+}
+interface PlayerControlsProps {
+    isPaused: boolean;
+    isRunning: boolean;
+    speed: SpeedMultiplier;
+    isRewinding: boolean;
+    rewindBufferSize: number;
+    onPauseToggle: () => void;
+    onRestart: () => void;
+    onSave: () => void;
+    onLoad: () => void;
+    onSpeedChange: (speed: SpeedMultiplier) => void;
+    onRewindStart: () => void;
+    onRewindStop: () => void;
+    onScreenshot: () => void;
+    onFullscreen: () => void;
+    onControls: () => void;
+    onCheats: () => void;
+    onRetroAchievements: () => void;
+    onExit: () => void;
+    disabled?: boolean;
+    hardcoreRestrictions?: RAHardcodeRestrictions;
+    raConnected?: boolean;
+    raGameFound?: boolean;
+    raAchievementCount?: number;
+    raIsIdentifying?: boolean;
+    autoSaveEnabled?: boolean;
+    autoSaveProgress?: number;
+    autoSaveState?: 'idle' | 'counting' | 'saving' | 'done';
+    autoSavePaused?: boolean;
+    onAutoSaveToggle?: () => void;
+    systemColor?: string;
+    gamepadCount?: number;
+    onGamepadSettings?: () => void;
+    volume?: number;
+    isMuted?: boolean;
+    onVolumeChange?: (volume: number) => void;
+    onToggleMute?: () => void;
+    onShowShortcuts?: () => void;
+    onRecordToggle?: () => void;
+    isRecording?: boolean;
+    currentShader?: ShaderPresetId;
+    onShaderChange?: (shader: ShaderPresetId, requiresRestart: boolean) => void;
+}
+interface SaveSlotModalProps {
+    isOpen: boolean;
+    mode: 'save' | 'load';
+    slots: SaveSlot[];
+    isLoading: boolean;
+    actioningSlot?: number | null;
+    onSelect: (slot: number) => void;
+    onDelete: (slot: number) => void;
+    onClose: () => void;
+    maxSlots?: number;
+    currentTier?: string;
+    onUpgrade?: () => void;
+}
+interface ControlMapperProps {
+    isOpen: boolean;
+    controls: ControlMapping;
+    onSave: (controls: ControlMapping) => void;
+    onClose: () => void;
+    system?: string;
+}
+interface CheatModalProps {
+    isOpen: boolean;
+    cheats: Cheat[];
+    activeCheats: Set<number>;
+    onToggle: (cheatId: number) => void;
+    onClose: () => void;
+}
+interface Cheat {
+    id: number;
+    code: string;
+    description: string;
+}
+interface RAHardcodeRestrictions {
+    isHardcore?: boolean;
+    canUseSaveStates: boolean;
+    canUseRewind: boolean;
+    canUseCheats: boolean;
+    canUseSlowMotion: boolean;
+}
+
+declare const GamePlayer: react.NamedExoticComponent<GamePlayerProps & {
+    controls?: KeyboardMapping;
+    saveControls?: (controls: KeyboardMapping) => void;
+}>;
+
+/**
+ * Detect controller brand from gamepad id for UI theming
+ */
+declare function detectControllerBrand(id: string): ControllerBrand;
+interface UseGamepadOptions {
+    /** Callback when a gamepad connects */
+    onConnect?: (gamepad: GamepadInfo) => void;
+    /** Callback when a gamepad disconnects */
+    onDisconnect?: () => void;
+}
+interface UseGamepadReturn {
+    /** Array of connected gamepads (up to 4) */
+    gamepads: GamepadInfo[];
+    /** Whether any gamepad is connected */
+    isAnyConnected: boolean;
+    /** Number of connected gamepads */
+    connectedCount: number;
+    /** Get raw gamepad by index for reading button states */
+    getRawGamepad: (index: number) => Gamepad | null;
+    /** Force refresh gamepad list */
+    refresh: () => void;
+}
+/**
+ * Hook to track connected gamepads
+ * Uses requestAnimationFrame polling since Gamepad API requires active polling
+ *
+ * NOTE: Browsers require a button press before reporting gamepads (security feature)
+ */
+declare function useGamepad(options?: UseGamepadOptions): UseGamepadReturn;
+/**
+ * Standard gamepad axis indices
+ */
+declare const STANDARD_AXIS_MAP: {
+    readonly leftStickX: 0;
+    readonly leftStickY: 1;
+    readonly rightStickX: 2;
+    readonly rightStickY: 3;
+};
+type StandardAxis = keyof typeof STANDARD_AXIS_MAP;
+
+type ToastType = 'success' | 'error' | 'info' | 'warning' | 'gamepad';
+interface Toast {
+    id: string;
+    message: string;
+    type: ToastType;
+    title?: string;
+    icon?: string;
+    duration?: number;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+interface ShowToastOptions {
+    title?: string;
+    icon?: string;
+    duration?: number;
+    action?: Toast['action'];
+}
+interface UseToastReturn {
+    toasts: Toast[];
+    showToast: (message: string, type?: ToastType, options?: ShowToastOptions) => void;
+    dismissToast: (id: string) => void;
+    clearToasts: () => void;
+}
+/**
+ * Hook for managing toast notifications
+ * @param defaultDuration - Default duration for toasts (default 3000ms)
+ */
+declare function useToast(defaultDuration?: number): UseToastReturn;
+
+interface SystemConfig {
+    key: string;
+    label: string;
+    fullName: string;
+    slug: string;
+    extensions: string[];
+    core: string;
+    dbNames: string[];
+    iconName: string;
+    color: string;
+    accentHex: string;
+    aliases: string[];
+    biosNeeded?: boolean;
+    biosFileNames?: string[];
+    biosLocation?: 'system' | 'rom_folder';
+}
+/**
+ * The master system configuration
+ * Order matters for display in dropdowns
+ */
+declare const SYSTEMS: SystemConfig[];
+
+/**
+ * Unified System Configuration
+ *
+ * SINGLE SOURCE OF TRUTH for all system-related data:
+ * - Canonical system keys (used internally)
+ * - File extensions → system detection
+ * - System → RetroArch emulator core
+ * - System → Database names (for LaunchBox matching)
+ * - System → Display metadata (UI labels, colors, icons)
+ *
+ * All other files should import from here instead of maintaining their own mappings.
+ */
+
+/**
+ * Get system by canonical key (e.g., 'NES', 'GBA')
+ */
+declare function getSystemByKey(key: string): SystemConfig | undefined;
+/**
+ * Get system by any name/alias (case-insensitive)
+ * Tries: exact key match, then alias match
+ */
+declare function getSystem(name: string): SystemConfig | undefined;
+/**
+ * Get system from file extension (e.g., '.nes', '.gba')
+ */
+declare function getSystemFromExtension(filename: string): SystemConfig | undefined;
+/**
+ * Get system by database name (for LaunchBox matching)
+ */
+declare function getSystemByDbName(dbName: string): SystemConfig | undefined;
+/**
+ * Get RetroArch core for a system name (case-insensitive)
+ * Falls back to 'fceumm' (NES) if not found
+ */
+declare function getCore(systemName: string): string;
+/**
+ * Get DB names for matching (used in game search)
+ */
+declare function getDBSystemNames(systemKey: string): string[];
+/**
+ * Check if a system is supported
+ */
+declare function isSystemSupported(name: string): boolean;
+/**
+ * Get all supported extensions
+ */
+declare function getSupportedExtensions(): string[];
+/**
+ * Get all systems for UI dropdown
+ */
+declare function getSystemsList(): Array<{
+    value: string;
+    label: string;
+    iconName: string;
+    color: string;
+}>;
+/**
+ * Detect system from filename
+ * Returns null for ZIP files (user must select)
+ */
+declare function detectSystem(filename: string): SystemConfig | undefined;
+/**
+ * Check if two system names refer to the same platform
+ */
+declare function systemsMatch(name1: string, name2: string): boolean;
+/**
+ * Normalize a system name to its canonical key
+ */
+declare function normalizeSystemKey(name: string): string;
+declare const SUPPORTED_EXTENSIONS: string[];
+/**
+ * TIER 1: "Zero Lag" - Lightweight Systems
+ * ----------------------------------------
+ * These 8-bit and 16-bit systems have low CPU requirements in WASM,
+ * allowing us to enable Run-Ahead (frame prediction) for near-zero input latency.
+ *
+ * Run-Ahead works by running the emulator ahead by 1 frame and using that
+ * result for display, effectively cutting 1 frame (~16ms) of input lag.
+ */
+declare const PERFORMANCE_TIER_1_SYSTEMS: Set<string>;
+/**
+ * TIER 2: "Max Smoothness" - Heavy Systems
+ * ----------------------------------------
+ * These 32-bit+ systems push WASM hard. Run-Ahead would cause stuttering.
+ * Instead, we optimize for smooth, consistent frame delivery:
+ * - Threaded video rendering to prevent UI freezes
+ * - Larger audio buffers to prevent crackling
+ * - Disabled manual rewind capture (saves RAM and CPU cycles)
+ */
+declare const PERFORMANCE_TIER_2_SYSTEMS: Set<string>;
+
+interface RASidebarProps {
+    isOpen: boolean;
+    onClose: () => void;
+    isLoggedIn: boolean;
+    credentials: RACredentials | null;
+    isLoading: boolean;
+    error?: string | null;
+    onLogin: (username: string, password: string) => Promise<boolean>;
+    onLogout: () => void;
+    hardcoreEnabled: boolean;
+    onHardcoreChange: (enabled: boolean) => void;
+    currentGame: RAGameExtended | null;
+    achievements: RAAchievement[];
+    unlockedIds: Set<number>;
+}
+declare function RASidebar({ isOpen, onClose, isLoggedIn, credentials, isLoading, error, onLogin, onLogout, hardcoreEnabled, onHardcoreChange, currentGame, achievements, unlockedIds, }: RASidebarProps): react_jsx_runtime.JSX.Element | null;
+
+interface AchievementPopupProps {
+    achievement: RAAchievement;
+    hardcore: boolean;
+    onDismiss: () => void;
+    autoDismissMs?: number;
+}
+declare function AchievementPopup({ achievement, hardcore, onDismiss, autoDismissMs, }: AchievementPopupProps): react_jsx_runtime.JSX.Element;
+
+interface ToastContainerProps {
+    toasts: Toast[];
+    onDismiss?: (id: string) => void;
+}
+declare function ToastContainer({ toasts, onDismiss }: ToastContainerProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Shortcuts Reference
+ * -------------------
+ * Collapsible panel showing player F-key shortcuts.
+ * Game controls have their own config in the Keys modal.
+ */
+interface ShortcutsReferenceProps {
+    systemColor?: string;
+    isExpanded?: boolean;
+}
+declare const ShortcutsReference: react.NamedExoticComponent<ShortcutsReferenceProps>;
+
+interface UseGameRecordingProps {
+    getCanvasElement: () => HTMLCanvasElement | null;
+}
+interface UseGameRecordingReturn {
+    isRecording: boolean;
+    isPaused: boolean;
+    recordingDuration: number;
+    startRecording: () => void;
+    stopRecording: () => Promise<Blob | null>;
+    pauseRecording: () => void;
+    resumeRecording: () => void;
+    isSupported: boolean;
+}
+/**
+ * Gameplay Recording Hook
+ * -----------------------
+ * Uses MediaRecorder API to capture canvas gameplay as WebM video.
+ *
+ * Features:
+ * - Start/stop recording
+ * - Pause/resume
+ * - Duration tracking
+ * - Returns Blob for download
+ */
+declare function useGameRecording({ getCanvasElement, }: UseGameRecordingProps): UseGameRecordingReturn;
+
+export { ALL_BUTTONS, AchievementPopup, BUTTON_GROUPS, BUTTON_LABELS, type ButtonId, CONSOLE_CAPABILITIES, CONSOLE_KEYBOARD_OVERRIDES, type Cheat, type CheatModalProps, type ConsoleCapabilities, type ControlConfig, type ControlMapperProps, type ControlMapping, type ControllerBrand, DEFAULT_CONTROLS, DEFAULT_GAMEPAD, DEFAULT_KEYBOARD, DPAD_BUTTONS, type EmulatorStatus, FACE_BUTTONS, GamePlayer, type GamePlayerProps, type GamepadInfo, type GamepadMapping, type KeyboardMapping, PERFORMANCE_TIER_1_SYSTEMS, PERFORMANCE_TIER_2_SYSTEMS, type PlayerControlsProps, type PlayerIndex, type RAAchievement, type RACredentials, type RAGame, type RAGameExtended, type RAHardcodeRestrictions, RASidebar, type RAUser, RA_MEDIA_BASE, type RetroAchievementsConfig, SHADER_PRESETS, SHOULDER_BUTTONS, STANDARD_AXIS_MAP, STANDARD_GAMEPAD_BUTTONS, STICK_BUTTONS, SUPPORTED_EXTENSIONS, SYSTEMS, SYSTEM_BUTTONS, type SaveSlot, type SaveSlotModalProps, type ShaderPresetId, ShaderSelector, ShortcutsReference, type ShowToastOptions, type SpeedMultiplier, type StandardAxis, type SystemConfig, TRIGGER_BUTTONS, type Toast, ToastContainer, type ToastType, type UseGamepadOptions, type UseGamepadReturn, type UseNostalgistReturn, type UseToastReturn, buildRetroArchConfig, clearAllControls, consoleHasButton, detectControllerBrand, detectSystem, formatGamepadButton, formatKeyCode, gamepadToRetroArchConfig, getAchievementBadgeUrl, getConsoleButtons, getConsoleCapabilities, getConsoleKeyboardDefaults, getCore, getDBSystemNames, getFullGamepadMapping, getFullKeyboardMapping, getSupportedExtensions, getSystem, getSystemByDbName, getSystemByKey, getSystemFromExtension, getSystemsList, getUserAvatarUrl, isSystemSupported, keyboardToRetroArchConfig, loadAllGamepadMappings, loadGamepadMapping, loadKeyboardMapping, normalizeSystemKey, saveGamepadMapping, saveKeyboardMapping, systemsMatch, useGameRecording, useGamepad, useNostalgist, useToast };