@enigma-lake/tower-play-controller-sdk 2.0.24 → 2.0.25

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import React, { createContext, useContext, useRef, useCallback, useEffect, useState, useMemo, Fragment as Fragment$1 } from 'react';
-import { Currency, sendSetUserCurrencyEvent, sendSetUserCurrencyEventV2, setToggleGameWidgetsVisibility, setToggleGameWidgetsExpansion, getUserInformationEvent, EVENTS, sendOpenHighPlayModalEvent, setTogglePlayAmountView } from '@enigma-lake/zoot-platform-sdk';
+import React, { createContext, useContext, useMemo, useRef, useEffect, useCallback, useState, Fragment as Fragment$1 } from 'react';
 import cx$1 from 'classnames';
-import { Menu, MenuButton, MenuItems, MenuItem, Switch as Switch$1 } from '@headlessui/react';
+import { createTranslator as createTranslator$1, DEFAULT_LANGUAGE, resolveLanguage, Currency, sendSetUserCurrencyEvent, sendSetUserCurrencyEventV2, setToggleGameWidgetsVisibility, setToggleGameWidgetsExpansion, getUserInformationEvent, EVENTS, sendOpenHighPlayModalEvent } from '@enigma-lake/zoot-platform-sdk';
+export { DEFAULT_LANGUAGE, SUPPORTED_LANGUAGES, SUPPORTED_LANGUAGE_CODES, resolveLanguage } from '@enigma-lake/zoot-platform-sdk';
+import { Menu, MenuButton, MenuItems, MenuItem, Switch as Switch$1, Dialog, DialogPanel, DialogTitle } from '@headlessui/react';
 
 const hexToRgb = (hex) => {
     const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
@@ -102,6 +103,23 @@ const createAutoplayButtonAction = ({ state, cashoutDisabled, onStopPlay, onPlay
     };
 };
 
+var SELECTORS;
+(function (SELECTORS) {
+    SELECTORS["RISK"] = "Risk";
+})(SELECTORS || (SELECTORS = {}));
+var RiskTypes;
+(function (RiskTypes) {
+    RiskTypes["LOW"] = "LOW";
+    RiskTypes["MEDIUM"] = "MEDIUM";
+    RiskTypes["HIGH"] = "HIGH";
+})(RiskTypes || (RiskTypes = {}));
+// standard controller palette (matches multi/plinko play-controller SDKs)
+const DEFAULT_RISK_COLORS = {
+    [RiskTypes.LOW]: "#1AE380",
+    [RiskTypes.MEDIUM]: "#FFC058",
+    [RiskTypes.HIGH]: "#FF5646",
+};
+
 const AutoManualPlayStateContext = createContext(undefined);
 const useAutoManualPlayState = () => {
     const context = useContext(AutoManualPlayStateContext);
@@ -111,6 +129,104 @@ const useAutoManualPlayState = () => {
     return context;
 };
 
+const en = {
+    playNow: "PLAY NOW",
+    playFreeRound: "PLAY FREE ROUND",
+    selectPlayAmount: "SELECT PLAY AMOUNT",
+    cashout: "CASHOUT",
+    collect: "COLLECT",
+    doubleTitle: "DOUBLE",
+    doubleSubtitle: "OR NOTHING",
+    startAutoplay: "START AUTOPLAY",
+    stopAutoplay: "STOP AUTOPLAY",
+    numberOfPlays: "Number of Plays",
+    selectPlayAmountAria: "Select play amount",
+    playAmountLabel: "Play amount",
+    autoLabel: "Auto",
+    selectTileToast: "Please select at least one tile to start autoplay.",
+    riskLabel: "Risk",
+    riskLow: "Low",
+    riskMedium: "Medium",
+    riskHigh: "High",
+    freeRoundLeftOne: "FREE ROUND LEFT",
+    freeRoundLeftOther: "FREE ROUNDS LEFT",
+    freeRoundsModalTitle: "Free Game Rounds",
+    freeRoundsHave: "You have",
+    freeRoundsUnitOne: "FREE GAME ROUND",
+    freeRoundsUnitOther: "FREE GAME ROUNDS",
+    freeRoundsPerRound: "{amount} per round",
+    freeRoundsExpiresIn: "Expires in {days} {unit}",
+    dayUnitOne: "day",
+    dayUnitOther: "days",
+    freeRoundsModalPlayNow: "Play now",
+    freeRoundsModalPlayLater: "Maybe later",
+    freeRoundsSummaryWon: "You won",
+    freeRoundsSummaryIn: "in",
+    freeRoundsSummaryUnitOne: "free game round",
+    freeRoundsSummaryUnitOther: "free game rounds",
+    freeRoundsSummaryCredited: "Winnings have been credited to your bonus balance.",
+    freeRoundsSummaryClose: "Close",
+};
+
+const zhCN = {
+    playNow: "立即游戏",
+    playFreeRound: "免费游戏",
+    selectPlayAmount: "选择下注金额",
+    cashout: "提现",
+    collect: "收取",
+    doubleTitle: "双倍",
+    doubleSubtitle: "或全无",
+    startAutoplay: "开始自动游戏",
+    stopAutoplay: "停止自动游戏",
+    numberOfPlays: "游戏次数",
+    selectPlayAmountAria: "选择下注金额",
+    playAmountLabel: "下注金额",
+    autoLabel: "自动",
+    selectTileToast: "请至少选择一个方块以开始自动游戏。",
+    riskLabel: "风险",
+    riskLow: "低",
+    riskMedium: "中",
+    riskHigh: "高",
+    freeRoundLeftOne: "剩余免费回合",
+    freeRoundLeftOther: "剩余免费回合",
+    freeRoundsModalTitle: "免费游戏回合",
+    freeRoundsHave: "您有",
+    freeRoundsUnitOne: "个免费游戏回合",
+    freeRoundsUnitOther: "个免费游戏回合",
+    freeRoundsPerRound: "每回合 {amount}",
+    freeRoundsExpiresIn: "{days} {unit}后到期",
+    dayUnitOne: "天",
+    dayUnitOther: "天",
+    freeRoundsModalPlayNow: "立即游戏",
+    freeRoundsModalPlayLater: "稍后再玩",
+    freeRoundsSummaryWon: "您赢得了",
+    freeRoundsSummaryIn: "，共",
+    freeRoundsSummaryUnitOne: "个免费游戏回合",
+    freeRoundsSummaryUnitOther: "个免费游戏回合",
+    freeRoundsSummaryCredited: "奖金已存入您的奖金余额。",
+    freeRoundsSummaryClose: "关闭",
+};
+
+const dictionaries = {
+    en,
+    "zh-CN": zhCN,
+};
+const createTranslator = (language) => createTranslator$1(dictionaries, language);
+
+const I18nContext = createContext(undefined);
+const I18nProvider = ({ language, children, }) => {
+    const value = useMemo(() => {
+        const resolved = resolveLanguage(language);
+        return { language: resolved, t: createTranslator(resolved) };
+    }, [language]);
+    return jsx(I18nContext.Provider, { value: value, children: children });
+};
+const DEFAULT_VALUE = {
+    language: DEFAULT_LANGUAGE,
+    t: createTranslator(DEFAULT_LANGUAGE),
+};
+const useTranslation = () => useContext(I18nContext) ?? DEFAULT_VALUE;
+
 const getNextPlayAmount = ({ currentAmount, defaultBetOptions, direction, }) => {
     if (!defaultBetOptions.length) {
         return currentAmount;
@@ -141,7 +257,8 @@ function isFullMode(config) {
     return config.withoutRiskAndAutoplay !== true;
 }
 const usePlayController = () => {
-    const { config, autoPlay: { setNumberOfPlays, numberOfPlays, setPlayedRounds, playedRounds, selection, setState, state, }, playValues: { displayPlayAmountView, setDisplayPlayAmountView, togglePlayAmountView, }, } = useAutoManualPlayState();
+    const { t } = useTranslation();
+    const { config, mode, autoPlay: { setNumberOfPlays, numberOfPlays, setPlayedRounds, playedRounds, selection, setState, state, }, playValues: { displayPlayAmountView, setDisplayPlayAmountView, togglePlayAmountView, }, } = useAutoManualPlayState();
     const { current } = config.currencyOptions;
     const { isPlaying, canCashout, disabledCashout = false, disabledController, playHook, totalBalance, } = config.playOptions;
     // --- Autoplay-related values only valid in full mode ---
@@ -152,11 +269,65 @@ const usePlayController = () => {
     const autoPlayDelay = autoplayEnabled
         ? (config.playOptions.autoPlayDelay ?? 1500)
         : 1500;
-    const { playAmount = 0, playLimits, setPlayAmount = () => { }, } = playHook?.() ?? {};
+    const { playAmount: rawPlayAmount = 0, playLimits, setPlayAmount: rawSetPlayAmount = () => { }, } = playHook?.() ?? {};
     const minPlayAmount = playLimits?.[current.code]?.limits.min ?? 0;
     const maxPlayAmount = playLimits?.[current.code]?.limits.max ?? 0;
+    // Free rounds (opt-in): only when the player has ENGAGED free-rounds mode
+    // (via the intro modal's PLAY NOW) are the per-round value/coin locked to
+    // the grant. When not engaged, the controller renders exactly as if the
+    // user had no free rounds. Engagement coexists with the cashout flow.
+    //
+    // By default engagement is MANUAL-mode only (free rounds are never engaged
+    // in auto-play mode). Games whose autoplay submission path funds rounds
+    // from engaged grants opt into engaged autoplay via
+    // `supportsGrantFundedAutoplay`, which drops the manual-mode requirement.
+    const isManualMode = mode === GAME_MODE.MANUAL;
+    const freeRoundsOptions = config.freeRoundsOptions;
+    const supportsGrantFundedAutoplay = Boolean(freeRoundsOptions?.supportsGrantFundedAutoplay);
+    const isFreeRoundsEngaged = Boolean((isManualMode || supportsGrantFundedAutoplay) &&
+        freeRoundsOptions?.engaged &&
+        freeRoundsOptions.roundsRemaining > 0);
+    // playAmount is in display units everywhere in this SDK (e.g. 1.00), while the
+    // grant stake is in cents, so convert. When engaged, setPlayAmount is a no-op
+    // (the stake is locked to the grant).
+    const playAmount = isFreeRoundsEngaged
+        ? freeRoundsOptions.stakeCents /
+            100
+        : rawPlayAmount;
+    const setPlayAmount = isFreeRoundsEngaged
+        ? () => {
+            // locked to the free-round grant stake (no-op setter)
+        }
+        : rawSetPlayAmount;
     const playIntervalRef = useRef(null);
     const isAutoplayActiveRef = useRef(false);
+    // Each setTimeout tick invokes the `loopRounds` closure from the render that
+    // scheduled it, so reading `config.freeRoundsOptions` there can see a stale,
+    // pre-engagement value. Keep the latest free-rounds state in a ref
+    // (refreshed every render) so the loop's hard-stop checks always see live
+    // values — a grant engaged mid-loop still hard-stops paid autoplay, and an
+    // engaged grant-funded loop sees the live remaining count.
+    const freeRoundsLiveRef = useRef({
+        engaged: false,
+        remaining: 0,
+        supportsGrantFundedAutoplay: false,
+    });
+    freeRoundsLiveRef.current = {
+        engaged: Boolean(config.freeRoundsOptions?.engaged),
+        remaining: config.freeRoundsOptions?.roundsRemaining ?? 0,
+        supportsGrantFundedAutoplay,
+    };
+    // Per-session accounting for engaged (grant-funded) autoplay.
+    // roundsRemaining is game-driven and only decrements via an async refetch
+    // AFTER each settlement, so the live ref can still read stale-high when the
+    // loop schedules the next round. We therefore also count submissions
+    // locally: a session that started engaged may never submit more rounds than
+    // the grants available when it started, regardless of refetch timing.
+    const autoplaySessionRef = useRef({
+        startedEngaged: false,
+        grantsAtStart: 0,
+        roundsSubmitted: 0,
+    });
     const stopAutoplay = () => {
         isAutoplayActiveRef.current = false;
         if (playIntervalRef.current) {
@@ -176,6 +347,35 @@ const usePlayController = () => {
         if (!isAutoplayActiveRef.current || !autoplayEnabled) {
             return;
         }
+        // Free-rounds gates — all live values come from refs (closures here are
+        // stale across rounds).
+        const live = freeRoundsLiveRef.current;
+        const session = autoplaySessionRef.current;
+        if (!live.supportsGrantFundedAutoplay) {
+            // Legacy (flag absent/false): tower free rounds are MANUAL-only — there
+            // is no free autoplay. If a grant is engaged (or becomes engaged) while
+            // an autoplay loop is live, hard-stop instead of letting PAID autoplay
+            // run alongside the grant.
+            if (live.engaged) {
+                stopAutoplay();
+                return;
+            }
+        }
+        else if (session.startedEngaged) {
+            // Grant-funded autoplay: an autoplay session that started on free
+            // rounds ends the moment the grants are exhausted or engagement ends
+            // mid-session — it must never submit a paid round. Checked BEFORE each
+            // submission so the round that consumes the last grant completes
+            // normally, then the loop halts via the normal stop path. Uses the
+            // local per-session submission count as well because the game's
+            // roundsRemaining refetch can lag behind the next scheduled round.
+            const grantsExhausted = session.roundsSubmitted >= session.grantsAtStart || live.remaining <= 0;
+            if (grantsExhausted || !live.engaged) {
+                setNumberOfPlays(AUTOPLAY_DEFAULT_PLAY_ROUNDS_COUNT);
+                stopAutoplay();
+                return;
+            }
+        }
         if (remainingPlays < 1 || numberOfPlays === 0) {
             setNumberOfPlays(AUTOPLAY_DEFAULT_PLAY_ROUNDS_COUNT);
             stopAutoplay();
@@ -183,6 +383,7 @@ const usePlayController = () => {
         }
         setPlayedRounds(currentPlayedRounds + 1);
         setNumberOfPlays((prev) => Math.max(prev - 1, 0));
+        session.roundsSubmitted += 1;
         // onAutoPlay exists only in full mode (guarded by autoplayEnabled)
         config.onAutoPlay(selection, () => {
             if (!isAutoplayActiveRef.current) {
@@ -200,13 +401,32 @@ const usePlayController = () => {
         if (selection.length === 0) {
             showAutoPlayToast?.({
                 type: "info",
-                message: "Please select at least one tile to start autoplay.",
+                message: t("selectTileToast"),
             });
             return;
         }
+        // Grant-funded autoplay: the effective play count is clamped to the
+        // remaining grants so autoplay can never spill into paid rounds (and an
+        // infinite/over-cap count stops at roundsRemaining). The game client
+        // enforces actual per-round grant consumption; this is the UI cap.
+        const effectiveNumberOfPlays = supportsGrantFundedAutoplay && isFreeRoundsEngaged
+            ? Math.min(numberOfPlays, freeRoundsOptions?.roundsRemaining ?? 0)
+            : numberOfPlays;
+        if (effectiveNumberOfPlays !== numberOfPlays) {
+            setNumberOfPlays(effectiveNumberOfPlays);
+        }
+        // Snapshot the free-rounds state for this session. Uses the RAW engaged
+        // flag (not isFreeRoundsEngaged, which also requires remaining > 0) so a
+        // session started while engaged with 0 grants fails closed on the first
+        // loop iteration instead of silently becoming a paid session.
+        autoplaySessionRef.current = {
+            startedEngaged: Boolean(freeRoundsOptions?.engaged),
+            grantsAtStart: freeRoundsOptions?.roundsRemaining ?? 0,
+            roundsSubmitted: 0,
+        };
         isAutoplayActiveRef.current = true;
         setState(AUTO_PLAY_STATE.PLAYING);
-        loopRounds(playedRounds, numberOfPlays);
+        loopRounds(playedRounds, effectiveNumberOfPlays);
     };
     const adjustPlayAmount = ({ direction }) => {
         if (isDisabled()) {
@@ -229,7 +449,8 @@ const usePlayController = () => {
         }
         setPlayAmount(playValue);
     };
-    const isValidPlayAmount = playAmount >= minPlayAmount && playAmount <= maxPlayAmount;
+    const isValidPlayAmount = isFreeRoundsEngaged ||
+        (playAmount >= minPlayAmount && playAmount <= maxPlayAmount);
     return {
         // amounts
         playAmount,
@@ -263,6 +484,16 @@ const usePlayController = () => {
             setDisplayPlayAmountView,
             togglePlayAmountView,
         },
+        // free rounds (binary engagement via the intro modal; manual-mode only
+        // unless the game opts into grant-funded autoplay)
+        freeRounds: {
+            isEngaged: isFreeRoundsEngaged,
+            roundsRemaining: freeRoundsOptions?.roundsRemaining ?? 0,
+            totalRounds: freeRoundsOptions?.totalRounds ?? 0,
+            stakeCents: freeRoundsOptions?.stakeCents ?? 0,
+            coinType: freeRoundsOptions?.coinType,
+            currency: freeRoundsOptions?.currency,
+        },
     };
 };
 
@@ -280,10 +511,12 @@ const Button = ({ disabled, roleType, className = "", theme = "primary", ...prop
 };
 Button.themes = themes;
 
-var styles_group = {"base":"GroupRow-module__base___b241-","label":"GroupRow-module__label___Du57P","group":"GroupRow-module__group___V7xa6","groupItem":"GroupRow-module__groupItem___yNSX8","refreshButton":"GroupRow-module__refreshButton___m61F8","x2":"GroupRow-module__x2___9bLae","last":"GroupRow-module__last___ArsSn"};
+var styles_group = {"base":"GroupRow-module__base___b241-","label":"GroupRow-module__label___Du57P","group":"GroupRow-module__group___V7xa6","groupItem":"GroupRow-module__groupItem___yNSX8","refreshButton":"GroupRow-module__refreshButton___m61F8","x2":"GroupRow-module__x2___9bLae","last":"GroupRow-module__last___ArsSn","isClassicGame":"GroupRow-module__isClassicGame___m9r03"};
 
-const GroupRow = ({ children, label, className, ...restProps }) => {
-    return (jsxs("div", { ...restProps, className: cx$1(styles_group.base, className), children: [label && jsx("div", { className: styles_group.label, children: label }), jsx("div", { className: styles_group.group, children: children })] }));
+const GroupRow = ({ children, label, className, isClassicGame = false, ...restProps }) => {
+    return (jsxs("div", { ...restProps, className: cx$1(styles_group.base, className, {
+            [styles_group.isClassicGame]: isClassicGame,
+        }), children: [label && jsx("div", { className: styles_group.label, children: label }), jsx("div", { className: styles_group.group, children: children })] }));
 };
 
 var style_select$1 = {"button":"SelectMenu-module__button___N-HeB","menu":"SelectMenu-module__menu___c5jvZ","menuItems":"SelectMenu-module__menuItems___BX1YQ","menuItem":"SelectMenu-module__menuItem___eXbi3","selected":"SelectMenu-module__selected___XyADw","disabledSVG":"SelectMenu-module__disabledSVG___OdVFW","disabled":"SelectMenu-module__disabled___jiTPl"};
@@ -315,6 +548,15 @@ const getIcon = (option) => {
 const SelectMenu = ({ disabled = false }) => {
     const { config } = useAutoManualPlayState();
     const { current, available } = config.currencyOptions;
+    useEffect(() => {
+        const hex = config?.classicGame?.dropdown?.bgColorHex ??
+            config?.dropdown?.bgColorHex ??
+            "#01243A";
+        const v = hexToRgb(hex);
+        if (v) {
+            document.documentElement.style.setProperty("--play-dropdown-bg", v);
+        }
+    }, [config?.classicGame?.dropdown?.bgColorHex, config?.dropdown?.bgColorHex]);
     const handleClick = (e) => {
         if (disabled) {
             return;
@@ -344,39 +586,117 @@ const SelectMenu = ({ disabled = false }) => {
                     }) })] })) }));
 };
 
-var styles$4 = {"base":"PlayValueInput-module__base___sTNW2","icon":"PlayValueInput-module__icon___jZj7O","playValueInput":"PlayValueInput-module__playValueInput___7pJtn","playValueInputWithLabel":"PlayValueInput-module__playValueInputWithLabel___S55Cr","label":"PlayValueInput-module__label___1ZSAV","inputContainer":"PlayValueInput-module__inputContainer___RKr1l","playValueWithLabel":"PlayValueInput-module__playValueWithLabel___K4-pr"};
+var styles$6 = {"base":"PlayValueInput-module__base___sTNW2","icon":"PlayValueInput-module__icon___jZj7O","playValueInput":"PlayValueInput-module__playValueInput___7pJtn","playValueInputWithLabel":"PlayValueInput-module__playValueInputWithLabel___S55Cr","label":"PlayValueInput-module__label___1ZSAV","inputContainer":"PlayValueInput-module__inputContainer___RKr1l","playValueWithLabel":"PlayValueInput-module__playValueWithLabel___K4-pr","isClassicGame":"PlayValueInput-module__isClassicGame___lQzVE"};
 
-const PlayValueInput = ({ disabled, children, className, value, onClick, }) => {
+const PlayValueInput = ({ disabled, children, className, value, onClick, isClassicGame = false, }) => {
+    const { t } = useTranslation();
     const handleOnClick = () => {
         if (disabled) {
             return;
         }
         onClick();
     };
-    return (jsxs("div", { className: cx$1(styles$4.base, className, {
-            [styles$4.disabled]: disabled,
-        }), children: [children && jsx("div", { className: cx$1(styles$4.icon), children: children }), jsxs("div", { className: cx$1(styles$4.inputContainer), onClick: (e) => {
+    return (jsxs("div", { className: cx$1(styles$6.base, className, {
+            [styles$6.disabled]: disabled,
+            [styles$6.isClassicGame]: isClassicGame,
+        }), children: [children && jsx("div", { className: cx$1(styles$6.icon), children: children }), jsxs("div", { className: cx$1(styles$6.inputContainer), onClick: (e) => {
                     e.preventDefault();
                     handleOnClick();
-                }, children: [jsx("span", { className: styles$4.label, children: "Play amount" }), jsx("div", { className: cx$1(styles$4.playValueInput, {
-                            [styles$4.playValueInputWithLabel]: true,
+                }, children: [jsx("span", { className: styles$6.label, children: t("playAmountLabel") }), jsx("div", { className: cx$1(styles$6.playValueInput, {
+                            [styles$6.playValueInputWithLabel]: true,
                         }), children: value })] })] }));
 };
 
-const PlayAmountControl = ({ isDisabled, forceRefresh, }) => {
+const COIN_TYPE_SWEEPS = 0;
+const COIN_TYPE_GOLD = 1;
+// B2C coin decimals (platform convention): Sweeps shows 2 dp, Gold 0 dp.
+const COIN_DECIMALS = {
+    [COIN_TYPE_SWEEPS]: 2,
+    [COIN_TYPE_GOLD]: 0,
+};
+const resolveFreeRoundsCoinLabel = ({ coinType, currency, }) => {
+    if (currency) {
+        return currency;
+    }
+    if (coinType === COIN_TYPE_SWEEPS) {
+        return "SC";
+    }
+    if (coinType === COIN_TYPE_GOLD) {
+        return "GC";
+    }
+    return "";
+};
+// The per-round value belongs to the GRANT's coin, which can differ from the
+// player's active currency (e.g. a Sweeps grant surfaced while the player is
+// on Gold). Use the grant coin's decimals so a 0.20 SC value doesn't render as
+// "0" under Gold's 0-dp formatting. B2B grants (operator `currency`) fall back
+// to the operator currency decimals passed in via `fallback`.
+const resolveFreeRoundsDecimals = ({ coinType, currency, fallback, }) => {
+    if (!currency && coinType !== undefined && coinType in COIN_DECIMALS) {
+        return COIN_DECIMALS[coinType];
+    }
+    return fallback;
+};
+// Resolves display decimals from a coin/currency LABEL (cross-SDK standard):
+// SC/SWEEPS = 2, GC/GOLD = 0, B2B operator currency strings = 2.
+const resolveCoinLabelDecimals = (coin) => {
+    const normalized = coin.trim().toUpperCase();
+    if (normalized === "GC" || normalized === "GOLD") {
+        return 0;
+    }
+    return 2;
+};
+const MS_PER_DAY = 86_400_000;
+// Computes the whole-day countdown for "*Expires in {N} days". Rounds UP so a
+// grant expiring in 36 hours reads "2 days" (it is still claimable on day 2).
+// Returns null when the input is missing/invalid or already expired.
+const computeExpiresInDays = (expiresAt, now = Date.now()) => {
+    if (expiresAt === null || expiresAt === undefined) {
+        return null;
+    }
+    const expiryMs = new Date(expiresAt).getTime();
+    if (Number.isNaN(expiryMs)) {
+        return null;
+    }
+    const remainingMs = expiryMs - now;
+    if (remainingMs <= 0) {
+        return null;
+    }
+    return Math.ceil(remainingMs / MS_PER_DAY);
+};
+
+const PlayAmountControl = ({ isDisabled, forceRefresh, lockCurrency = false, }) => {
     const { config } = useAutoManualPlayState();
-    const { playAmount, adjustPlayAmount, playValues: { togglePlayAmountView }, autoPlay: { state }, } = usePlayController();
+    const { playAmount, adjustPlayAmount, playValues: { togglePlayAmountView }, autoPlay: { state }, freeRounds, } = usePlayController();
+    const isClassicGame = Boolean(config.isClassicGame || config.classicGame?.forceLeftStyle);
+    // While a free-rounds grant is engaged, the input is locked to the GRANT's
+    // per-round value and coin (which can differ from the active currency), so
+    // the locked amount is always truthful.
+    const { current } = config.currencyOptions;
+    const grantCoinLabel = resolveFreeRoundsCoinLabel({
+        coinType: freeRounds.coinType,
+        currency: freeRounds.currency,
+    });
+    const valueDecimals = freeRounds.isEngaged
+        ? resolveFreeRoundsDecimals({
+            coinType: freeRounds.coinType,
+            currency: freeRounds.currency,
+            fallback: current.decimals,
+        })
+        : current.decimals;
+    const coinLabel = freeRounds.isEngaged && grantCoinLabel ? grantCoinLabel : current.abbr;
     const handleTogglePlayAmount = () => {
         setToggleGameWidgetsVisibility();
         togglePlayAmountView();
         setToggleGameWidgetsExpansion();
     };
-    return (jsxs(GroupRow, { children: [jsx(PlayValueInput, { className: styles_group.groupItem, value: `${format(playAmount, config.currencyOptions.current.decimals)} ${config.currencyOptions.current.abbr}`, disabled: isDisabled() ||
+    return (jsxs(GroupRow, { isClassicGame: isClassicGame, children: [jsx(PlayValueInput, { className: styles_group.groupItem, value: `${format(playAmount, valueDecimals)} ${coinLabel}`, disabled: isDisabled() ||
                     config.playOptions.disableInput ||
                     config.playOptions.disabledController ||
-                    state === AUTO_PLAY_STATE.PLAYING, onClick: handleTogglePlayAmount, children: jsx(SelectMenu, { disabled: isDisabled() }) }), jsx(Button, { className: styles_group.groupItem, onClick: () => adjustPlayAmount({ direction: -1 }), theme: "ghost", disabled: isDisabled(), children: jsx("span", { className: styles_group.x2, children: "-" }) }), jsx(Button, { className: styles_group.refreshButton, onClick: () => {
+                    state === AUTO_PLAY_STATE.PLAYING ||
+                    lockCurrency, onClick: handleTogglePlayAmount, isClassicGame: isClassicGame, children: jsx(SelectMenu, { disabled: isDisabled() || lockCurrency }) }), jsx(Button, { className: styles_group.groupItem, onClick: () => adjustPlayAmount({ direction: -1 }), theme: "ghost", disabled: isDisabled() || lockCurrency, children: jsx("span", { className: styles_group.x2, children: "-" }) }), jsx(Button, { className: styles_group.refreshButton, onClick: () => {
                     forceRefresh();
-                }, "data-button-refresh": true, children: jsx("span", { className: cx$1(styles_group.x2, styles_group.first) }) }), jsx(Button, { className: styles_group.groupItem, onClick: () => adjustPlayAmount({ direction: 1 }), theme: "ghost", disabled: isDisabled(), children: jsx("span", { className: cx$1(styles_group.x2, styles_group.last), children: "+" }) })] }));
+                }, "data-button-refresh": true, children: jsx("span", { className: cx$1(styles_group.x2, styles_group.first) }) }), jsx(Button, { className: styles_group.groupItem, onClick: () => adjustPlayAmount({ direction: 1 }), theme: "ghost", disabled: isDisabled() || lockCurrency, children: jsx("span", { className: cx$1(styles_group.x2, styles_group.last), children: "+" }) })] }));
 };
 
 const getDefaultButtonClassName = (currencyCode, styles) => {
@@ -398,38 +718,56 @@ const getActiveButtonClassName = (currencyCode, styles) => {
     return styles.buttonDefault__active;
 };
 
-var AUTOPLAY_LABEL;
-(function (AUTOPLAY_LABEL) {
-    AUTOPLAY_LABEL["START"] = "START AUTOPLAY";
-    AUTOPLAY_LABEL["STOP"] = "STOP AUTOPLAY";
-})(AUTOPLAY_LABEL || (AUTOPLAY_LABEL = {}));
-
-const useSpacebarButtonTrigger = ({ roleButton, activeClassName, canTrigger, }) => {
+// Space activates buttons/links natively. If the user has keyboard focus on a
+// different interactive control (the intro modal's PLAY NOW / PLAY LATER
+// buttons, etc.), let Space activate THAT control instead of hijacking it to
+// click the play button — otherwise a paid play can fire while the user is
+// trying to engage free rounds.
+const isOtherInteractiveControlFocused = (button) => {
+    const active = document.activeElement;
+    return Boolean(active &&
+        active !== button &&
+        typeof active.matches === "function" &&
+        active.matches("button, a, input, select, textarea"));
+};
+const useSpacebarButtonTrigger = ({ roleButton, activeClassName, canTrigger, suppressed = false, }) => {
     const handleKeyPress = useCallback((event) => {
         if (event.code !== "Space") {
             return;
         }
+        if (suppressed) {
+            return;
+        }
         const button = selectButton(roleButton);
         if (!button || !canTrigger()) {
             return;
         }
+        if (isOtherInteractiveControlFocused(button)) {
+            return;
+        }
         event.preventDefault();
         event.stopPropagation();
         addPressedClass(roleButton, activeClassName);
         button.click();
-    }, [activeClassName, canTrigger, roleButton]);
+    }, [activeClassName, canTrigger, roleButton, suppressed]);
     const handleKeyUp = useCallback((event) => {
         if (event.code !== "Space") {
             return;
         }
+        if (suppressed) {
+            return;
+        }
         const button = selectButton(roleButton);
         if (!button) {
             return;
         }
+        if (isOtherInteractiveControlFocused(button)) {
+            return;
+        }
         event.preventDefault();
         event.stopPropagation();
         removePressedClass(roleButton, activeClassName);
-    }, [activeClassName, roleButton]);
+    }, [activeClassName, roleButton, suppressed]);
     useEffect(() => {
         window.addEventListener("keydown", handleKeyPress, true);
         window.addEventListener("keyup", handleKeyUp, true);
@@ -442,20 +780,29 @@ const useSpacebarButtonTrigger = ({ roleButton, activeClassName, canTrigger, })
 
 const AutoPlayController = () => {
     const { config } = useAutoManualPlayState();
+    const { t } = useTranslation();
     const [forceRefresh, setForceRefresh] = useState(false);
-    const { isValidPlayAmount, playValues: { displayPlayAmountView, togglePlayAmountView }, autoPlay: { isDisabled, state, onPlay, onStopPlay, cashoutDisabled }, } = usePlayController();
+    const { isValidPlayAmount, freeRounds, playValues: { displayPlayAmountView, togglePlayAmountView }, autoPlay: { isDisabled, state, onPlay, onStopPlay, cashoutDisabled }, } = usePlayController();
     const { current } = config.currencyOptions;
     const roleButton = GAME_MODE.AUTOPLAY;
-    const buttonLabel = state === AUTO_PLAY_STATE.PLAYING
-        ? AUTOPLAY_LABEL.STOP
-        : AUTOPLAY_LABEL.START;
+    const isStopState = state === AUTO_PLAY_STATE.PLAYING;
+    // Free-rounds engaged (grant-funded autoplay): the STOP control shows the
+    // live remaining grant count so the player sees the rounds tick down.
+    let buttonLabel = isStopState
+        ? t("stopAutoplay")
+        : t("startAutoplay");
+    if (isStopState && freeRounds.isEngaged) {
+        buttonLabel = `${t("stopAutoplay")} (${freeRounds.roundsRemaining})`;
+    }
     const activeClassName = getActiveButtonClassName(current.code, styles_button);
+    // Cashout styling keys off the PLAYING state (not the label text) so the
+    // engaged "(N)" label suffix can never break the style comparison.
     const defaultClassName = useMemo(() => {
-        if (buttonLabel === AUTOPLAY_LABEL.STOP) {
+        if (isStopState) {
             return styles_button.buttonCashout;
         }
         return getDefaultButtonClassName(current.code, styles_button);
-    }, [buttonLabel, current.code]);
+    }, [isStopState, current.code]);
     useSpacebarButtonTrigger({
         roleButton,
         activeClassName,
@@ -464,6 +811,10 @@ const AutoPlayController = () => {
             cashoutDisabled,
             isDisabled: isDisabled(),
         }),
+        // Suppress the global Space shortcut while the free-rounds intro modal is
+        // open so Space belongs to the modal's PLAY NOW / PLAY LATER buttons
+        // instead of starting/stopping the autoplay mounted behind it.
+        suppressed: Boolean(config.freeRoundsOptions?.showIntroModal),
     });
     const isButtonDisabled = isAutoplayButtonDisabled({
         state,
@@ -488,7 +839,7 @@ const AutoPlayController = () => {
     }, [togglePlayAmountView]);
     const renderButton = useMemo(() => {
         if (displayPlayAmountView) {
-            return (jsx(Button, { className: styles_button.buttonPlayAmount, onClick: handleTogglePlayAmount, roleType: roleButton, children: "SELECT PLAY AMOUNT" }));
+            return (jsx(Button, { className: styles_button.buttonPlayAmount, onClick: handleTogglePlayAmount, roleType: roleButton, children: t("selectPlayAmount") }));
         }
         return (jsx(Button, { disabled: isButtonDisabled, className: defaultClassName, onClick: buttonAction, roleType: roleButton, children: buttonLabel }));
     }, [
@@ -499,6 +850,7 @@ const AutoPlayController = () => {
         handleTogglePlayAmount,
         isButtonDisabled,
         roleButton,
+        t,
     ]);
     return (jsxs(Fragment, { children: [jsx(PlayAmountControl, { isDisabled: isDisabled, forceRefresh: () => setForceRefresh(!forceRefresh), "data-force-refresh": `mini-play-amount-control-data-${forceRefresh.toString()}` }, `mini-play-amount-control-key-${forceRefresh.toString()}`), renderButton] }));
 };
@@ -527,9 +879,10 @@ const useIsRunningExternal = () => {
 
 const ManualPlayController = () => {
     const { config, doubleOrNothing } = useAutoManualPlayState();
+    const { t } = useTranslation();
     const { isRunningExternal } = useIsRunningExternal();
     const [forceRefresh, setForceRefresh] = useState(false);
-    const { isValidPlayAmount, playValues: { displayPlayAmountView, togglePlayAmountView }, manualPlay: { isDisabled, onPlay, canCashout, cashoutDisabled }, } = usePlayController();
+    const { isValidPlayAmount, playValues: { displayPlayAmountView, togglePlayAmountView }, manualPlay: { isDisabled, onPlay, canCashout, cashoutDisabled }, freeRounds, } = usePlayController();
     const { current } = config.currencyOptions;
     const roleButton = GAME_MODE.MANUAL;
     const activeClassName = getActiveButtonClassName(current.code, styles_button);
@@ -538,6 +891,10 @@ const ManualPlayController = () => {
         roleButton,
         activeClassName,
         canTrigger: () => !isDisabled(),
+        // Suppress the global Space-to-play shortcut while the free-rounds intro
+        // modal is open so Space belongs to the modal's PLAY NOW / PLAY LATER
+        // buttons instead of firing a paid play behind it.
+        suppressed: Boolean(config.freeRoundsOptions?.showIntroModal),
     });
     const isButtonDisabled = isDisabled() || !isValidPlayAmount;
     const handleTogglePlayAmount = useCallback(() => {
@@ -572,7 +929,7 @@ const ManualPlayController = () => {
     }), [cashoutDisabled, config.onCashout]);
     const renderButton = useMemo(() => {
         if (displayPlayAmountView) {
-            return (jsx(Button, { className: styles_button.buttonPlayAmount, onClick: handleTogglePlayAmount, roleType: roleButton, children: "SELECT PLAY AMOUNT" }));
+            return (jsx(Button, { className: styles_button.buttonPlayAmount, onClick: handleTogglePlayAmount, roleType: roleButton, children: t("selectPlayAmount") }));
         }
         if (canCashout) {
             const isCashoutDisabled = isManualCashoutDisabled({
@@ -586,16 +943,29 @@ const ManualPlayController = () => {
                 doubleOrNothing.state === DOUBLE_OR_NOTHING_STATE.PROGRESS;
             return (jsxs("div", { className: styles_button.buttonRow, children: [jsxs(Button, { disabled: isCashoutDisabled, className: cx$1(styles_button.buttonCashout, {
                             [styles_button.buttonRow__cashout]: showDoubleOrNothing,
-                        }), onClick: handleCashoutClick, roleType: roleButton, children: [isRunningExternal ? "COLLECT" : "CASHOUT", " ", format(current.possibleWin ?? 0, current.decimals), " ", current.abbr] }), showDoubleOrNothing ? (jsx(Button, { disabled: isDoubleOrNothingDisabled, className: cx$1(styles_button.buttonDON, styles_button.buttonRow__don, {
+                        }), onClick: handleCashoutClick, roleType: roleButton, children: [isRunningExternal ? t("collect") : t("cashout"), " ", format(current.possibleWin ?? 0, current.decimals), " ", current.abbr] }), showDoubleOrNothing ? (jsx(Button, { disabled: isDoubleOrNothingDisabled, className: cx$1(styles_button.buttonDON, styles_button.buttonRow__don, {
                             [styles_button.buttonDON__disabled]: isDoubleOrNothingDisabled,
-                        }), onClick: handleDoubleOrNothingClick, roleType: roleButton, children: jsxs("div", { className: styles_button.buttonDON__content, children: [jsx("p", { className: styles_button.buttonDON__title, children: "DOUBLE" }), jsx("p", { className: styles_button.buttonDON__subtitle, children: "OR NOTHING" })] }) })) : null] }));
+                        }), onClick: handleDoubleOrNothingClick, roleType: roleButton, children: jsxs("div", { className: styles_button.buttonDON__content, children: [jsx("p", { className: styles_button.buttonDON__title, children: t("doubleTitle") }), jsx("p", { className: styles_button.buttonDON__subtitle, children: t("doubleSubtitle") })] }) })) : null] }));
+        }
+        // While a game-driven autoplay loop is running, the game's stop-autoplay
+        // control is the only action — don't stack the manual play CTA behind it.
+        // The play amount, widgets and free-rounds footer stay as-is.
+        if (config.freeRoundsOptions?.autoplayActive) {
+            return null;
         }
-        return (jsx(Button, { disabled: isButtonDisabled, className: defaultClassName, onClick: onPlay, roleType: roleButton, children: "PLAY NOW" }));
+        // Free rounds reuse the play button label while ENGAGED — it becomes
+        // "PLAY FREE ROUND" (no count; the remaining count lives ONLY in the
+        // "{N} FREE ROUNDS LEFT" footer).
+        const playNowText = freeRounds.isEngaged
+            ? t("playFreeRound")
+            : t("playNow");
+        return (jsx(Button, { disabled: isButtonDisabled, className: defaultClassName, onClick: onPlay, roleType: roleButton, children: playNowText }));
     }, [
         canCashout,
         cashoutDisabled,
         config.doubleOrNothing?.disabled,
         config.doubleOrNothing?.display,
+        config.freeRoundsOptions?.autoplayActive,
         config.playOptions.disabledController,
         config.playOptions.isPlaying,
         current.abbr,
@@ -604,6 +974,7 @@ const ManualPlayController = () => {
         defaultClassName,
         displayPlayAmountView,
         doubleOrNothing.state,
+        freeRounds.isEngaged,
         handleDoubleOrNothingClick,
         handleCashoutClick,
         handleTogglePlayAmount,
@@ -611,18 +982,20 @@ const ManualPlayController = () => {
         isRunningExternal,
         onPlay,
         roleButton,
+        t,
     ]);
-    return (jsxs(Fragment, { children: [jsx(PlayAmountControl, { isDisabled: isDisabled || displayPlayAmountView, forceRefresh: () => setForceRefresh(!forceRefresh), "data-force-refresh": `mini-play-amount-control-data-${forceRefresh.toString()}` }, `mini-play-amount-control-key-${forceRefresh.toString()}`), renderButton] }));
+    return (jsxs(Fragment, { children: [jsx(PlayAmountControl, { isDisabled: isDisabled || displayPlayAmountView, lockCurrency: freeRounds.isEngaged, forceRefresh: () => setForceRefresh(!forceRefresh), "data-force-refresh": `mini-play-amount-control-data-${forceRefresh.toString()}` }, `mini-play-amount-control-key-${forceRefresh.toString()}`), renderButton] }));
 };
 
-var styles_ui = {"base":"UI-module__base___wThyQ","container":"UI-module__container___gMSiK","betForm":"UI-module__betForm___hQkYd","disabled":"UI-module__disabled___dnZJX","auto":"UI-module__auto___5peb8","controllerWidgets":"UI-module__controllerWidgets___x2lBy","sideWidget":"UI-module__sideWidget___WMGRy","centerWidget":"UI-module__centerWidget___sLLUi","left":"UI-module__left___1wtUp","center":"UI-module__center___E0ILH","right":"UI-module__right___yLHvk"};
+var styles_ui = {"base":"UI-module__base___wThyQ","container":"UI-module__container___gMSiK","betForm":"UI-module__betForm___hQkYd","isClassicGame":"UI-module__isClassicGame___zV1we","baseForceLeft":"UI-module__baseForceLeft___xfc-h","containerSpread":"UI-module__containerSpread___Axb7e","disabled":"UI-module__disabled___dnZJX","auto":"UI-module__auto___5peb8","freeRoundsFooter":"UI-module__freeRoundsFooter___AOprS","freeRoundsFooterCount":"UI-module__freeRoundsFooterCount___eaTrs","controllerWidgets":"UI-module__controllerWidgets___x2lBy","sideWidget":"UI-module__sideWidget___WMGRy","centerWidget":"UI-module__centerWidget___sLLUi","left":"UI-module__left___1wtUp","center":"UI-module__center___E0ILH","right":"UI-module__right___yLHvk","controls":"UI-module__controls___Z6L-V","inActiveRound":"UI-module__inActiveRound___HYAx2"};
 
 var style_difficulty = {"base":"DifficultySelector-module__base___lDaQ-"};
 
-var style_select = {"base":"Selector-module__base___-q0yf","label":"Selector-module__label___JJdbd","button":"Selector-module__button___MeRoC","menu":"Selector-module__menu___P0ROg","menuItems":"Selector-module__menuItems___chFk2","menuItem":"Selector-module__menuItem___isa4c","selected":"Selector-module__selected___nUJtR","disabled":"Selector-module__disabled___f1qGJ"};
+var style_select = {"base":"Selector-module__base___-q0yf","label":"Selector-module__label___JJdbd","button":"Selector-module__button___MeRoC","menu":"Selector-module__menu___P0ROg","menuItems":"Selector-module__menuItems___chFk2","menuItem":"Selector-module__menuItem___isa4c","selected":"Selector-module__selected___nUJtR","disabled":"Selector-module__disabled___f1qGJ","disabledClassic":"Selector-module__disabledClassic___baiGO"};
 
 const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-const Selector = ({ currentValue, label, riskColor, values, onSelect, disabled, }) => {
+const Selector = ({ currentValue, label, riskColor, values, onSelect, disabled, isClassicGame = false, formatDisplay, }) => {
+    const display = (value) => formatDisplay ? formatDisplay(value) : capitalize(String(value));
     const handleClick = (e) => {
         if (disabled) {
             return;
@@ -635,31 +1008,28 @@ const Selector = ({ currentValue, label, riskColor, values, onSelect, disabled,
         onSelect(value);
     };
     return (jsxs("div", { className: cx$1(style_select.base), children: [label && jsx("span", { className: cx$1(style_select.label), children: label }), jsx(Menu, { as: "div", className: cx$1(style_select.menu), children: ({ open }) => (jsxs(Fragment, { children: [jsxs(MenuButton, { className: cx$1(style_select.button, {
-                                [style_select.disabled]: disabled,
-                            }), style: { color: riskColor }, disabled: disabled, "data-difficulty-selector-button": true, children: [capitalize(String(currentValue)), jsx(ChevronIcon, { open: open, disabled: disabled })] }), jsx(MenuItems, { anchor: { to: "top start" }, className: cx$1(style_select.menuItems), children: values.map((value) => (jsx(MenuItem, { as: "div", "data-value": value, onClick: handleClick, className: cx$1(style_select.menuItem, {
+                                [style_select.disabled]: disabled && !isClassicGame,
+                                [style_select.disabledClassic]: disabled && isClassicGame,
+                            }), style: { color: riskColor }, disabled: disabled, "data-difficulty-selector-button": true, children: [display(currentValue), jsx(ChevronIcon, { open: open, disabled: disabled })] }), jsx(MenuItems, { anchor: { to: "top start" }, className: cx$1(style_select.menuItems), children: values.map((value) => (jsx(MenuItem, { as: "div", "data-value": value, onClick: handleClick, className: cx$1(style_select.menuItem, {
                                     [style_select.selected]: String(currentValue) === String(value),
-                                }), children: capitalize(String(value)) }, `element-${value}`))) })] })) })] }));
+                                }), children: display(value) }, `element-${value}`))) })] })) })] }));
 };
 
-var SELECTORS;
-(function (SELECTORS) {
-    SELECTORS["RISK"] = "Risk";
-})(SELECTORS || (SELECTORS = {}));
-var RiskTypes;
-(function (RiskTypes) {
-    RiskTypes["LOW"] = "LOW";
-    RiskTypes["MEDIUM"] = "MEDIUM";
-    RiskTypes["HIGH"] = "HIGH";
-})(RiskTypes || (RiskTypes = {}));
-
-const DifficultySelector = ({ playOptions, dropdownConfig, }) => {
+const RISK_LABEL_KEY = {
+    [RiskTypes.LOW]: "riskLow",
+    [RiskTypes.MEDIUM]: "riskMedium",
+    [RiskTypes.HIGH]: "riskHigh",
+};
+const DifficultySelector = ({ playOptions, dropdownConfig, isClassicGame = false, }) => {
+    const { t } = useTranslation();
     const { risks, disabledMenu, currentRisk, onRiskChange } = playOptions;
-    const riskColor = useRef(dropdownConfig.riskColorConfig[currentRisk ?? RiskTypes.LOW]);
+    const riskColors = { ...DEFAULT_RISK_COLORS, ...dropdownConfig.riskColorConfig };
+    const riskColor = useRef(riskColors[currentRisk ?? RiskTypes.LOW]);
     function onRiskSelected(value) {
-        riskColor.current = dropdownConfig.riskColorConfig[value];
+        riskColor.current = riskColors[value];
         onRiskChange(value);
     }
-    return (jsx("div", { className: style_difficulty.base, children: jsx(Selector, { currentValue: currentRisk, label: SELECTORS.RISK, values: risks, onSelect: onRiskSelected, disabled: disabledMenu, riskColor: riskColor.current }) }));
+    return (jsx("div", { className: style_difficulty.base, children: jsx(Selector, { currentValue: currentRisk, label: t("riskLabel"), values: risks, onSelect: onRiskSelected, disabled: disabledMenu, riskColor: riskColor.current, isClassicGame: isClassicGame, formatDisplay: (risk) => t(RISK_LABEL_KEY[risk]) }) }));
 };
 
 const ALLOWED_SEPARATORS = [",", "."];
@@ -682,9 +1052,9 @@ function cleanInputNumber(value) {
     return `${integerPart}.${decimalPart}`;
 }
 
-var styles$3 = {"base":"Input-module__base___IifiA","disabled":"Input-module__disabled___WqyKa"};
+var styles$5 = {"base":"Input-module__base___IifiA","disabled":"Input-module__disabled___WqyKa","disabledClassic":"Input-module__disabledClassic___hzsCt"};
 
-const Input = ({ onChange, disabled, className, max, ...restProps }) => {
+const Input = ({ onChange, disabled, className, max, isClassicGame = false, ...restProps }) => {
     const handleChange = React.useCallback((event) => {
         if (disabled) {
             return;
@@ -697,27 +1067,32 @@ const Input = ({ onChange, disabled, className, max, ...restProps }) => {
         event.target.value = clamped;
         onChange?.(event);
     }, [disabled, max, onChange]);
-    return (jsx("input", { ...restProps, type: "text", max: max, inputMode: "numeric", pattern: "\\d*", maxLength: 2, disabled: disabled, onChange: handleChange, className: cx$1(styles$3.base, className, { [styles$3.disabled]: disabled }) }));
+    return (jsx("input", { ...restProps, type: "text", max: max, inputMode: "numeric", pattern: "\\d*", maxLength: 2, disabled: disabled, onChange: handleChange, className: cx$1(styles$5.base, className, {
+            [styles$5.disabled]: disabled && !isClassicGame,
+            [styles$5.disabledClassic]: disabled && isClassicGame,
+        }) }));
 };
 
-var styles$2 = {"base":"Switch-module__base___gj2ey","switcher":"Switch-module__switcher___gHXIx","gold":"Switch-module__gold___oewnb","sweeps":"Switch-module__sweeps___yS-IY","default":"Switch-module__default___TmHoU","unchecked":"Switch-module__unchecked___ooSS2","disabled":"Switch-module__disabled___lMRv0","thumb":"Switch-module__thumb___1wJ9D","move-right":"Switch-module__move-right___ca-6D","label":"Switch-module__label___pG2uz"};
+var styles$4 = {"base":"Switch-module__base___gj2ey","isClassicGame":"Switch-module__isClassicGame___H2Ffo","switcher":"Switch-module__switcher___gHXIx","gold":"Switch-module__gold___oewnb","sweeps":"Switch-module__sweeps___yS-IY","default":"Switch-module__default___TmHoU","unchecked":"Switch-module__unchecked___ooSS2","disabled":"Switch-module__disabled___lMRv0","thumb":"Switch-module__thumb___1wJ9D","move-right":"Switch-module__move-right___ca-6D","label":"Switch-module__label___pG2uz"};
 
 const Switch = ({ enabled, onSwitch, disabled, isPlaying, }) => {
     const { config } = useAutoManualPlayState();
+    const { t } = useTranslation();
     const { current } = config.currencyOptions;
+    const isClassicGame = Boolean(config?.isClassicGame || config?.classicGame?.forceLeftStyle);
     const defaultClassName = useMemo(() => {
         if (current.code === Currency.GOLD) {
-            return styles$2.gold;
+            return styles$4.gold;
         }
         if (current.code === Currency.SWEEPS) {
-            return styles$2.sweeps;
+            return styles$4.sweeps;
         }
-        return styles$2.default;
+        return styles$4.default;
     }, [current.code]);
-    const switcherClassName = useMemo(() => cx$1(styles$2.switcher, defaultClassName, {
-        [styles$2.checked]: enabled,
-        [styles$2.unchecked]: !enabled,
-        [styles$2.disabled]: disabled,
+    const switcherClassName = useMemo(() => cx$1(styles$4.switcher, defaultClassName, {
+        [styles$4.checked]: enabled,
+        [styles$4.unchecked]: !enabled,
+        [styles$4.disabled]: disabled,
     }), [defaultClassName, enabled, disabled]);
     useEffect(() => {
         const handleGlobalKeyDown = (event) => {
@@ -737,15 +1112,19 @@ const Switch = ({ enabled, onSwitch, disabled, isPlaying, }) => {
             window.removeEventListener("keydown", handleGlobalKeyDown, true);
         };
     }, []);
-    return (jsx(Switch$1, { checked: enabled, onChange: onSwitch, as: Fragment$1, disabled: isPlaying, children: jsxs("div", { className: styles$2.base, children: [jsx("span", { className: styles$2.label, children: "Auto" }), jsx("div", { className: switcherClassName, children: jsx("span", { className: cx$1(styles$2.thumb, { [styles$2["move-right"]]: enabled }) }) })] }) }));
+    return (jsx(Switch$1, { checked: enabled, onChange: onSwitch, as: Fragment$1, disabled: isPlaying, children: jsxs("div", { className: cx$1({
+                [styles$4.isClassicGame]: isClassicGame,
+                [styles$4.base]: !isClassicGame,
+            }), children: [jsx("span", { className: styles$4.label, children: t("autoLabel") }), jsx("div", { className: switcherClassName, children: jsx("span", { className: cx$1(styles$4.thumb, { [styles$4["move-right"]]: enabled }) }) })] }) }));
 };
 
-var styles$1 = {"base":"InputWithSwitch-module__base___vjLoh","icon":"InputWithSwitch-module__icon___upeAL","input":"InputWithSwitch-module__input___K6RCD","label":"InputWithSwitch-module__label___tEjpj"};
+var styles$3 = {"base":"InputWithSwitch-module__base___vjLoh","icon":"InputWithSwitch-module__icon___upeAL","input":"InputWithSwitch-module__input___K6RCD","label":"InputWithSwitch-module__label___tEjpj","classic":"InputWithSwitch-module__classic___3AzII"};
 
-const InputWithSwitch = ({ children, switcherConfig, disabled, className, ...restProps }) => {
-    return (jsxs("div", { className: cx$1(styles$1.base, className, {
-            [styles$1.disabled]: switcherConfig.disabled,
-        }), children: [jsx(Switch, { ...switcherConfig }), jsx(Input, { ...restProps, className: cx$1(styles$1.input), disabled: disabled }), jsx("div", { className: cx$1(styles$1.icon), children: children })] }));
+const InputWithSwitch = ({ children, switcherConfig, disabled, className, isClassicGame = false, ...restProps }) => {
+    return (jsxs("div", { className: cx$1(styles$3.base, className, {
+            [styles$3.disabled]: switcherConfig.disabled,
+            [styles$3.classic]: isClassicGame,
+        }), children: [jsx(Switch, { ...switcherConfig }), jsx(Input, { ...restProps, className: cx$1(styles$3.input), disabled: disabled, isClassicGame: isClassicGame }), jsx("div", { className: cx$1(styles$3.icon), children: children })] }));
 };
 
 function getDefaultExportFromCjs (x) {
@@ -849,13 +1228,18 @@ const WidgetContainer = ({ state, widgets, displayPlayAmountView, }) => {
     return (jsxs("div", { className: cx("controllerWidgets"), children: [renderZone(left, "left"), renderZone(center, "center"), renderZone(right, "right")] }));
 };
 
-var styles = {"base":"PlayValueList-module__base___5duc6","playValuesWrapper":"PlayValueList-module__playValuesWrapper___-zfj2","playValue":"PlayValueList-module__playValue___TJQhI","selectedPlayValue":"PlayValueList-module__selectedPlayValue___3DhDC","disabledPlayValue":"PlayValueList-module__disabledPlayValue___U9Bkj"};
+var styles$2 = {"base":"PlayValueList-module__base___5duc6","playValuesWrapper":"PlayValueList-module__playValuesWrapper___-zfj2","locked":"PlayValueList-module__locked___JNPHM","playValue":"PlayValueList-module__playValue___TJQhI","selectedPlayValue":"PlayValueList-module__selectedPlayValue___3DhDC","disabledPlayValue":"PlayValueList-module__disabledPlayValue___U9Bkj","isClassicGame":"PlayValueList-module__isClassicGame___AjnGE"};
 
 const PlayValueList = () => {
     const [forceRefresh, setForceRefresh] = useState(false);
     const { config } = useAutoManualPlayState();
-    const { onChangeAmount, playAmount, totalBalance, playValues: { displayPlayAmountView, togglePlayAmountView }, } = usePlayController();
+    const { t } = useTranslation();
+    const isClassicGame = Boolean(config?.isClassicGame || config?.classicGame?.forceLeftStyle);
+    const { onChangeAmount, playAmount, totalBalance, autoPlay: { state: autoplayState }, playValues: { displayPlayAmountView, togglePlayAmountView }, } = usePlayController();
     const { playLimits } = config.playOptions.playHook();
+    // While autoplay is running the stake is locked for the whole session, so
+    // the play-amount table must not accept changes until it stops.
+    const isAutoplayPlaying = autoplayState === AUTO_PLAY_STATE.PLAYING;
     if (!displayPlayAmountView) {
         return null;
     }
@@ -886,6 +1270,9 @@ const PlayValueList = () => {
         setForceRefresh(!forceRefresh);
     };
     const handleClick = (e) => {
+        if (isAutoplayPlaying) {
+            return;
+        }
         const el = e.target?.closest("[data-value]");
         if (!el) {
             return;
@@ -899,13 +1286,43 @@ const PlayValueList = () => {
             applyValue(value);
         }
     };
-    return (jsx("div", { className: cx$1(styles.base), "data-force-refresh": forceRefresh, children: jsx("div", { className: cx$1(styles.playValuesWrapper), onClick: handleClick, role: "listbox", "aria-label": "Select play amount", "data-testid": "play-value-list", children: playLimits?.[config.currencyOptions.current.code].defaultBetOptions.map((playValue) => (jsx("div", { className: cx$1(styles.playValue, {
-                    [styles.selectedPlayValue]: playValue === playAmount,
-                    [styles.disabledPlayValue]: playValue > totalBalance,
+    return (jsx("div", { className: cx$1(styles$2.base, { [styles$2.isClassicGame]: isClassicGame }), "data-force-refresh": forceRefresh, children: jsx("div", { className: cx$1(styles$2.playValuesWrapper, {
+                [styles$2.locked]: isAutoplayPlaying,
+            }), onClick: handleClick, role: "listbox", "aria-label": t("selectPlayAmountAria"), "aria-disabled": isAutoplayPlaying, "data-testid": "play-value-list", children: playLimits?.[config.currencyOptions.current.code].defaultBetOptions.map((playValue) => (jsx("div", { className: cx$1(styles$2.playValue, {
+                    [styles$2.selectedPlayValue]: playValue === playAmount,
+                    [styles$2.disabledPlayValue]: playValue > totalBalance,
                 }), "data-value": playValue, role: "option", tabIndex: 0, "aria-selected": false, children: format(playValue, config.currencyOptions.current.decimals) }, `${config.currencyOptions.current.code}-${playValue}`))) }) }));
 };
 
+var styles$1 = {"backdrop":"FreeRoundsIntroModal-module__backdrop___qIgNx","column":"FreeRoundsIntroModal-module__column___YG71X","panel":"FreeRoundsIntroModal-module__panel___-zQpe","header":"FreeRoundsIntroModal-module__header___K5jmV","summary":"FreeRoundsIntroModal-module__summary___qpAbF","accent":"FreeRoundsIntroModal-module__accent___m-2s6","perRound":"FreeRoundsIntroModal-module__perRound___5Sx-v","expiry":"FreeRoundsIntroModal-module__expiry___n-fve","actions":"FreeRoundsIntroModal-module__actions___toCBq","button":"FreeRoundsIntroModal-module__button___bSTmX","playNow":"FreeRoundsIntroModal-module__playNow___iVhdt","playLater":"FreeRoundsIntroModal-module__playLater___l9031"};
+
+// Centered START intro pop-up — binary engagement decision. Renders + fires
+// callbacks only; the SDK does no fetching. `onPlayNow` should engage
+// free-rounds mode + close, `onPlayLater` should close and render zero
+// free-rounds UI for the rest of the session.
+const FreeRoundsIntroModal = ({ open, roundsRemaining, stakeCents, coinType, currency, decimals = 2, expiresAt, onPlayNow, onPlayLater, }) => {
+    const { t } = useTranslation();
+    const handleClose = () => onPlayLater?.();
+    const coinLabel = resolveFreeRoundsCoinLabel({ coinType, currency });
+    const valueDecimals = resolveFreeRoundsDecimals({
+        coinType,
+        currency,
+        fallback: decimals,
+    });
+    const perRoundDisplay = format(stakeCents / 100, valueDecimals);
+    const expiresInDays = computeExpiresInDays(expiresAt);
+    return (jsx(Dialog, { open: open, onClose: handleClose, className: styles$1.backdrop, children: jsx("div", { className: styles$1.column, children: jsxs(DialogPanel, { className: styles$1.panel, children: [jsx(DialogTitle, { className: styles$1.header, children: t("freeRoundsModalTitle") }), jsxs("div", { className: styles$1.summary, children: [t("freeRoundsHave"), " ", jsx("span", { className: styles$1.accent, children: roundsRemaining }), " ", roundsRemaining === 1
+                                ? t("freeRoundsUnitOne")
+                                : t("freeRoundsUnitOther")] }), jsx("div", { className: styles$1.perRound, children: t("freeRoundsPerRound", {
+                            amount: `${perRoundDisplay}${coinLabel ? ` ${coinLabel}` : ""}`,
+                        }) }), expiresInDays !== null && (jsx("div", { className: styles$1.expiry, children: t("freeRoundsExpiresIn", {
+                            days: expiresInDays,
+                            unit: expiresInDays === 1 ? t("dayUnitOne") : t("dayUnitOther"),
+                        }) })), jsxs("div", { className: styles$1.actions, children: [jsx("button", { type: "button", className: `${styles$1.button} ${styles$1.playNow}`, onClick: onPlayNow, children: t("freeRoundsModalPlayNow") }), jsx("button", { type: "button", className: `${styles$1.button} ${styles$1.playLater}`, onClick: onPlayLater, children: t("freeRoundsModalPlayLater") })] })] }) }) }));
+};
+
 const AutoManualPlayProvider = ({ children, config, }) => {
+    const t = useMemo(() => createTranslator(resolveLanguage(config.language)), [config.language]);
     const [mode, setMode] = useState(GAME_MODE.MANUAL);
     const [autoplayState, setAutoplayState] = useState(AUTO_PLAY_STATE.IDLE);
     const [doubleOrNothingState, setDoubleOrNothingState] = useState(DOUBLE_OR_NOTHING_STATE.IDLE);
@@ -917,13 +1334,31 @@ const AutoManualPlayProvider = ({ children, config, }) => {
     const isControllerDisabled = config.playOptions.disabledController;
     const isGamePlaying = config.playOptions.isPlaying;
     const isAutoplayPlaying = autoplayState === AUTO_PLAY_STATE.PLAYING;
+    // Free rounds are MANUAL-only by default. While a grant is engaged the
+    // player must not be able to flip into autoplay (which would silently drop
+    // the manual-gated engaged state and let PAID autoplay start). This is
+    // independent of `mode` so it stays true even if a switch attempt slipped
+    // through. Games whose autoplay submission path funds rounds from engaged
+    // grants opt out of the lock via `supportsGrantFundedAutoplay`.
+    const freeRoundsRemaining = config.freeRoundsOptions?.roundsRemaining ?? 0;
+    const isFreeRoundsEngaged = Boolean(config.freeRoundsOptions?.engaged && freeRoundsRemaining > 0);
+    const supportsGrantFundedAutoplay = Boolean(config.freeRoundsOptions?.supportsGrantFundedAutoplay);
+    const isModeLockedByFreeRounds = isFreeRoundsEngaged && !supportsGrantFundedAutoplay;
     const isSimplified = config.withoutRiskAndAutoplay === true;
+    const isClassicGame = Boolean(config?.isClassicGame || config?.classicGame?.forceLeftStyle);
     const togglePlayAmountView = useCallback(() => {
         setDisplayPlayAmountView((v) => !v);
     }, []);
+    // Grant-funded autoplay: while free rounds are engaged the selectable
+    // autoplay count is hard-capped to the remaining grants (covers the default
+    // count and the ∞ option — Infinity clamps down to roundsRemaining, so ∞ is
+    // effectively disabled while engaged). No paid spillover.
     useEffect(() => {
-        void setTogglePlayAmountView({ isOpen: displayPlayAmountView });
-    }, [displayPlayAmountView]);
+        if (!supportsGrantFundedAutoplay || !isFreeRoundsEngaged) {
+            return;
+        }
+        setNumberOfPlays((prev) => prev > freeRoundsRemaining ? freeRoundsRemaining : prev);
+    }, [supportsGrantFundedAutoplay, isFreeRoundsEngaged, freeRoundsRemaining]);
     const startAutoplay = useCallback((numPlays) => {
         setMode(GAME_MODE.AUTOPLAY);
         setAutoplayState(AUTO_PLAY_STATE.SELECTING);
@@ -963,12 +1398,25 @@ const AutoManualPlayProvider = ({ children, config, }) => {
         setSelection([]);
     }, []);
     const toggleMode = useCallback(() => {
-        if (isGamePlaying || isControllerDisabled || isAutoplayPlaying) {
+        // No-op while a free-round grant is engaged WITHOUT the game's
+        // grant-funded-autoplay opt-in: manual-only, no-exit. The player cannot
+        // switch to autoplay until the grant is consumed/released. When the game
+        // sets `supportsGrantFundedAutoplay`, engaged switching is allowed (still
+        // blocked while a round is in flight via the gates above).
+        if (isGamePlaying ||
+            isControllerDisabled ||
+            isAutoplayPlaying ||
+            isModeLockedByFreeRounds) {
             return;
         }
         setNumberOfPlays(AUTOPLAY_DEFAULT_PLAY_ROUNDS_COUNT);
         setMode((prevMode) => prevMode === GAME_MODE.MANUAL ? GAME_MODE.AUTOPLAY : GAME_MODE.MANUAL);
-    }, [isAutoplayPlaying, isControllerDisabled, isGamePlaying]);
+    }, [
+        isAutoplayPlaying,
+        isControllerDisabled,
+        isGamePlaying,
+        isModeLockedByFreeRounds,
+    ]);
     const updateSelection = useCallback((values) => {
         if (!isAutoPlaying) {
             setSelection(values);
@@ -1027,29 +1475,60 @@ const AutoManualPlayProvider = ({ children, config, }) => {
         displayPlayAmountView,
         togglePlayAmountView,
     ]);
-    return (jsxs(AutoManualPlayStateContext.Provider, { value: contextValue, children: [typeof children === "function" ? children(contextValue) : children, config.playOptions.displayController && (jsx("div", { className: cx$1(styles_ui.base, styles_ui.betForm), style: {
-                    "--play-bottom": config.panel.bottom ?? 0,
-                    "--play-panel-bg": hexToRgb(config.panel.bgColorHex ?? "#01243A"),
-                    "--play-dropdown-bg": hexToRgb(config.dropdown.bgColorHex ?? "#01243A"),
-                    "--play-panel-bg-opacity": config.panel.bgColorOpacity ?? 0.5,
-                }, children: jsxs("div", { className: cx$1(styles_ui.container), children: [jsx(PlayValueList, {}), !isSimplified ? (jsxs("div", { className: cx$1(styles_ui.auto), children: [jsx(DifficultySelector, { playOptions: {
-                                        ...config.playOptions,
-                                        disabledMenu: isControllerDisabled || config.playOptions.disabledMenu,
-                                    }, dropdownConfig: config.dropdown }), jsx(InputWithSwitch, { value: numberOfPlays === Infinity ? 0 : numberOfPlays, type: "number", onChange: (e) => setNumberOfPlays(Number(e.currentTarget.value)), placeholder: "Number of Plays", min: 0, max: 99, disabled: isControllerDisabled || mode === GAME_MODE.MANUAL, switcherConfig: {
-                                        onSwitch: toggleMode,
-                                        isPlaying: isAutoPlaying || isGamePlaying,
-                                        enabled: mode !== GAME_MODE.MANUAL,
-                                        disabled: isControllerDisabled || isAutoplayPlaying,
-                                    }, children: jsx("span", { className: cx$1({
-                                            [styles_ui.disabled]: mode !== GAME_MODE.AUTOPLAY ||
-                                                numberOfPlays !== Infinity ||
-                                                isAutoplayPlaying,
-                                        }), children: "\u221E" }) })] })) : null, mode === GAME_MODE.MANUAL ? (jsx(ManualPlayController, {})) : (jsx(AutoPlayController, {})), jsx(WidgetContainer, { state: autoplayState, displayPlayAmountView: displayPlayAmountView, widgets: {
-                                left: config.leftWidgets,
-                                center: config.centerWidgets,
-                                right: config.rightWidgets,
-                            } })] }) }))] }));
+    return (jsx(I18nProvider, { language: config.language, children: jsxs(AutoManualPlayStateContext.Provider, { value: contextValue, children: [typeof children === "function" ? children(contextValue) : children, mode === GAME_MODE.MANUAL &&
+                    config.freeRoundsOptions?.showIntroModal && (jsx("div", { style: {
+                        "--play-panel-bg": hexToRgb(config.panel.bgColorHex ?? "#221062"),
+                    }, children: jsx(FreeRoundsIntroModal, { open: config.freeRoundsOptions.showIntroModal, roundsRemaining: config.freeRoundsOptions.roundsRemaining, totalRounds: config.freeRoundsOptions.totalRounds, stakeCents: config.freeRoundsOptions.stakeCents, coinType: config.freeRoundsOptions.coinType, currency: config.freeRoundsOptions.currency, decimals: config.currencyOptions.current.decimals, expiresAt: config.freeRoundsOptions.expiresAt, onPlayNow: config.freeRoundsOptions.onPlayNow, onPlayLater: config.freeRoundsOptions.onPlayLater }) })), config.playOptions.displayController && (jsx("div", { className: cx$1(styles_ui.base, styles_ui.betForm, {
+                        [styles_ui.baseForceLeft]: config.classicGame?.forceLeftStyle,
+                        [styles_ui.isClassicGame]: config.isClassicGame,
+                        [styles_ui.inActiveRound]: mode === GAME_MODE.MANUAL && isGamePlaying,
+                    }), style: {
+                        "--play-bottom": config.panel.bottom ?? 0,
+                        "--play-panel-bg": hexToRgb(config.panel.bgColorHex ?? "#221062"),
+                        "--play-dropdown-bg": hexToRgb(config.classicGame?.dropdown?.bgColorHex ??
+                            config.dropdown.bgColorHex ??
+                            "#150C47"),
+                        "--play-panel-bg-opacity": config.panel.bgColorOpacity ?? 0.5,
+                    }, children: jsxs("div", { className: cx$1(styles_ui.container, {
+                            [styles_ui.containerSpread]: config.classicGame?.forceLeftStyle,
+                        }), children: [jsxs("div", { className: cx$1(styles_ui.controls), children: [jsx(PlayValueList, {}), !isSimplified ? (jsxs("div", { className: cx$1(styles_ui.auto), children: [jsx(DifficultySelector, { playOptions: {
+                                                    ...config.playOptions,
+                                                    disabledMenu: isControllerDisabled ||
+                                                        config.playOptions.disabledMenu,
+                                                }, dropdownConfig: config.dropdown, isClassicGame: isClassicGame }), jsx(InputWithSwitch, { value: numberOfPlays === Infinity ? 0 : numberOfPlays, type: "number", onChange: (e) => setNumberOfPlays(Number(e.currentTarget.value)), placeholder: t("numberOfPlays"), min: 0, max: 99, disabled: isControllerDisabled || mode === GAME_MODE.MANUAL, isClassicGame: isClassicGame, switcherConfig: {
+                                                    onSwitch: toggleMode,
+                                                    isPlaying: isAutoPlaying || isGamePlaying,
+                                                    enabled: mode !== GAME_MODE.MANUAL,
+                                                    disabled: isControllerDisabled ||
+                                                        isAutoplayPlaying ||
+                                                        isModeLockedByFreeRounds,
+                                                }, children: !isClassicGame && (jsx("span", { className: cx$1({
+                                                        [styles_ui.disabled]: mode !== GAME_MODE.AUTOPLAY ||
+                                                            numberOfPlays !== Infinity ||
+                                                            isAutoplayPlaying,
+                                                    }), children: "\u221E" })) })] })) : null, mode === GAME_MODE.MANUAL ? (jsx(ManualPlayController, {})) : (jsx(AutoPlayController, {}))] }), isFreeRoundsEngaged && (jsxs("div", { className: styles_ui.freeRoundsFooter, children: [jsx("span", { className: styles_ui.freeRoundsFooterCount, children: config.freeRoundsOptions?.roundsRemaining }), " ", config.freeRoundsOptions?.roundsRemaining === 1
+                                        ? t("freeRoundLeftOne")
+                                        : t("freeRoundLeftOther")] })), jsx(WidgetContainer, { state: autoplayState, displayPlayAmountView: displayPlayAmountView, widgets: {
+                                    left: config.leftWidgets,
+                                    center: config.centerWidgets,
+                                    right: config.rightWidgets,
+                                } })] }) }))] }) }));
+};
+
+var styles = {"backdrop":"FreeRoundsSummaryModal-module__backdrop___tNi3I","panel":"FreeRoundsSummaryModal-module__panel___2MIEp","header":"FreeRoundsSummaryModal-module__header___-BkpP","summary":"FreeRoundsSummaryModal-module__summary___YExX9","accent":"FreeRoundsSummaryModal-module__accent___z9aBF","hint":"FreeRoundsSummaryModal-module__hint___CYWqA","close":"FreeRoundsSummaryModal-module__close___4-irR"};
+
+// END pop-up — shown by the game after the last free round settles. The game
+// owns visibility: it mounts open when the play-through completes, unmount
+// onClose.
+const FreeRoundsSummaryModal = ({ totalWinAmount, coin, roundsPlayed, decimals, onClose, }) => {
+    const { t } = useTranslation();
+    // Shared monetary formatter — truncates (never rounds up) so the summary
+    // can't display more winnings than were actually credited.
+    const winDisplay = format(totalWinAmount, decimals ?? resolveCoinLabelDecimals(coin));
+    return (jsx(Dialog, { open: true, onClose: onClose, className: styles.backdrop, children: jsxs(DialogPanel, { className: styles.panel, children: [jsx(DialogTitle, { className: styles.header, children: t("freeRoundsModalTitle") }), jsxs("div", { className: styles.summary, children: [t("freeRoundsSummaryWon"), " ", jsxs("span", { className: styles.accent, children: [winDisplay, " ", coin] }), " ", t("freeRoundsSummaryIn"), " ", roundsPlayed, " ", roundsPlayed === 1
+                            ? t("freeRoundsSummaryUnitOne")
+                            : t("freeRoundsSummaryUnitOther")] }), jsx("div", { className: styles.hint, children: t("freeRoundsSummaryCredited") }), jsx("button", { type: "button", className: styles.close, onClick: onClose, children: t("freeRoundsSummaryClose") })] }) }));
 };
 
-export { AUTO_PLAY_STATE, AutoManualPlayProvider, DOUBLE_OR_NOTHING_STATE, GAME_MODE, WIDGET, canAutoplaySpaceTrigger, createAutoplayButtonAction, createManualCashoutClickHandler, format, isAutoplayButtonDisabled, isManualCashoutDisabled };
+export { AUTO_PLAY_STATE, AutoManualPlayProvider, DEFAULT_RISK_COLORS, DOUBLE_OR_NOTHING_STATE, FreeRoundsIntroModal, FreeRoundsSummaryModal, GAME_MODE, I18nProvider, WIDGET, canAutoplaySpaceTrigger, createAutoplayButtonAction, createManualCashoutClickHandler, createTranslator, format, isAutoplayButtonDisabled, isManualCashoutDisabled, useTranslation };
 //# sourceMappingURL=index.mjs.map