kasy-cli 1.31.10 → 1.31.12

package/templates/firebase/lib/components/kasy_app_bar.dart

@@ -125,12 +125,9 @@ class KasyFrostedChromeBackground extends StatelessWidget {
     this.padForStatusBar = true,
   });
 
-  /// Translucent tint so blurred content shows through; tuned per brightness.
-  /// Derived from the global `surface` token so the bar lifts off the canvas
-  /// and follows light/dark automatically.
+  /// Solid bar fill from the global `surface` token; follows light/dark.
   Color _tint(BuildContext context) {
-    final bool dark = Theme.of(context).brightness == Brightness.dark;
-    return context.colors.surface.withValues(alpha: dark ? 0.88 : 0.82);
+    return context.colors.surface;
   }
 
   @override
@@ -194,40 +191,34 @@ class KasyFrostedChromeBackground extends StatelessWidget {
 class KasyTopScrollFade extends StatelessWidget {
   const KasyTopScrollFade({super.key});
 
-  /// Always-solid strong band at the very top, ON TOP of the status-bar inset.
-  /// Fixed (not derived from the inset) so the top reads 100% solid even on web,
-  /// where there is no status-bar inset.
-  static const double _solidBand = 20;
-
-  /// Smooth fade below the solid band before the wash is fully transparent.
-  static const double _fadeTail = 18;
+  /// Total wash height: status-bar strip + a fade zone below it.
+  static const double _contentFade = 40.0;
 
   @override
   Widget build(BuildContext context) {
     final double topInset = MediaQuery.paddingOf(context).top;
-    final double solidHeight = topInset + _solidBand;
-    final double height = solidHeight + _fadeTail;
-    final Color bg = context.colors.background;
-    // Fully solid (100%) from the very top through the status-bar strip and the
-    // fixed band, then an eased fade to transparent — strong at the top, soft at
-    // the bottom. The middle stop curves the fade so it is gradual, not linear.
-    final double solidStop = (solidHeight / height).clamp(0.0, 1.0);
-    final double midStop = solidStop + (1 - solidStop) * 0.5;
+    // On web topInset = 0; enforce a 6 px minimum so the strip still exists.
+    final double solidHeight = topInset < 6 ? 6.0 : topInset;
+    final double totalHeight = solidHeight + _contentFade;
+    final Color base = context.colors.surface;
+
+    // Same gradient the grid cards use for their caption scrim — strong at the
+    // top, melting gradually to fully transparent at the bottom.
     return IgnorePointer(
       child: SizedBox(
-        height: height,
+        height: totalHeight,
         child: DecoratedBox(
           decoration: BoxDecoration(
             gradient: LinearGradient(
               begin: Alignment.topCenter,
               end: Alignment.bottomCenter,
               colors: <Color>[
-                bg,
-                bg,
-                bg.withValues(alpha: 0.4),
-                bg.withValues(alpha: 0),
+                base.withValues(alpha: 0.96),
+                base.withValues(alpha: 0.96),
+                base.withValues(alpha: 0.68),
+                base.withValues(alpha: 0.0),
               ],
-              stops: <double>[0.0, solidStop, midStop, 1.0],
+              stops: const <double>[0.0, 0.20, 0.55, 1.0],
             ),
           ),
         ),
@@ -399,12 +390,13 @@ class KasyAppBar extends StatelessWidget {
     }
 
     // A top wash sits BEHIND the bar (and stays put even when the bar hides) so
-    // content melts into the background at the top — the same pattern on every
-    // screen that has an app bar. Skipped for modal / page-sheet bars (custom
-    // height or inset), where nothing scrolls behind the bar.
+    // content melts into the background at the top — mobile only (tablet/desktop
+    // use the sidebar/web header instead). Skipped for modal / page-sheet bars.
+    final bool isMobile =
+        MediaQuery.sizeOf(context).width < DeviceType.medium.breakpoint;
     final bool standardBar =
         useSafeArea && topInset == null && toolbarHeight == null;
-    if (!standardBar) return animatedChrome;
+    if (!standardBar || !isMobile) return animatedChrome;
     return Stack(
       clipBehavior: Clip.none,
       children: <Widget>[

package/templates/firebase/lib/components/kasy_toast.dart

@@ -733,7 +733,9 @@ _Palette _palette(KasyColors c, KasyToastTone tone) {
         accent: c.primary,
         icon: KasyIcons.info,
         buttonBg: c.primary,
-        buttonFg: c.onPrimary,
+        // The Close button sits on a solid, vivid tone color — keep its label
+        // white for reliable contrast regardless of the brand "on" token.
+        buttonFg: Colors.white,
       );
     case KasyToastTone.success:
       final Color successDark = HSLColor.fromColor(c.success)
@@ -745,21 +747,21 @@ _Palette _palette(KasyColors c, KasyToastTone tone) {
         accent: successDark,
         icon: KasyIcons.checkCircle,
         buttonBg: successDark,
-        buttonFg: c.onSuccess,
+        buttonFg: Colors.white,
       );
     case KasyToastTone.warning:
       return _Palette(
         accent: c.warning,
         icon: KasyIcons.privacy,
         buttonBg: c.warning,
-        buttonFg: c.onWarning,
+        buttonFg: Colors.white,
       );
     case KasyToastTone.danger:
       return _Palette(
         accent: c.error,
         icon: KasyIcons.error,
         buttonBg: c.error,
-        buttonFg: c.onError,
+        buttonFg: Colors.white,
       );
   }
 }

package/templates/firebase/lib/core/web_device_preview/web_device_preview.dart

@@ -508,6 +508,11 @@ class _DeviceSwitchBridge extends StatefulWidget {
 }
 
 class _DeviceSwitchBridgeState extends State<_DeviceSwitchBridge> {
+  // _syncOrientation retries on the next frame while the DevicePreview store is
+  // still mounting/initializing; cap the retries so it can never spin forever.
+  int _syncRetries = 0;
+  static const int _maxSyncRetries = 120;
+
   @override
   void initState() {
     super.initState();
@@ -531,8 +536,8 @@ class _DeviceSwitchBridgeState extends State<_DeviceSwitchBridge> {
   }
 
   void _onFrameVisibleChanged() {
-    if (!mounted) return;
-    final store = Provider.of<DevicePreviewStore>(context, listen: false);
+    final store = _store();
+    if (store == null) return;
     final data = _readData(store);
     if (data == null) return;
     if (data.isFrameVisible != widget.frameVisibleNotifier.value) {
@@ -543,17 +548,21 @@ class _DeviceSwitchBridgeState extends State<_DeviceSwitchBridge> {
   void _onOrientationChanged() => _syncOrientation();
 
   void _syncOrientation() {
-    if (!mounted) return;
-    final store = Provider.of<DevicePreviewStore>(context, listen: false);
-    final data = _readData(store);
-    if (data == null) {
-      // DevicePreview initializes asynchronously (it loads saved preferences), so
-      // on the first web frame the store can still be uninitialized and reading
-      // store.data throws "Not initialized". Retry next frame instead of surfacing
-      // a scary (and harmless) exception in the console.
-      WidgetsBinding.instance.addPostFrameCallback((_) => _syncOrientation());
+    final store = _store();
+    final data = store == null ? null : _readData(store);
+    if (store == null || data == null) {
+      // DevicePreview mounts its store asynchronously: on the first web frames the
+      // provider may not be in the tree yet (ProviderNotFound) or the store may be
+      // uninitialized (reading .data throws "Not initialized"). Retry on the next
+      // frame instead of surfacing a scary (and harmless) exception. Capped so it
+      // can never spin forever.
+      if (mounted && _syncRetries < _maxSyncRetries) {
+        _syncRetries++;
+        WidgetsBinding.instance.addPostFrameCallback((_) => _syncOrientation());
+      }
       return;
     }
+    _syncRetries = 0;
     final target = widget.landscapeNotifier.value
         ? Orientation.landscape
         : Orientation.portrait;
@@ -562,9 +571,19 @@ class _DeviceSwitchBridgeState extends State<_DeviceSwitchBridge> {
     }
   }
 
-  /// [DevicePreviewStore.data] throws while the store is still finishing its async
-  /// initialization. Returns null instead of throwing so callers can skip or retry
-  /// cleanly (see _syncOrientation).
+  /// The DevicePreview store, or null if it isn't in the tree yet — `Provider.of`
+  /// throws ProviderNotFound on the first web frames before DevicePreview mounts it.
+  DevicePreviewStore? _store() {
+    if (!mounted) return null;
+    try {
+      return Provider.of<DevicePreviewStore>(context, listen: false);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  /// [DevicePreviewStore.data] throws "Not initialized" while the store finishes its
+  /// async init. Returns null instead so callers can skip or retry cleanly.
   DevicePreviewData? _readData(DevicePreviewStore store) {
     try {
       return store.data;

package/templates/firebase/lib/features/onboarding/repositories/user_infos_repository.dart

@@ -17,11 +17,18 @@ class UserInfosRepository {
 
   Future<void> save(String userId, UserInfoDetail info) async {
     final entity = info.toEntity();
-    
+
     final alreadyExistingInfo =
         await _userInfosApi.getByKey(userId, entity.key);
     if (alreadyExistingInfo != null) {
-      return _userInfosApi.update(userId, entity);
+      // Reuse the existing document id so re-answering the same onboarding
+      // question overwrites its value instead of appending a duplicate. The
+      // fresh entity has a null id, which would otherwise make update() write
+      // to a new auto-id document every time (the duplication seen in testing).
+      return _userInfosApi.update(
+        userId,
+        entity.copyWith(id: alreadyExistingInfo.id),
+      );
     }
 
     return _userInfosApi.create(userId, entity);

package/templates/firebase/lib/features/subscriptions/api/stripe_backend_api.dart

@@ -34,6 +34,7 @@ class StripeBackendApi {
     required String priceId,
     String? successUrl,
     String? cancelUrl,
+    String? locale,
   }) async {
     final res = await _functions
         .httpsCallable('stripeFunctions-createCheckoutSession')
@@ -41,6 +42,7 @@ class StripeBackendApi {
           'priceId': priceId,
           if (successUrl != null) 'successUrl': successUrl,
           if (cancelUrl != null) 'cancelUrl': cancelUrl,
+          if (locale != null) 'locale': locale,
         });
     return (res.data as Map)['url'] as String;
   }

package/templates/firebase/lib/features/subscriptions/api/stripe_payment_api.dart

@@ -3,6 +3,7 @@ import 'package:kasy_kit/core/data/models/subscription.dart';
 import 'package:kasy_kit/features/subscriptions/api/entities/subscription_entity.dart';
 import 'package:kasy_kit/features/subscriptions/api/stripe_backend_api.dart';
 import 'package:kasy_kit/features/subscriptions/api/subscription_payment_api.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
 import 'package:url_launcher/url_launcher.dart';
 
 /// Stripe web subscription provider.
@@ -33,13 +34,26 @@ class StripePaymentApi implements SubscriptionPaymentApi {
 
   @override
   Future<void> purchaseProduct(SubscriptionProduct product) async {
-    final returnUrl = Uri.base.toString();
+    // On success, Stripe redirects this new tab to a tiny standalone page
+    // (web/stripe_success.html) instead of reloading the whole app in a second
+    // tab. The original app tab keeps polling and flips to premium via the
+    // webhook. On cancel we send the user back to the app where they were.
+    final appUrl = Uri.base.toString();
+    final successUrl = '${Uri.base.origin}/stripe_success.html';
     final url = await _backend.createCheckoutSession(
       priceId: product.skuId,
-      successUrl: returnUrl,
-      cancelUrl: returnUrl,
+      successUrl: successUrl,
+      cancelUrl: appUrl,
+      // Send the app language so the backend can persist it on the user and
+      // deliver subscription notifications in the right language (on web there
+      // is no registered device to read the locale from).
+      locale: LocaleSettings.instance.currentLocale.languageCode,
     );
     await _open(url);
+    // Checkout is now open in a new tab. Payment is NOT confirmed yet — the
+    // webhook will write the subscription record when the user pays. Throw so
+    // the provider knows to poll for activation instead of setting active now.
+    throw PendingWebCheckoutException();
   }
 
   @override
@@ -75,8 +89,6 @@ class StripePaymentApi implements SubscriptionPaymentApi {
   Future<void> presentCodeRedemptionSheet() async {}
 
   Future<void> _open(String url) async {
-    // On web, redirect the current tab so the user returns to the app after
-    // Stripe Checkout / the Customer Portal.
-    await launchUrl(Uri.parse(url), webOnlyWindowName: '_self');
+    await launchUrl(Uri.parse(url), webOnlyWindowName: '_blank');
   }
 }

package/templates/firebase/lib/features/subscriptions/api/subscription_payment_api.dart

@@ -51,3 +51,11 @@ abstract interface class SubscriptionPaymentApi {
 class UserCancelledPurchaseException implements Exception {
   UserCancelledPurchaseException();
 }
+
+/// Thrown by [StripePaymentApi.purchaseProduct] on web after the hosted
+/// Checkout URL is opened in a new browser tab. The purchase is NOT complete —
+/// the caller must poll for subscription activation (via webhook) instead of
+/// treating the returned Future as payment confirmation.
+class PendingWebCheckoutException implements Exception {
+  PendingWebCheckoutException();
+}

package/templates/firebase/lib/features/subscriptions/providers/premium_page_provider.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart' show PlatformException;
 import 'package:kasy_kit/core/data/api/analytics_api.dart';
+import 'package:kasy_kit/core/data/models/entitlement.dart';
 import 'package:kasy_kit/core/data/models/subscription.dart';
 import 'package:kasy_kit/core/states/models/user_state.dart';
 import 'package:kasy_kit/core/states/translations.dart';
@@ -8,7 +9,7 @@ import 'package:kasy_kit/core/states/user_state_notifier.dart';
 import 'package:kasy_kit/core/toast/toast_service.dart';
 import 'package:kasy_kit/features/feedbacks/repositories/feature_request_repository.dart';
 import 'package:kasy_kit/features/subscriptions/api/subscription_payment_api.dart'
-    show UserCancelledPurchaseException;
+    show PendingWebCheckoutException, UserCancelledPurchaseException;
 import 'package:kasy_kit/features/subscriptions/providers/models/premium_state.dart';
 import 'package:kasy_kit/features/subscriptions/repositories/subscription_repository.dart';
 import 'package:kasy_kit/router.dart';
@@ -31,6 +32,17 @@ class PremiumStateNotifier extends _$PremiumStateNotifier {
 
   @override
   Future<PremiumState> build() async {
+    // A user who already has an active subscription must ALWAYS land on the
+    // "subscribed" state, even if the offer list fails to load. On web the
+    // offers come from Stripe and the fetch can transiently fail; without this
+    // early return a paying user would wrongly see the empty-products paywall
+    // and "lose" the confirmation that they paid. The active view
+    // ([ActivePremiumContent]) does not need the offer list.
+    final currentSubscription = _userState.subscription;
+    if (currentSubscription is SubscriptionStateData) {
+      return PremiumState.active(activeOffer: currentSubscription.activeOffer);
+    }
+
     try {
       // If you have installed the remote config brick
       // you can use it like this
@@ -41,25 +53,13 @@ class PremiumStateNotifier extends _$PremiumStateNotifier {
       final offers = await _subscriptionRepository.getOffers();
       if (offers.isEmpty) {
         _logger.w(
-          'RevenueCat returned no subscription offers. The paywall will show '
+          'The store returned no subscription offers. The paywall will show '
           'an empty-products state instead of a blank screen.',
         );
         return const PremiumState(offers: []);
       }
 
-      return switch (_userState.subscription) {
-        SubscriptionStateData(:final activeOffer) => PremiumState.active(
-          activeOffer: offers.firstWhere(
-            (element) => element.skuId == activeOffer?.skuId,
-            orElse: () => offers.first,
-          ),
-        ),
-        SubscriptionInactiveStateData() => PremiumState(
-          offers: offers,
-          selectedOffer: offers.first,
-        ),
-        _ => PremiumState(offers: offers, selectedOffer: offers.first),
-      };
+      return PremiumState(offers: offers, selectedOffer: offers.first);
     } catch (err, stack) {
       // RevenueCat CONFIGURATION_ERROR (code 23) means the products exist in the
       // dashboard but aren't live on the store yet (e.g. "Ready to Submit").
@@ -123,61 +123,102 @@ class PremiumStateNotifier extends _$PremiumStateNotifier {
     String? paywall,
     String? redirectRoute,
   }) async {
-    state = switch (state.value) {
-      PremiumStateData(:final offers) => AsyncData(
-        PremiumState.sending(
-          isPremium: false,
-          offers: offers,
-          selectedOffer: offer,
-        ),
-      ),
+    final currentOffers = switch (state.value) {
+      PremiumStateData(:final offers) => offers,
       _ => throw "cannot purchase while active",
     };
+    state = AsyncData(
+      PremiumState.sending(isPremium: false, offers: currentOffers, selectedOffer: offer),
+    );
     try {
       final entitlements = await _subscriptionRepository.purchase(offer);
-      state = AsyncData(PremiumState.active(activeOffer: offer));
-      await _analyticsApi?.logEvent("purchase", {
-        "skuId": offer.skuId,
-        "price": offer.price,
-        // "promotion": offer.promotion,
-        "duration": offer.duration,
-        "paywall": paywall,
-      });
-      // let's refresh the user state
-      await ref
-          .read(userStateNotifierProvider.notifier)
-          .refreshSubscription(product: offer, entitlements: entitlements);
-      final t = ref.read(translationsProvider);
-      ref
-          .read(toastProvider)
-          .success(
-            title: t.premium.purchase_success_title,
-            text: t.premium.purchase_success_text,
-          );
-      await Future.delayed(const Duration(seconds: 2));
-      if (redirectRoute != null) ref.read(goRouterProvider).go(redirectRoute);
+      await _activateAfterPurchase(offer, entitlements, paywall, redirectRoute);
+    } on PendingWebCheckoutException {
+      // Stripe web: checkout opened in a new tab. Poll until the webhook
+      // activates the subscription or we time out.
+      await _waitForWebPayment(offer, currentOffers, paywall: paywall, redirectRoute: redirectRoute);
     } catch (err, stackTrace) {
-      state = switch (state.value) {
-        PremiumStateData(:final offers) => AsyncData(
-          PremiumState(offers: offers, selectedOffer: offer),
-        ),
-        PremiumStateSending(:final offers) => AsyncData(
-          PremiumState(offers: offers, selectedOffer: offer),
-        ),
-        PremiumStateActive() => state,
-        _ => throw "cannot purchase while active",
-      };
+      state = AsyncData(PremiumState(offers: currentOffers, selectedOffer: offer));
       if (err is UserCancelledPurchaseException) return;
       await Sentry.captureException(err, stackTrace: stackTrace);
       _logger.e("...PremiumStateNotifier: purchase failed $err : $stackTrace");
       final t = ref.read(translationsProvider);
-      ref
-          .read(toastProvider)
-          .error(
-            title: t.premium.error_title,
-            text: t.premium.error_text,
-            reason: "We were unable to process your subscription",
-          );
+      ref.read(toastProvider).error(
+        title: t.premium.error_title,
+        text: t.premium.error_text,
+        reason: "We were unable to process your subscription",
+      );
+    }
+  }
+
+  Future<void> _activateAfterPurchase(
+    SubscriptionProduct offer,
+    List<Entitlement>? entitlements,
+    String? paywall,
+    String? redirectRoute,
+  ) async {
+    state = AsyncData(PremiumState.active(activeOffer: offer));
+    await _analyticsApi?.logEvent("purchase", {
+      "skuId": offer.skuId,
+      "price": offer.price,
+      "duration": offer.duration,
+      "paywall": paywall,
+    });
+    await ref
+        .read(userStateNotifierProvider.notifier)
+        .refreshSubscription(product: offer, entitlements: entitlements);
+    final t = ref.read(translationsProvider);
+    ref.read(toastProvider).success(
+      title: t.premium.purchase_success_title,
+      text: t.premium.purchase_success_text,
+    );
+    await Future.delayed(const Duration(seconds: 2));
+    if (redirectRoute != null) ref.read(goRouterProvider).go(redirectRoute);
+  }
+
+  /// Polls the subscription backend every 5 s until the Stripe webhook delivers
+  /// the activation (up to 10 min). Runs while the state is [PremiumStateSending].
+  Future<void> _waitForWebPayment(
+    SubscriptionProduct offer,
+    List<SubscriptionProduct> currentOffers, {
+    String? paywall,
+    String? redirectRoute,
+  }) async {
+    const maxAttempts = 120; // 10 min at 5 s intervals
+    const interval = Duration(seconds: 5);
+    final userId = _userState.user.idOrNull;
+    if (userId == null) {
+      state = AsyncData(PremiumState(offers: currentOffers, selectedOffer: offer));
+      return;
+    }
+
+    try {
+      for (var i = 0; i < maxAttempts; i++) {
+        await Future.delayed(interval);
+        if (state.value is! PremiumStateSending) return;
+        try {
+          final sub = await _subscriptionRepository.get(userId);
+          if (sub.isActive) {
+            await _activateAfterPurchase(offer, null, paywall, redirectRoute);
+            return;
+          }
+        } catch (_) {
+          // network / backend error → keep polling; disposal propagates to
+          // the outer catch on the next state.value access.
+        }
+      }
+
+      // Timed out — revert to paywall and ask the user to restore if they paid.
+      if (state.value is PremiumStateSending) {
+        state = AsyncData(PremiumState(offers: currentOffers, selectedOffer: offer));
+        final t = ref.read(translationsProvider);
+        ref.read(toastProvider).error(
+          title: t.premium.web_checkout_timeout_title,
+          text: t.premium.web_checkout_timeout_text,
+        );
+      }
+    } catch (_) {
+      // Provider was disposed while polling (user left the paywall). Ignore.
     }
   }
 
@@ -229,15 +270,45 @@ class PremiumStateNotifier extends _$PremiumStateNotifier {
 
     try {
       await _subscriptionRepository.restorePurchase();
+
+      // restorePurchase is a no-op on web (Stripe status lives server-side), so
+      // we re-read the backend to learn the real state: the webhook may have
+      // already written the subscription. Only flip to active when the backend
+      // actually confirms it — otherwise we'd show a false "restored" success.
+      final userId = _userState.user.idOrNull;
+      final restored = userId == null
+          ? null
+          : await _subscriptionRepository.get(userId);
       final t = ref.read(translationsProvider);
-      ref
-          .read(toastProvider)
-          .success(
-            title: t.premium.restore_success_title,
-            text: t.premium.restore_success_text,
-          );
-      await Future.delayed(const Duration(seconds: 2));
-      if (redirectRoute != null) ref.read(goRouterProvider).go(redirectRoute);
+
+      if (restored is SubscriptionStateData && restored.isActive) {
+        await ref
+            .read(userStateNotifierProvider.notifier)
+            .refreshSubscription(
+              product: restored.activeOffer,
+              entitlements: restored.entitlements,
+            );
+        state = AsyncData(
+          PremiumState.active(activeOffer: restored.activeOffer),
+        );
+        ref.read(toastProvider).success(
+          title: t.premium.restore_success_title,
+          text: t.premium.restore_success_text,
+        );
+        await Future.delayed(const Duration(seconds: 2));
+        if (redirectRoute != null) ref.read(goRouterProvider).go(redirectRoute);
+        return;
+      }
+
+      // Nothing to restore: revert to the paywall and tell the user, instead of
+      // a misleading success toast.
+      state = AsyncData(
+        PremiumStateData(offers: data.offers, selectedOffer: data.selectedOffer),
+      );
+      ref.read(toastProvider).alert(
+        title: t.premium.restore_none_title,
+        text: t.premium.restore_none_text,
+      );
     } catch (err, trace) {
       _logger.e("Error while restoring purchase: $err : $trace");
       state = AsyncData(

package/templates/firebase/lib/features/subscriptions/ui/widgets/premium_bottom_menu.dart

@@ -76,26 +76,19 @@ class BottomPremiumMenu extends StatelessWidget {
   Widget _buildRestoreButton(BuildContext context) {
     final translations = Translations.of(context).premium;
     final color = textColor ?? context.colors.muted;
+    // While a purchase / restore is in flight, onTapRestore is null. We keep the
+    // label visible but disabled instead of swapping it for a spinner, so the
+    // only loading indicator on the paywall is the main CTA button.
     return Padding(
       padding: const EdgeInsets.symmetric(horizontal: KasySpacing.sm),
-      child: onTapRestore != null
-          ? KasyButton(
-              variant: KasyButtonVariant.ghost,
-              label: translations.restore_action,
-              size: KasyButtonSize.small,
-              foregroundColor: color,
-              fontWeight: FontWeight.w500,
-              onPressed: onTapRestore,
-            )
-          : KasyButton.iconOnly(
-              icon: KasyIcons.refresh,
-              variant: KasyButtonVariant.ghost,
-              foregroundColor: color,
-              isLoading: true,
-              onPressed: null,
-              semanticLabel: translations.restore_action,
-              size: KasyButtonSize.small,
-            ),
+      child: KasyButton(
+        variant: KasyButtonVariant.ghost,
+        label: translations.restore_action,
+        size: KasyButtonSize.small,
+        foregroundColor: color,
+        fontWeight: FontWeight.w500,
+        onPressed: onTapRestore,
+      ),
     );
   }
 }

package/templates/firebase/lib/i18n/en.i18n.json

@@ -206,6 +206,10 @@
         "purchase_success_text": "Thank you for your trust",
         "error_title": "Error",
         "error_text": "An error occurred. Please try again",
+        "web_checkout_timeout_title": "Payment not confirmed",
+        "web_checkout_timeout_text": "We did not receive payment confirmation. If you already paid, tap Restore.",
+        "restore_none_title": "No subscription found",
+        "restore_none_text": "We could not find an active subscription to restore.",
         "comparison": {
             "title": "Premium plan comparison",
             "features_label": "Features",

package/templates/firebase/lib/i18n/es.i18n.json

@@ -206,6 +206,10 @@
         "purchase_success_text": "Gracias por tu confianza",
         "error_title": "Error",
         "error_text": "Ocurrió un error. Inténtalo de nuevo",
+        "web_checkout_timeout_title": "Pago no confirmado",
+        "web_checkout_timeout_text": "No recibimos confirmación del pago. Si ya pagaste, toca Restaurar.",
+        "restore_none_title": "No se encontró ninguna suscripción",
+        "restore_none_text": "No encontramos una suscripción activa para restaurar.",
         "comparison": {
             "title": "Comparación de planes Premium",
             "features_label": "Características",

package/templates/firebase/lib/i18n/pt.i18n.json

@@ -206,6 +206,10 @@
         "purchase_success_text": "Obrigado pela sua confiança",
         "error_title": "Erro",
         "error_text": "Ocorreu um erro. Tente novamente",
+        "web_checkout_timeout_title": "Pagamento não confirmado",
+        "web_checkout_timeout_text": "Não recebemos a confirmação do pagamento. Se você já pagou, toque em Restaurar.",
+        "restore_none_title": "Nenhuma assinatura encontrada",
+        "restore_none_text": "Não encontramos uma assinatura ativa para restaurar.",
         "comparison": {
             "title": "Comparação de planos Premium",
             "features_label": "Recursos",