Permette di filtrare il grafico analytics su una singola pagina.

Aggiunge il filtro Pagina (grafico) e il link Grafico in tabella, mantenendo Da/A/Device.

Co-authored-by: Cursor <cursoragent@cursor.com>

.cursor/rules/stream-soft-limit-scaling.mdc

@@ -0,0 +1,26 @@
+---
+description: Scalare soft limit ingest/autoscaler man mano che crescono i clienti
+alwaysApply: true
+---
+
+# Soft limit stream / autoscaler
+
+Con la crescita del numero di clienti (e delle dirette concorrenti attese), **alzare i soft limit** prima di restare a corto di capacità.
+
+Config rilevante (prod, tipicamente `infra/.env` + `StreamNode`):
+
+| Parametro | Ruolo (qualità-first 2026-09) |
+|-----------|-------------------------------|
+| `STREAM_NODE_HOME_MAX_PUBLISHERS` | Soft home (**4** — scale-out anticipato) |
+| `STREAM_CLOUD_MAX_PUBLISHERS` | Soft per CPX (**6**; 8 solo dopo misure QoS) |
+| `STREAM_AUTOSCALE_MAX_NODES` | Quanti CPX in parallelo (fase A **12** → B 22 → C 33) |
+| `STREAM_AUTOSCALE_SOFT_FREE_SLOTS` | Anticipo scale-out |
+| `STREAM_AUTOSCALE_MONTHLY_BUDGET_EUR` | Gate 24/7 (fase A **150**) |
+| `STREAM_AUTOSCALE_QUIET_HOURS` | `02:00-07:00` Europe/Rome: no scale-out/warm-spare; sweeper chiude CPX idle |
+| Piano `concurrent_streams_limit` | Tetto **per club** (Premium Full = 10): indipendente dal cluster |
+
+Capienza cluster soft ≈ `home_max + max_overflow × cloud_max` (fase A: 4+12×6 = **76**; fase C: 4+33×6 = **202**).
+
+Quiet hours: `Streams::NightCloudSweeper` + blocco provision in `Streams::Autoscaler`. Nodi cloud con sessioni attive di notte → alert Ops, non spegnere.
+
+Quando si parla di capacity planning, deploy autoscale, o “troppe dirette”, ricordare di rivedere questi valori (e il limite piano) in base ai clienti reali — non lasciare i soft limit di collaudo/early-prod a lungo. Densità 8 solo dopo misure.

backend/app/channels/session_channel.rb

@@ -55,6 +55,12 @@ class SessionChannel < ApplicationCable::Channel
       Sessions::Pause.new(session).call
     when "resume_stream"
       Sessions::Resume.new(session).call
+    when "mute_audio"
+      Sessions::SetAudioMute.new(session, muted: true).call
+    when "unmute_audio"
+      Sessions::SetAudioMute.new(session, muted: false).call
+    when "set_min_quality"
+      Sessions::SetMinQuality.new(session, preset: data["min_quality_preset"]).call
     end
   end
 

backend/app/controllers/admin/analytics_controller.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Admin
+  class AnalyticsController < Admin::BaseController
+    def index
+      @filters = {
+        from: parse_date(params[:from]) || 7.days.ago.to_date,
+        to: parse_date(params[:to]) || Time.zone.today,
+        device: params[:device].presence,
+        chart_path: params[:chart_path].presence
+      }
+      @analytics_preview_active = analytics_preview_active?
+
+      scope = AnalyticsPageStat.where(day: @filters[:from]..@filters[:to])
+      scope = scope.where(device: @filters[:device]) if @filters[:device].present? && AnalyticsEvent::DEVICES.include?(@filters[:device])
+
+      cell_scope = AnalyticsPageCell.where(day: @filters[:from]..@filters[:to])
+      cell_scope = cell_scope.where(device: @filters[:device]) if @filters[:device].present? && AnalyticsEvent::DEVICES.include?(@filters[:device])
+
+      clicks_by_path = cell_scope.group(:page_path).sum(:click_count)
+      moves_by_path = cell_scope.group(:page_path).sum(:move_count)
+      pageviews_by_path = scope.group(:page_path).sum(:pageview_count)
+      scroll_samples_by_path = scope.group(:page_path).sum(:scroll_samples)
+      scroll_sum_by_path = scope.group(:page_path).sum(:scroll_sum_pct)
+      max_scroll_by_path = scope.group(:page_path).maximum(:max_scroll_pct)
+
+      paths = (pageviews_by_path.keys + clicks_by_path.keys + moves_by_path.keys).uniq
+      @pages = paths.map do |path|
+        samples = scroll_samples_by_path[path].to_i
+        {
+          page_path: path,
+          pageviews: pageviews_by_path[path].to_i,
+          clicks: clicks_by_path[path].to_i,
+          moves: moves_by_path[path].to_i,
+          scroll_samples: samples,
+          scroll_sum: scroll_sum_by_path[path].to_i,
+          max_scroll: max_scroll_by_path[path].to_i
+        }
+      end.sort_by { |r| [-r[:pageviews], -r[:moves], -r[:clicks], r[:page_path]] }
+
+      @chart_path_options = @pages.map { |row| row[:page_path] }
+      if @filters[:chart_path].present? && @chart_path_options.exclude?(@filters[:chart_path])
+        @filters[:chart_path] = nil
+      end
+
+      trend_scope = scope
+      trend_scope = trend_scope.where(page_path: @filters[:chart_path]) if @filters[:chart_path].present?
+      pageviews_by_day = trend_scope.group(:day).sum(:pageview_count)
+      @trend = (@filters[:from]..@filters[:to]).map do |day|
+        {
+          day: day.iso8601,
+          pageviews: pageviews_by_day[day].to_i
+        }
+      end
+      @trend_totals = {
+        pageviews: @trend.sum { |r| r[:pageviews] }
+      }
+    end
+
+    def show
+      @page_path = params[:page_path].to_s
+      redirect_to admin_analytics_path, alert: t("admin.analytics.missing_path") and return if @page_path.blank?
+
+      from = parse_date(params[:from]) || 7.days.ago.to_date
+      to = parse_date(params[:to]) || Time.zone.today
+      @device_tab_stats = device_tab_stats(@page_path, from, to)
+      device = resolve_heatmap_device(@device_tab_stats, params[:device].presence)
+
+      @filters = {
+        from: from,
+        to: to,
+        device: device,
+        layer: params[:layer].to_s
+      }
+
+      cells = AnalyticsPageCell.where(
+        page_path: @page_path,
+        day: @filters[:from]..@filters[:to],
+        device: @filters[:device]
+      )
+
+      @click_total = cells.sum(:click_count)
+      @move_total = cells.sum(:move_count)
+      @filters[:layer] =
+        if %w[move click].include?(@filters[:layer])
+          @filters[:layer]
+        elsif @move_total.positive?
+          "move"
+        else
+          "click"
+        end
+
+      counter = @filters[:layer] == "click" ? :click_count : :move_count
+      @cells = cells.group(:cell_x, :cell_y).sum(counter)
+      @max_weight = @cells.values.max.to_i
+      @total_points = @cells.values.sum
+
+      stats = AnalyticsPageStat.where(
+        page_path: @page_path,
+        day: @filters[:from]..@filters[:to],
+        device: @filters[:device]
+      )
+      @pageviews = stats.sum(:pageview_count)
+      @scroll_samples = stats.sum(:scroll_samples)
+      @scroll_sum = stats.sum(:scroll_sum_pct)
+      @max_scroll = stats.maximum(:max_scroll_pct).to_i
+      @avg_scroll = @scroll_samples.positive? ? (@scroll_sum.to_f / @scroll_samples).round : 0
+      @grid = AnalyticsPageCell::GRID_SIZE
+      @snapshot = find_snapshot(@page_path, @filters[:device])
+    end
+
+    def preview_enable
+      Analytics::Suppress.enable!(cookies)
+      redirect_to preview_return_to(params[:return_to]), notice: t("admin.analytics.preview.enabled")
+    end
+
+    def preview_disable
+      Analytics::Suppress.disable!(cookies)
+      redirect_to admin_analytics_path, notice: t("admin.analytics.preview.disabled")
+    end
+
+    private
+
+    def analytics_preview_active?
+      Analytics::Suppress.active?(cookies[Analytics::Suppress::COOKIE_NAME])
+    end
+
+    def preview_return_to(value)
+      path = value.to_s.strip
+      return root_path if path.blank?
+      return path if path.start_with?("/") && !path.start_with?("//")
+
+      admin_analytics_path
+    end
+
+    def parse_date(value)
+      return nil if value.blank?
+
+      Date.parse(value.to_s)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def device_tab_stats(page_path, from, to)
+      cell_totals = AnalyticsPageCell.where(page_path: page_path, day: from..to)
+        .group(:device)
+        .pluck(
+          :device,
+          Arel.sql("SUM(click_count)"),
+          Arel.sql("SUM(move_count)")
+        )
+      cell_by_device = cell_totals.to_h { |device, clicks, moves| [device, { clicks: clicks.to_i, moves: moves.to_i }] }
+
+      pageview_totals = AnalyticsPageStat.where(page_path: page_path, day: from..to)
+        .group(:device)
+        .sum(:pageview_count)
+
+      AnalyticsEvent::DEVICES.index_with do |device|
+        cells = cell_by_device[device] || { clicks: 0, moves: 0 }
+        cells.merge(pageviews: pageview_totals[device].to_i)
+      end
+    end
+
+    def resolve_heatmap_device(tab_stats, requested)
+      if requested.present? && AnalyticsEvent::DEVICES.include?(requested)
+        return requested
+      end
+
+      AnalyticsEvent::DEVICES.max_by do |device|
+        stats = tab_stats[device]
+        stats[:clicks] + stats[:moves] + stats[:pageviews]
+      end
+    end
+
+    def find_snapshot(page_path, device)
+      return nil unless AnalyticsEvent::DEVICES.include?(device)
+
+      AnalyticsPageSnapshot.where(page_path: page_path, device: device)
+        .order(captured_at: :desc)
+        .detect { |snapshot| snapshot.image.attached? }
+    end
+  end
+end

backend/app/controllers/admin/announcements_controller.rb

@@ -0,0 +1,76 @@
+module Admin
+  class AnnouncementsController < Admin::BaseController
+    before_action :set_announcement, only: %i[edit update destroy]
+
+    def index
+      @announcements = AppAnnouncement.newest
+    end
+
+    def new
+      @announcement = AppAnnouncement.new(
+        kind: "info",
+        severity: "info",
+        status: "draft",
+        show_on_android: true,
+        show_on_ios: true,
+        show_on_web_public: true,
+        show_on_web_private: true,
+        dismissible: true
+      )
+    end
+
+    def create
+      @announcement = AppAnnouncement.new(announcement_params)
+      @announcement.created_by_admin = current_admin_account
+      if @announcement.save
+        redirect_to admin_announcements_path, notice: t("admin.flash.announcement_created")
+      else
+        flash.now[:alert] = @announcement.errors.full_messages.join(", ")
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @announcement.update(announcement_params)
+        redirect_to admin_announcements_path, notice: t("admin.flash.announcement_updated")
+      else
+        flash.now[:alert] = @announcement.errors.full_messages.join(", ")
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @announcement.destroy!
+      redirect_to admin_announcements_path, notice: t("admin.flash.announcement_destroyed")
+    end
+
+    private
+
+    def set_announcement
+      @announcement = AppAnnouncement.find(params[:id])
+    end
+
+    def announcement_params
+      params.require(:app_announcement).permit(
+        :kind, :severity, :status, :title, :body,
+        :action_url, :action_label, :dismissible, :starts_at, :ends_at,
+        :show_on_android, :show_on_ios, :show_on_web_public, :show_on_web_private,
+        translations: {
+          en: AppAnnouncement::COPY_KEYS,
+          fr: AppAnnouncement::COPY_KEYS,
+          de: AppAnnouncement::COPY_KEYS,
+          es: AppAnnouncement::COPY_KEYS
+        }
+      ).tap do |permitted|
+        %i[dismissible show_on_android show_on_ios show_on_web_public show_on_web_private].each do |key|
+          permitted[key] = ActiveModel::Type::Boolean.new.cast(permitted[key])
+        end
+        %i[starts_at ends_at action_url action_label].each do |key|
+          permitted[key] = nil if permitted[key].blank?
+        end
+      end
+    end
+  end
+end

backend/app/controllers/admin/auth_controller.rb

@@ -1,6 +1,8 @@
 module Admin
   class AuthController < Admin::BaseController
     skip_before_action :require_admin_login, only: %i[new create]
+    # Same as public logout: tolerate stale CSRF after long-lived admin tabs.
+    skip_before_action :verify_authenticity_token, only: :destroy
 
     def new
       redirect_to admin_root_path if admin_logged_in?

backend/app/controllers/admin/billing_controller.rb

@@ -2,6 +2,7 @@ module Admin
   class BillingController < BaseController
     def index
       @pending_payments = pending_scope.recent
+      @pending_transfers = transfer_scope
       @completed_payments = Billing::Payment.with_invoice_pdf.includes(:club, :invoice).recent.limit(40)
       @filter_club = Club.find_by(id: params[:club_id]) if params[:club_id].present?
       @clubs = Club.order(:name)
@@ -18,6 +19,25 @@ module Admin
                   alert: e.message
     end
 
+    def confirm_transfer
+      order = Billing::TransferOrder.find(params[:id])
+      Billing::ConfirmBankTransfer.call(
+        order: order,
+        admin: current_admin_account,
+        pdf: params[:pdf]
+      )
+      redirect_to admin_billing_path(club_id: order.club_id),
+                  notice: t("admin.flash.transfer_confirmed", plan: order.plan.name, club: order.club.name)
+    rescue Billing::ConfirmBankTransfer::Error, Billing::AttachPaymentInvoice::Error, Billing::IssueInvoice::Error => e
+      redirect_to admin_billing_path, alert: e.message
+    end
+
+    def cancel_transfer
+      order = Billing::TransferOrder.find(params[:id])
+      order.cancel!
+      redirect_to admin_billing_path(club_id: order.club_id), notice: t("admin.flash.transfer_cancelled")
+    end
+
     private
 
     def pending_scope
@@ -26,6 +46,12 @@ module Admin
       scope
     end
 
+    def transfer_scope
+      scope = Billing::TransferOrder.awaiting_payment.includes(:club, :requested_by_user)
+      scope = scope.where(club_id: params[:club_id]) if params[:club_id].present?
+      scope
+    end
+
     def billing_redirect_params(payment)
       { club_id: payment.club_id, anchor: "payment-#{payment.id}" }.compact
     end

backend/app/controllers/admin/clubs_controller.rb

@@ -1,9 +1,9 @@
 module Admin
   class ClubsController < BaseController
-    before_action :set_club, only: %i[show grant_comped revoke_comped]
+    before_action :set_club, only: %i[show grant_comped revoke_comped set_quote revoke_quote]
 
     def index
-      @clubs = Club.includes(:teams, subscription: %i[plan admin_comped_by])
+      @clubs = Club.includes(:teams, :billing_quote, subscription: %i[plan admin_comped_by])
                    .order(:name)
     end
 
@@ -11,6 +11,8 @@ module Admin
       @subscription = @club.subscription || @club.build_subscription(plan: Plan["free"], status: "active")
       @plans = Plan.ordered.reject { |p| p.slug == "free" }
       @teams = @club.teams.order(:name)
+      @quote = @club.active_billing_quote
+      @concurrency_violations = StreamConcurrencyViolation.for_club(@club.id).recent.limit(20)
     end
 
     def grant_comped
@@ -32,6 +34,32 @@ module Admin
       redirect_back_or_club alert: e.message
     end
 
+    def set_quote
+      quote = Billing::SetClubQuote.upsert(
+        club: @club,
+        plan_slug: params.require(:plan_slug),
+        interval: params[:interval],
+        amount_euros: params[:amount_euros],
+        note: params[:note],
+        admin: current_admin_account
+      )
+      redirect_back_or_club notice: t(
+        "admin.flash.quote_saved",
+        club: @club.name,
+        plan: quote.plan.name,
+        amount: quote.formatted_amount
+      )
+    rescue Billing::SetClubQuote::Error, ActionController::ParameterMissing => e
+      redirect_back_or_club alert: e.message
+    end
+
+    def revoke_quote
+      Billing::SetClubQuote.revoke(club: @club, admin: current_admin_account)
+      redirect_back_or_club notice: t("admin.flash.quote_revoked", club: @club.name)
+    rescue Billing::SetClubQuote::Error => e
+      redirect_back_or_club alert: e.message
+    end
+
     private
 
     def set_club

backend/app/controllers/admin/cost_entries_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Admin
+  class CostEntriesController < Admin::BaseController
+    before_action :set_entry, only: %i[edit update destroy]
+
+    def new
+      @entry = PlatformCostEntry.new(
+        month: parse_month(params[:month]) || Time.zone.today.beginning_of_month,
+        label: PlatformCostEntry::DEFAULT_LABEL
+      )
+    end
+
+    def create
+      @entry = PlatformCostEntry.new(entry_attributes)
+      if @entry.save
+        redirect_to admin_costs_path(month: month_param(@entry.month)), notice: t("admin.flash.cost_entry_created")
+      else
+        flash.now[:alert] = @entry.errors.full_messages.join(", ")
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @entry.update(entry_attributes)
+        redirect_to admin_costs_path(month: month_param(@entry.month)), notice: t("admin.flash.cost_entry_updated")
+      else
+        flash.now[:alert] = @entry.errors.full_messages.join(", ")
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      month = @entry.month
+      @entry.destroy!
+      redirect_to admin_costs_path(month: month_param(month)), notice: t("admin.flash.cost_entry_destroyed")
+    end
+
+    private
+
+    def set_entry
+      @entry = PlatformCostEntry.find(params[:id])
+    end
+
+    def entry_attributes
+      attrs = params.require(:platform_cost_entry).permit(:month, :label, :amount_euros, :notes)
+      if attrs[:amount_euros].present?
+        attrs[:amount_cents] = Billing::EuroAmount.to_cents(attrs.delete(:amount_euros))
+      end
+      attrs[:notes] = nil if attrs[:notes].blank?
+      attrs
+    end
+
+    def parse_month(value)
+      return nil if value.blank?
+
+      Date.strptime(value.to_s, "%Y-%m").beginning_of_month
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def month_param(date)
+      date.strftime("%Y-%m")
+    end
+  end
+end

backend/app/controllers/admin/costs_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Admin
+  class CostsController < Admin::BaseController
+    def index
+      @month = parse_month(params[:month]) || Time.zone.today.beginning_of_month
+      analytics = Admin::CostAnalytics.new(month: @month)
+      @summary = analytics.summary
+      @trend = analytics.trend
+      @clubs = analytics.club_breakdown
+      @entries = PlatformCostEntry.for_month(@month).ordered
+      @month_options = month_options(@month)
+    end
+
+    private
+
+    def parse_month(value)
+      return nil if value.blank?
+
+      Date.strptime(value.to_s, "%Y-%m").beginning_of_month
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def month_options(selected)
+      start = selected - 23.months
+      (0..23).map { |i| start + i.months }.reverse
+    end
+  end
+end

backend/app/controllers/admin/dashboard_controller.rb

@@ -5,9 +5,11 @@ module Admin
       @host = HostMetrics.new.sample!
       @active_sessions = StreamSession
         .where(status: DashboardStats::ACTIVE_STATUSES)
-        .includes(match: :team)
+        .includes(:stream_node, match: :team)
         .order(started_at: :desc)
       @teams = Team.includes(:matches).order(:name).limit(8)
+      @recent_concurrency_violations = StreamConcurrencyViolation.recent.limit(8)
+      @concurrency_violation_lookback = StreamConcurrencyViolation.lookback.count
     end
 
     def metrics

backend/app/controllers/admin/passwords_controller.rb

@@ -9,13 +9,23 @@ module Admin
         return render :edit, status: :unprocessable_entity
       end
 
-      if params[:password].blank? || params[:password].length < 8
-        flash.now[:alert] = t("admin.flash.password_too_short")
+      if params[:password] != params[:password_confirmation]
+        flash.now[:alert] = t("admin.flash.password_mismatch")
         return render :edit, status: :unprocessable_entity
       end
 
-      if params[:password] != params[:password_confirmation]
-        flash.now[:alert] = t("admin.flash.password_mismatch")
+      if (code = PasswordComplexity.violation(params[:password]))
+        key = case code
+              when :blank, :too_short then :password_too_short
+              when :too_long then :password_too_long
+              else :password_too_weak
+              end
+        flash.now[:alert] = t("admin.flash.#{key}")
+        return render :edit, status: :unprocessable_entity
+      end
+
+      if PasswordComplexity.same_as_current?(current_admin_account, params[:password])
+        flash.now[:alert] = t("admin.flash.password_same_as_current")
         return render :edit, status: :unprocessable_entity
       end
 

backend/app/controllers/admin/sessions_controller.rb

@@ -1,12 +1,24 @@
 module Admin
   class SessionsController < Admin::BaseController
     def index
-      @sessions = StreamSession.includes(:match, :user).order(created_at: :desc).limit(50)
+      @filters = session_filters
+      scope = filtered_sessions
+      @total_count = scope.count
+      @sessions = scope
+        .includes(:stream_node, :user, match: { team: :club })
+        .order(Arel.sql("COALESCE(stream_sessions.started_at, stream_sessions.created_at) DESC"))
+        .limit(100)
+      @clubs = Club.order(:name)
+      @nodes = StreamNode.order(:slug)
     end
 
     def show
-      @session = StreamSession.find(params[:id])
-      @events = @session.stream_events.recent.limit(50)
+      @session = StreamSession
+        .includes(:stream_node, :user, :device_states, :recording, match: { team: :club })
+        .find(params[:id])
+      @events = @session.stream_events.recent.limit(100)
+      @club = @session.match.team.club
+      @concurrency_violations = StreamConcurrencyViolation.for_session(@session.id).recent.limit(20)
     end
 
     def stop
@@ -39,5 +51,73 @@ module Admin
                     regia_expires_at: @session.regia_token_expires_at&.iso8601
                   }
     end
+
+    private
+
+    def session_filters
+      {
+        q: params[:q].to_s.strip.presence,
+        status: params[:status].to_s.strip.presence,
+        platform: params[:platform].to_s.strip.presence,
+        club_id: params[:club_id].to_s.strip.presence,
+        stream_node_id: params[:stream_node_id].to_s.strip.presence,
+        from: params[:from].to_s.strip.presence,
+        to: params[:to].to_s.strip.presence
+      }
+    end
+
+    def filtered_sessions
+      scope = StreamSession.left_outer_joins(match: { team: :club })
+
+      if @filters[:q].present?
+        term = "%#{ActiveRecord::Base.sanitize_sql_like(@filters[:q])}%"
+        scope = scope.where(
+          "teams.name ILIKE :term OR matches.opponent_name ILIKE :term OR clubs.name ILIKE :term OR matches.location ILIKE :term",
+          term: term
+        )
+      end
+
+      if @filters[:status].present? && StreamSession::STATUSES.include?(@filters[:status])
+        scope = scope.where(stream_sessions: { status: @filters[:status] })
+      end
+      if @filters[:platform].present? && StreamSession::LIVE_PLATFORMS.include?(@filters[:platform])
+        scope = scope.where(stream_sessions: { platform: @filters[:platform] })
+      end
+      if @filters[:club_id].present?
+        scope = scope.where(teams: { club_id: @filters[:club_id] })
+      end
+      if @filters[:stream_node_id].present?
+        node = StreamNode.find_by(id: @filters[:stream_node_id])
+        if node
+          scope = scope.where(
+            "stream_sessions.stream_node_id = :id OR stream_sessions.ingest_slug = :slug",
+            id: node.id,
+            slug: node.slug
+          )
+        end
+      end
+      if (from_time = parse_filter_date(@filters[:from], end_of_day: false))
+        scope = scope.where(
+          "COALESCE(stream_sessions.started_at, stream_sessions.created_at) >= ?",
+          from_time
+        )
+      end
+      if (to_time = parse_filter_date(@filters[:to], end_of_day: true))
+        scope = scope.where(
+          "COALESCE(stream_sessions.started_at, stream_sessions.created_at) <= ?",
+          to_time
+        )
+      end
+      scope
+    end
+
+    def parse_filter_date(value, end_of_day:)
+      return nil if value.blank?
+
+      date = Date.parse(value)
+      end_of_day ? date.end_of_day : date.beginning_of_day
+    rescue ArgumentError, TypeError
+      nil
+    end
   end
 end

backend/app/controllers/admin/stream_concurrency_violations_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Admin
+  class StreamConcurrencyViolationsController < Admin::BaseController
+    def index
+      @filters = {
+        q: params[:q].to_s.strip.presence,
+        devices_differ: params[:devices_differ].to_s == "1"
+      }
+      scope = StreamConcurrencyViolation.recent
+      if @filters[:q]
+        term = "%#{ActiveRecord::Base.sanitize_sql_like(@filters[:q])}%"
+        scope = scope.where(
+          "user_email ILIKE :term OR user_name ILIKE :term OR occupying_club_name ILIKE :term OR attempted_club_name ILIKE :term OR occupying_match_label ILIKE :term OR attempted_match_label ILIKE :term",
+          term: term
+        )
+      end
+      scope = scope.two_devices if @filters[:devices_differ]
+      @total_count = scope.count
+      @violations = scope.limit(200)
+      @lookback_count = StreamConcurrencyViolation.lookback.count
+      @two_devices_count = StreamConcurrencyViolation.lookback.two_devices.count
+    end
+  end
+end

backend/app/controllers/admin/stream_nodes_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Admin
+  class StreamNodesController < Admin::BaseController
+    def index
+      Streams::NodeRegistry.ensure_home_from_env!
+      @nodes = StreamNode.order(:role, :slug)
+      @dns_provider = ENV.fetch("STREAM_DNS_PROVIDER", "lab")
+      @cloud_provider = ENV.fetch("STREAM_CLOUD_PROVIDER", "local_lab")
+      @lab_hosts = lab_dns_snippet
+      @hetzner_configured = ENV["HCLOUD_TOKEN"].present?
+      @autoscale_metrics = Streams::Autoscaler.metrics
+    end
+
+    def create
+      kind = params[:kind].to_s
+      node =
+        if kind == "cloud"
+          Streams::NodeProvisioner.new.provision_cloud!
+        else
+          Streams::NodeProvisioner.new.provision_lab!
+        end
+      redirect_to admin_stream_nodes_path,
+                  notice: t("admin.flash.stream_node_created", slug: node.slug)
+    rescue Streams::NodeProvisioner::Error, Streams::CloudProviders::Error, Streams::DnsProviders::Error,
+           KeyError => e
+      redirect_to admin_stream_nodes_path, alert: e.message
+    end
+
+    def drain
+      node = StreamNode.find(params[:id])
+      Streams::NodeProvisioner.new.drain!(node)
+      redirect_to admin_stream_nodes_path, notice: t("admin.flash.stream_node_draining", slug: node.slug)
+    rescue Streams::NodeProvisioner::Error => e
+      redirect_to admin_stream_nodes_path, alert: e.message
+    end
+
+    def destroy
+      node = StreamNode.find(params[:id])
+      Streams::NodeProvisioner.new.decommission!(node)
+      redirect_to admin_stream_nodes_path, notice: t("admin.flash.stream_node_destroyed", slug: node.slug)
+    rescue Streams::NodeProvisioner::BusyError, Streams::NodeProvisioner::Error,
+           Streams::CloudProviders::Error, Streams::DnsProviders::Error => e
+      redirect_to admin_stream_nodes_path, alert: e.message
+    end
+
+    def kill_switch
+      Streams::Autoscaler.engage_kill_switch!
+      redirect_to admin_stream_nodes_path, notice: t("admin.flash.autoscale_kill_on")
+    end
+
+    def clear_kill_switch
+      Streams::Autoscaler.clear_kill_switch!
+      redirect_to admin_stream_nodes_path, notice: t("admin.flash.autoscale_kill_off")
+    end
+
+    private
+
+    def lab_dns_snippet
+      return "" unless @dns_provider == "lab"
+
+      Streams::DnsProviders::Lab.new.hosts_file_snippet
+    rescue Redis::BaseError
+      ""
+    end
+  end
+end

backend/app/controllers/analytics/events_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Analytics
+  class EventsController < ActionController::API
+    include ActionController::Cookies
+
+    def create
+      if analytics_suppressed?
+        return render json: { accepted: 0, rejected: 0, suppressed: true }, status: :accepted
+      end
+
+      payload = parse_payload
+      result = Analytics::Ingest.new(events: payload, remote_ip: request.remote_ip).call
+
+      if result.rate_limited
+        return head :too_many_requests
+      end
+
+      render json: { accepted: result.accepted, rejected: result.rejected }, status: :accepted
+    end
+
+    private
+
+    def analytics_suppressed?
+      Analytics::Suppress.active?(cookies[Analytics::Suppress::COOKIE_NAME])
+    end
+
+    def parse_payload
+      body = request.request_parameters
+      return body["events"] if body.is_a?(Hash) && body["events"].is_a?(Array)
+      return body if body.is_a?(Array)
+
+      raw = request.raw_post
+      return [] if raw.blank?
+
+      parsed = JSON.parse(raw)
+      return parsed["events"] if parsed.is_a?(Hash) && parsed["events"].is_a?(Array)
+      return parsed if parsed.is_a?(Array)
+
+      []
+    rescue JSON::ParserError
+      []
+    end
+  end
+end

backend/app/controllers/analytics/snapshots_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Analytics
+  class SnapshotsController < ActionController::API
+    include ActionController::Cookies
+
+    def create
+      if analytics_suppressed?
+        return render json: { ok: true, skipped: true, suppressed: true }, status: :accepted
+      end
+
+      result = Analytics::SnapshotIngest.new(
+        path: params[:path] || params[:page_path],
+        device: params[:device],
+        width: params[:width],
+        height: params[:height],
+        image: params[:image],
+        remote_ip: request.remote_ip
+      ).call
+
+      return head :too_many_requests if result.rate_limited
+      return render json: { ok: false, error: result.error }, status: :unprocessable_content unless result.ok
+
+      render json: { ok: true, skipped: result.skipped }, status: :accepted
+    end
+
+    private
+
+    def analytics_suppressed?
+      Analytics::Suppress.active?(cookies[Analytics::Suppress::COOKIE_NAME])
+    end
+  end
+end

backend/app/controllers/api/v1/accounts_controller.rb

@@ -0,0 +1,60 @@
+module Api
+  module V1
+    class AccountsController < ApplicationController
+      def show
+        render json: user_json(current_user)
+      end
+
+      def update
+        name = params[:name].to_s.strip
+        if name.blank?
+          return render json: { error: I18n.t("flash.accounts.name_required") }, status: :unprocessable_entity
+        end
+
+        if current_user.update(name: name)
+          render json: user_json(current_user)
+        else
+          render json: { error: current_user.errors.full_messages.join(", ") }, status: :unprocessable_entity
+        end
+      end
+
+      def password
+        result = Users::ChangePassword.call(
+          user: current_user,
+          current_password: params[:current_password],
+          password: params[:password],
+          password_confirmation: params[:password_confirmation]
+        )
+
+        unless result.ok?
+          return render json: { error: password_error_message(result.error) }, status: :unprocessable_entity
+        end
+
+        render json: { message: I18n.t("flash.accounts.password_updated") }
+      end
+
+      private
+
+      def user_json(user)
+        {
+          id: user.id,
+          email: user.email,
+          name: user.name,
+          role: user.role
+        }
+      end
+
+      def password_error_message(code)
+        case code
+        when :current_incorrect then I18n.t("flash.accounts.password_current_incorrect")
+        when :too_short then I18n.t("flash.accounts.password_too_short")
+        when :too_long then I18n.t("flash.accounts.password_too_long")
+        when :too_weak then I18n.t("flash.accounts.password_too_weak")
+        when :same_as_current then I18n.t("flash.accounts.password_same_as_current")
+        when :mismatch then I18n.t("flash.accounts.password_mismatch")
+        else I18n.t("flash.accounts.password_update_failed")
+        end
+      end
+    end
+  end
+end

backend/app/controllers/api/v1/announcements_controller.rb

@@ -0,0 +1,13 @@
+module Api
+  module V1
+    class AnnouncementsController < BaseController
+      skip_before_action :authenticate_request!
+
+      def index
+        platform = params[:platform].to_s.presence
+        announcements = AppAnnouncement.for_platform(platform).newest
+        render json: announcements.map { |item| item.as_api_json(platform: platform) }
+      end
+    end
+  end
+end

backend/app/controllers/api/v1/auth_controller.rb

@@ -1,7 +1,7 @@
 module Api
   module V1
     class AuthController < ApplicationController
-      skip_before_action :authenticate_request!, only: %i[login refresh register]
+      skip_before_action :authenticate_request!, only: %i[login refresh register forgot_password]
 
       def register
         user = User.new(
@@ -22,18 +22,18 @@ module Api
         if user&.authenticate(params[:password])
           render json: token_response(user), status: :ok
         else
-          render json: { error: "Invalid credentials" }, status: :unauthorized
+          render json: { error: I18n.t("flash.sessions.invalid_credentials") }, status: :unauthorized
         end
       end
 
       def logout
-        render json: { message: "Logged out" }
+        render json: { message: I18n.t("flash.sessions.logged_out") }
       end
 
       def refresh
         payload = JsonWebToken.decode(params[:refresh_token] || bearer_token)
         user = User.find_by(id: payload&.dig(:user_id))
-        return render json: { error: "Invalid token" }, status: :unauthorized unless user
+        return render json: { error: I18n.t("flash.sessions.invalid_token") }, status: :unauthorized unless user
 
         render json: token_response(user)
       end
@@ -42,6 +42,13 @@ module Api
         render json: user_json(current_user)
       end
 
+      def forgot_password
+        Users::RequestPasswordReset.call(email: params[:email])
+        render json: {
+          message: I18n.t("flash.password_resets.email_sent")
+        }
+      end
+
       private
 
       def token_response(user)

backend/app/controllers/api/v1/base_controller.rb

@@ -2,6 +2,8 @@ module Api
   module V1
     class BaseController < ApplicationController
       rescue_from Teams::EntitlementError, with: :render_entitlement_error
+      rescue_from Streams::IngestUnavailableError, with: :render_ingest_unavailable
+      rescue_from BrandingAttachments::CoverUploadError, with: :render_cover_upload_error
       rescue_from Youtube::BroadcastService::Error, with: :render_youtube_error
 
       private
@@ -20,6 +22,17 @@ module Api
           billing_url: error.billing_url
         }, status: :forbidden
       end
+
+      def render_ingest_unavailable(error)
+        render json: {
+          error: error.message,
+          error_code: error.code
+        }, status: :service_unavailable
+      end
+
+      def render_cover_upload_error(error)
+        render json: { error: error.message, error_code: "cover_upload_invalid" }, status: :unprocessable_entity
+      end
     end
   end
 end

backend/app/controllers/api/v1/invitations_controller.rb

@@ -9,34 +9,23 @@ module Api
           return render json: { valid: false, error: "Invito non valido o scaduto" }, status: :not_found
         end
 
-        render json: {
-          valid: true,
-          email: invitation.email,
-          team_id: invitation.team_id,
-          team_name: invitation.team.name,
-          club_name: invitation.team.club.name,
-          staff_kind: invitation.staff_kind,
-          expires_at: invitation.expires_at
-        }
+        render json: invitation_json(invitation).merge(valid: true)
       end
 
       def accept
         invitation = find_pending_invitation
         return render json: { error: "Invito non valido o scaduto" }, status: :not_found unless invitation
 
-        if current_user.email.downcase != invitation.email.downcase
+        email = invitation.email
+        if current_user.email.downcase != email.downcase
           return render json: {
-            error: "Questo invito è per #{invitation.email}. Accedi con quell'indirizzo email.",
-            invited_email: invitation.email
+            error: "Questo invito è per #{email}. Accedi con quell'indirizzo email.",
+            invited_email: email
           }, status: :unprocessable_entity
         end
 
         invitation.accept!(current_user)
-        render json: {
-          team_id: invitation.team_id,
-          team_name: invitation.team.name,
-          message: "Sei entrato in #{invitation.team.name} come responsabile trasmissione."
-        }
+        render json: invitation_json(invitation).merge(message: accept_message(invitation))
       end
 
       private
@@ -45,7 +34,42 @@ module Api
         token = params[:token].to_s
         return nil if token.blank?
 
-        TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(token))
+        digest = Digest::SHA256.hexdigest(token)
+        TeamInvitation.pending.find_by(token_digest: digest) ||
+          TournamentBroadcastInvitation.pending.find_by(token_digest: digest)
+      end
+
+      def invitation_json(invitation)
+        if invitation.is_a?(TournamentBroadcastInvitation)
+          tournament = invitation.tournament
+          {
+            email: invitation.email,
+            tournament_id: tournament.id,
+            tournament_name: tournament.name,
+            club_name: tournament.club.name,
+            team_id: tournament.broadcast_team_id,
+            team_name: tournament.name,
+            staff_kind: "transmission",
+            expires_at: invitation.expires_at
+          }
+        else
+          {
+            email: invitation.email,
+            team_id: invitation.team_id,
+            team_name: invitation.team.name,
+            club_name: invitation.team.club.name,
+            staff_kind: invitation.staff_kind,
+            expires_at: invitation.expires_at
+          }
+        end
+      end
+
+      def accept_message(invitation)
+        if invitation.is_a?(TournamentBroadcastInvitation)
+          "Sei incaricato delle dirette per #{invitation.tournament.name}."
+        else
+          "Sei entrato in #{invitation.team.name} come responsabile trasmissione."
+        end
       end
     end
   end

backend/app/controllers/api/v1/matches_controller.rb

@@ -2,6 +2,7 @@ module Api
   module V1
     class MatchesController < BaseController
       include Api::UrlHelper
+      include Api::CoverJson
       include BrandingAttachments
 
       before_action :set_team, only: %i[index create]
@@ -9,18 +10,28 @@ module Api
 
       def index
         matches = @team.matches
-          .includes(:team, :stream_sessions)
+          .includes(:team, :stream_sessions, :home_participant, :away_participant, :tournament)
           .order(Arel.sql("scheduled_at ASC NULLS LAST"), created_at: :desc)
-          .select(&:coach_hub_visible?)
-        render json: matches.map { |m| match_json(m) }
+        unless current_user.club_admin?(@team.club)
+          if @team.tournament_broadcast?
+            assigned_ids = current_user.tournament_broadcast_assignments.select(:match_id)
+            matches = matches.where(id: assigned_ids)
+          end
+        end
+        render json: matches.select(&:coach_hub_visible?).map { |m| match_json(m) }
       end
 
       def create
+        if @team.tournament_broadcast?
+          return render json: { error: "Le partite del torneo si programmano dal sito web." }, status: :unprocessable_entity
+        end
+
         attrs = match_params.to_h
         attrs["sport_key"] = @team.sport_key
         normalize_scoring_rules!(attrs)
         match = @team.matches.create!(attrs)
         attach_opponent_logo(match)
+        attach_match_cover(match)
         render json: match_json(match), status: :created
       end
 
@@ -34,6 +45,7 @@ module Api
         normalize_opponent_color!(attrs)
         @match.update!(attrs)
         attach_opponent_logo(@match)
+        attach_match_cover(@match)
         render json: match_json(@match)
       end
 
@@ -98,15 +110,23 @@ module Api
         match.opponent_logo_file.attach(file) if file.present?
       end
 
+      def attach_match_cover(match)
+        attach_cover_image(match, entitlements: match.team.entitlements)
+        enqueue_cover_slate_generation(match)
+      end
+
       def match_json(match, detail: false)
         active = active_session_for(match)
         team = match.team
         {
           id: match.id,
           team_id: match.team_id,
-          team_name: team.name,
-          opponent_name: match.opponent_name,
-          location: match.location,
+          team_name: match.home_display_name,
+          opponent_name: match.away_display_name,
+          location: match.court_or_location,
+          court: match.court,
+          tournament_id: match.tournament_id,
+          tournament_name: match.tournament&.name,
           scheduled_at: match.scheduled_at,
           sport: match.sport_key,
           sport_key: match.sport_key,
@@ -118,11 +138,12 @@ module Api
           scoring_rules: match.scoring_rules.presence,
           effective_scoring_rules: match.effective_scoring_rules,
           category: match.category,
-          home_primary_color: team.effective_primary_color,
-          home_secondary_color: team.effective_secondary_color,
-          home_logo_url: api_absolute_url(team.effective_logo_url),
-          opponent_primary_color: match.effective_opponent_primary_color,
-          opponent_logo_url: api_absolute_url(match.opponent_logo_url),
+          home_primary_color: match.home_participant&.effective_primary_color || team.effective_primary_color,
+          home_secondary_color: match.home_participant&.effective_secondary_color || team.effective_secondary_color,
+          home_logo_url: api_absolute_url(match.home_participant&.effective_logo_url || team.effective_logo_url),
+          opponent_primary_color: match.away_participant&.effective_primary_color || match.effective_opponent_primary_color,
+          opponent_logo_url: api_absolute_url(match.away_participant&.effective_logo_url || match.opponent_logo_url),
+          **match_cover_json(match),
           active_session_id: active&.id,
           active_session_status: active&.status,
           stream_completed: match.stream_completed?,

backend/app/controllers/api/v1/recordings_controller.rb

@@ -97,10 +97,11 @@ module Api
           replay_url: recording.replay_url,
           playback_url: recording.playback_stream_url,
           thumbnail_url: recording.thumbnail_url,
-          download_enabled: ent.phone_download_enabled?,
+          download_enabled: ent.phone_download_enabled? && recording.storage_key.present?,
           youtube_video_id: recording.youtube_video_id,
           youtube_watch_url: recording.youtube_watch_url,
-          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled?,
+          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled? && recording.storage_key.present? && recording.youtube_video_id.blank?,
+          replay_source: recording.replay_source,
           source_platform: recording.source_platform,
           source_platform_label: recording.source_platform_label,
           expires_at: recording.expires_at,

backend/app/controllers/api/v1/stream_sessions_controller.rb

@@ -6,6 +6,10 @@ module Api
       def create
         team_ids = current_user.streamable_teams.map(&:id)
         match = Match.where(team_id: team_ids).find(params[:match_id])
+        unless current_user.can_broadcast_match?(match)
+          return render json: { error: "Non sei incaricato di trasmettere questa partita" }, status: :forbidden
+        end
+
         session = Sessions::Create.new(user: current_user, match: match, params: session_params).call
         render json: session_json(session), status: :created
       end
@@ -34,6 +38,12 @@ module Api
         render json: session_json(@session)
       end
 
+      def audio_mute
+        muted = params.key?(:muted) ? params[:muted] : true
+        Sessions::SetAudioMute.new(@session, muted: muted).call
+        render json: session_json(@session)
+      end
+
       def score
         Scoring::SyncState.new(session: @session, payload: score_sync_params).call
         render json: session_json(@session, detail: true)
@@ -68,8 +78,10 @@ module Api
           current_bitrate: params[:current_bitrate],
           target_bitrate: params[:target_bitrate],
           fps: params[:fps],
+          thermal_state: sanitized_thermal_state,
           last_seen_at: Time.current
         )
+        Sessions::ApplyClientInfo.call(@session, params[:client]) if params[:client].present?
         sync_publisher_when_streaming!(params[:fps].to_f)
         SessionChannel.broadcast_message(@session, state.as_cable_payload)
         head :no_content
@@ -141,6 +153,13 @@ module Api
         }
       end
 
+      def min_quality
+        Sessions::SetMinQuality.new(@session, preset: params[:min_quality_preset]).call
+        render json: session_json(@session)
+      rescue ArgumentError => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      end
+
       def youtube_stats
         count = if @session.platform == "youtube" && @session.youtube_broadcast_id.present?
                   Youtube::BroadcastService.new(@session.match.team)
@@ -160,8 +179,18 @@ module Api
                                 .find(params[:id])
       end
 
+      def sanitized_thermal_state
+        value = params[:thermal_state].to_s.downcase.presence
+        value if value.in?(%w[nominal fair serious critical])
+      end
+
       def session_params
-        params.permit(:platform, :privacy_status, :quality_preset, :target_bitrate, :target_fps, :youtube_channel)
+        params.permit(
+          :platform, :privacy_status, :quality_preset, :target_bitrate, :target_fps, :youtube_channel,
+          client: %i[os client_os app_version app_build version build build_number
+                     device_manufacturer manufacturer device_model model
+                     os_version system_version carrier network_operator operator]
+        )
       end
 
       def score_sync_params
@@ -180,6 +209,7 @@ module Api
           platform: session.platform,
           rtmp_ingest_url: session.rtmp_ingest_url,
           hls_playback_url: session.hls_playback_url,
+          stream_node: session.stream_node&.slug,
           watch_page_url: session.matchlivetv_platform? ? session.watch_page_url : nil,
           share_url: session.share_url,
           youtube_watch_url: session.youtube_watch_url,
@@ -187,9 +217,11 @@ module Api
           youtube_ready: session.youtube_ready?,
           privacy_status: session.privacy_status,
           quality_preset: session.quality_preset,
+          min_quality_preset: session.min_quality_preset,
           target_bitrate: session.target_bitrate,
           started_at: session.started_at,
-          disconnection_count: session.disconnection_count
+          disconnection_count: session.disconnection_count,
+          audio_muted: session.audio_muted
         }
         if detail
           data[:score] = session.score_state&.as_cable_payload

backend/app/controllers/api/v1/teams_controller.rb

@@ -110,6 +110,9 @@ module Api
           secondary_color: team.effective_secondary_color,
           club_id: team.club_id,
           club_name: team.club.name,
+          tournament_broadcast: team.tournament_broadcast?,
+          tournament_id: team.broadcast_tournament&.id,
+          tournament_name: team.broadcast_tournament&.name,
           youtube_connected: yt.connected?,
           youtube_selectable: yt.selectable?,
           youtube_channel_title: yt.channel_title,
@@ -137,7 +140,8 @@ module Api
           youtube_mode: ent.plan.youtube_mode,
           staff_role: current_user.staff_role_for(team),
           can_stream: current_user.can_stream_for?(team),
-          can_connect_youtube: team.club.owned_by?(current_user) && ent.premium_full? && ent.youtube_enabled?
+          can_connect_youtube: team.club.owned_by?(current_user) && ent.premium_full? && ent.youtube_enabled?,
+          custom_cover_enabled: ent.can_use_custom_cover?
         }
         if detail
           data[:members] = team.user_teams.includes(:user).where.not(role: "owner").map do |ut|
@@ -170,12 +174,13 @@ module Api
           replay_url: recording.replay_url,
           playback_url: recording.playback_stream_url,
           thumbnail_url: recording.thumbnail_url,
-          download_enabled: ent.phone_download_enabled?,
+          download_enabled: ent.phone_download_enabled? && recording.storage_key.present?,
           view_count: recording.view_count,
           views_label: recording.views_label,
           youtube_video_id: recording.youtube_video_id,
           youtube_watch_url: recording.youtube_watch_url,
-          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled?,
+          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled? && recording.storage_key.present? && recording.youtube_video_id.blank?,
+          replay_source: recording.replay_source,
           source_platform: recording.source_platform,
           source_platform_label: recording.source_platform_label,
           expires_at: recording.expires_at,

backend/app/controllers/application_controller.rb

@@ -1,17 +1,25 @@
 class ApplicationController < ActionController::API
   include ActionController::HttpAuthentication::Token::ControllerMethods
 
+  before_action :set_api_locale
   before_action :authenticate_request!
 
   attr_reader :current_user
 
   private
 
+  def set_api_locale
+    explicit = LocaleResolver.normalize(request.headers["X-Locale"])
+    I18n.locale = explicit ||
+                  LocaleResolver.from_accept_language(request.headers["Accept-Language"]) ||
+                  I18n.default_locale
+  end
+
   def authenticate_request!
     token = bearer_token
     payload = JsonWebToken.decode(token)
     @current_user = User.find_by(id: payload[:user_id]) if payload
-    render json: { error: "Unauthorized" }, status: :unauthorized unless @current_user
+    render json: { error: I18n.t("flash.sessions.unauthorized") }, status: :unauthorized unless @current_user
   end
 
   def bearer_token

backend/app/controllers/concerns/api/cover_json.rb

@@ -0,0 +1,16 @@
+module Api
+  module CoverJson
+    extend ActiveSupport::Concern
+
+    private
+
+    def match_cover_json(match)
+      resolver = Streams::CoverResolver.new(match)
+      {
+        effective_cover_url: api_absolute_url(resolver.effective_cover_url),
+        cover_source: resolver.cover_source,
+        custom_cover_enabled: match.team.entitlements.can_use_custom_cover?
+      }
+    end
+  end
+end

backend/app/controllers/concerns/branding_attachments.rb

@@ -8,6 +8,48 @@ module BrandingAttachments
     record.logo_file.attach(file) if file.present?
   end
 
+  def attach_cover_image(record, entitlements:)
+    remove_flag = params[:remove_cover].to_s == "1" || params.dig(:match, :remove_cover).to_s == "1"
+    if remove_flag
+      record.cover_image.purge if record.cover_image.attached?
+      record.cover_slate.purge if record.cover_slate.attached?
+      return
+    end
+
+    file = params.dig(:branding, :cover_image) || params[:cover_image]
+    return if file.blank?
+
+    entitlements.assert_can_upload_cover!
+    validate_cover_file!(file)
+    record.cover_slate.purge if record.cover_slate.attached?
+    record.cover_image.attach(file)
+  end
+
+  def validate_cover_file!(file)
+    allowed_types = Coverable::COVER_IMAGE_TYPES
+
+    # Rileva MIME dal contenuto (magic bytes) ignorando il declared_type del client.
+    io = file.respond_to?(:tempfile) ? file.tempfile : file
+    io.rewind if io.respond_to?(:rewind)
+    detected = Marcel::MimeType.for(io, name: file.respond_to?(:original_filename) ? file.original_filename : nil)
+    io.rewind if io.respond_to?(:rewind)
+
+    unless detected.in?(allowed_types)
+      raise CoverUploadError, I18n.t("coverable.errors.invalid_type")
+    end
+
+    byte_size = file.respond_to?(:size) ? file.size : File.size(file.path)
+    if byte_size > Coverable::MAX_COVER_BYTES
+      raise CoverUploadError, I18n.t("coverable.errors.too_large")
+    end
+  end
+
+  class CoverUploadError < StandardError; end
+
+  def enqueue_cover_slate_generation(record)
+    GenerateCoverSlateJob.enqueue_for(record) if record.cover_image.attached?
+  end
+
   def normalize_hex_color(value, fallback)
     v = value.to_s.strip
     v = "##{v}" if v.match?(/\A[0-9A-Fa-f]{6}\z/)

backend/app/controllers/concerns/mediamtx_playback.rb

@@ -4,11 +4,20 @@ module MediamtxPlayback
   private
 
   def mediamtx_paths_index
-    @mediamtx_paths_index ||= Mediamtx::Client.new.list_paths.index_by { |i| i["name"] }
+    mediamtx_paths_index_for_url(MatchLiveTv.mediamtx_api_url)
+  end
+
+  def mediamtx_paths_index_for(session)
+    mediamtx_paths_index_for_url(session.mediamtx_api_base_url)
+  end
+
+  def mediamtx_paths_index_for_url(api_url)
+    @mediamtx_paths_by_origin ||= {}
+    @mediamtx_paths_by_origin[api_url] ||= Mediamtx::Client.new(base_url: api_url).list_paths.index_by { |i| i["name"] }
   end
 
   def mediamtx_path_info(session, path_name: mediamtx_playback_path_name(session))
-    mediamtx_paths_index[path_name]
+    mediamtx_paths_index_for(session)[path_name]
   end
 
   def mediamtx_playback_path_name(session)
@@ -28,7 +37,7 @@ module MediamtxPlayback
   end
 
   def mediamtx_publisher_online?(session)
-    info = mediamtx_paths_index[session.mediamtx_path_name]
+    info = mediamtx_paths_index_for(session)[session.mediamtx_path_name]
     info && info["online"]
   end
 end

backend/app/controllers/hls_proxy_controller.rb

@@ -20,7 +20,8 @@ class HlsProxyController < ActionController::Base
   def proxy_mediamtx_path(upstream_path)
     return head :not_found if upstream_path.blank?
 
-    upstream = "#{MatchLiveTv.mediamtx_hls_url}/#{upstream_path}"
+    origin = hls_origin_for(upstream_path)
+    upstream = "#{origin}/#{upstream_path}"
     upstream = "#{upstream}?#{request.query_string}" if request.query_string.present?
     cookie = request.headers["Cookie"].presence || "cookieCheck=1"
 
@@ -30,7 +31,7 @@ class HlsProxyController < ActionController::Base
       if response.status.in?([301, 302, 307, 308])
         location = response.headers["location"].to_s
         cookie = cookie_from_set_header(response.headers["set-cookie"]).presence || cookie
-        upstream = resolve_upstream_url(location)
+        upstream = resolve_upstream_url(location, origin)
         next
       end
 
@@ -43,10 +44,21 @@ class HlsProxyController < ActionController::Base
     head :bad_gateway
   end
 
-  def resolve_upstream_url(location)
+  def hls_origin_for(upstream_path)
+    session_id = upstream_path[/\Alive\/match_([0-9a-f-]{36})/i, 1]
+    if session_id
+      session = StreamSession.find_by(id: session_id)
+      node_hls = session&.stream_node&.internal_hls_url.presence
+      return node_hls.sub(%r{/$}, "") if node_hls.present?
+    end
+
+    MatchLiveTv.mediamtx_hls_url.sub(%r{/$}, "")
+  end
+
+  def resolve_upstream_url(location, origin)
     return location if location.start_with?("http://", "https://")
 
-    base = MatchLiveTv.mediamtx_hls_url.sub(%r{/$}, "")
+    base = origin.to_s.sub(%r{/$}, "")
     location.start_with?("/") ? "#{base}#{location}" : "#{base}/#{location}"
   end
 

backend/app/controllers/public/accounts_controller.rb

@@ -0,0 +1,39 @@
+module Public
+  class AccountsController < WebBaseController
+    before_action :require_login!
+
+    def show
+    end
+
+    def update
+      name = params[:name].to_s.strip
+      if name.blank?
+        flash.now[:alert] = t("flash.accounts.name_required")
+        return render :show, status: :unprocessable_entity
+      end
+
+      if current_user.update(name: name)
+        redirect_to public_account_path, notice: t("flash.accounts.profile_updated")
+      else
+        flash.now[:alert] = current_user.errors.full_messages.to_sentence
+        render :show, status: :unprocessable_entity
+      end
+    end
+
+    def update_password
+      result = Users::ChangePassword.call(
+        user: current_user,
+        current_password: params[:current_password],
+        password: params[:password],
+        password_confirmation: params[:password_confirmation]
+      )
+
+      unless result.ok?
+        redirect_to public_account_path, alert: t("flash.accounts.password_#{result.error}")
+        return
+      end
+
+      redirect_to public_account_path, notice: t("flash.accounts.password_updated")
+    end
+  end
+end

backend/app/controllers/public/club_billing_controller.rb

@@ -11,11 +11,15 @@ module Public
       @club.assign_attributes(billing_profile_params)
       if @club.save(context: :billing_profile)
         if premium_checkout_return_params.present? && @club.billing_profile_complete?
-          redirect_to public_club_checkout_path(
-            @club,
-            plan: premium_checkout_return_params[:plan],
-            interval: premium_checkout_return_params[:interval]
-          ), notice: t("flash.club_billing.profile_saved_proceed_payment")
+          if @club.active_billing_quote.present?
+            redirect_to public_club_billing_path(@club), notice: t("flash.club_billing.profile_updated")
+          else
+            redirect_to public_club_checkout_path(
+              @club,
+              plan: premium_checkout_return_params[:plan],
+              interval: premium_checkout_return_params[:interval]
+            ), notice: t("flash.club_billing.profile_saved_proceed_payment")
+          end
         else
           redirect_to public_club_billing_path(@club), notice: t("flash.club_billing.profile_updated")
         end
@@ -42,6 +46,29 @@ module Public
       redirect_to public_club_billing_path(@club), alert: t("flash.club_billing.stripe_error", message: e.message)
     end
 
+    def request_bank_transfer
+      if @club.subscription&.admin_comped?
+        redirect_to public_club_billing_path(@club), alert: t("flash.clubs.comped_change_denied")
+        return
+      end
+
+      unless @club.billing_profile_complete?
+        redirect_to public_club_billing_profile_path(@club, plan: params[:plan], interval: params[:interval]),
+                    alert: t("flash.clubs.complete_billing_first")
+        return
+      end
+
+      Billing::RequestBankTransfer.call(
+        club: @club,
+        user: current_user,
+        plan_slug: params[:plan],
+        interval: params[:interval]
+      )
+      redirect_to public_club_billing_path(@club), notice: t("flash.club_billing.bank_transfer_requested")
+    rescue Billing::RequestBankTransfer::Error, ArgumentError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
     def download_invoice
       invoice = @club.billing_invoices.find(params[:invoice_id])
       unless invoice.pdf.attached?

backend/app/controllers/public/clubs_controller.rb

@@ -23,23 +23,28 @@ module Public
       ClubMembership.create!(user: current_user, club: club, role: "owner")
 
       first_team_name = params.dig(:first_team, :name).presence || t("club.new.default_first_team_name")
-      club.teams.create!(
+      first_team = club.teams.create!(
         name: first_team_name,
         sport: club.sport
       )
 
-      plan = params[:plan].presence_in(%w[free premium_light premium_full]) || "free"
-      Billing::AssignPlan.call(club: club, plan_slug: plan)
+      desired_plan = params[:plan].presence_in(%w[free premium_light premium_full]) || "free"
+      Billing::AssignPlan.call(club: club, plan_slug: "free")
+      Teams::StaffAssignment.designate_club_owner!(team: first_team, user: current_user)
 
-      if plan.in?(%w[premium_light premium_full]) && MatchLiveTv.stripe_enabled?
-        unless club.billing_profile_complete?
-          redirect_to public_club_billing_profile_path(club, plan: plan, interval: checkout_interval_param),
-                      alert: t("flash.clubs.complete_billing_first")
-          return
+      if desired_plan.in?(%w[premium_light premium_full])
+        interval = Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
+        if MatchLiveTv.stripe_enabled?
+          unless club.billing_profile_complete?
+            redirect_to public_club_billing_profile_path(club, plan: desired_plan, interval: interval),
+                        alert: t("flash.clubs.complete_billing_first")
+            return
+          end
+
+          redirect_to public_club_checkout_path(club, plan: desired_plan, interval: interval)
+        else
+          redirect_to public_club_billing_path(club), notice: t("flash.clubs.created_complete_subscription")
         end
-
-        interval = checkout_interval_param
-        redirect_to public_club_checkout_path(club, plan: plan, interval: interval)
       else
         redirect_to public_club_path(club), notice: t("flash.clubs.created")
       end
@@ -51,25 +56,34 @@ module Public
     def show
       require_club_owner!(@club)
       apply_checkout_flash!
-      @entitlements_team = @club.teams.first
+      @entitlements_team = @club.teams.visible.first
       @entitlements = @entitlements_team&.entitlements
-      @teams = @club.teams.order(:name)
+      @teams = @club.teams.visible.order(:name)
       @replay_stats = Recordings::ClubStats.new(@club).call if @entitlements&.can_access_recordings?
     end
 
     def edit
       require_club_owner!(@club)
+      @entitlements = @club.teams.first&.entitlements
     end
 
     def update
       require_club_owner!(@club)
+      @entitlements = @club.teams.first!.entitlements
       @club.assign_attributes(club_params)
       attach_branding_logo(@club)
+      attach_cover_image(@club, entitlements: @entitlements)
       @club.save!
+      enqueue_cover_slate_generation(@club)
       redirect_to public_club_path(@club), notice: t("flash.clubs.updated")
     rescue ActiveRecord::RecordInvalid => e
+      @entitlements = @club.teams.first&.entitlements
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
       render :edit, status: :unprocessable_entity
+    rescue Teams::EntitlementError, BrandingAttachments::CoverUploadError => e
+      @entitlements = @club.teams.first&.entitlements
+      flash.now[:alert] = e.message
+      render :edit, status: :unprocessable_entity
     end
 
     def billing
@@ -82,6 +96,8 @@ module Public
       @entitlements = @team.entitlements
       @plans = Plan.ordered
       @payments = @club.billing_payments.recent.includes(:invoice).limit(50)
+      @quote = @club.active_billing_quote
+      @pending_transfer = @club.billing_transfer_orders.awaiting_payment.first
     end
 
     def checkout
@@ -92,6 +108,12 @@ module Public
         return
       end
 
+      if @club.active_billing_quote.present?
+        redirect_to public_club_billing_path(@club),
+                    alert: t("flash.club_billing.quote_checkout_denied")
+        return
+      end
+
       unless MatchLiveTv.stripe_enabled?
         redirect_to public_club_billing_path(@club), alert: t("flash.clubs.stripe_not_configured")
         return

backend/app/controllers/public/contacts_controller.rb

@@ -0,0 +1,46 @@
+module Public
+  class ContactsController < WebBaseController
+    def show
+      @inquiry = empty_inquiry
+    end
+
+    def create
+      result = Contacts::SubmitInquiry.call(params: inquiry_params, ip: request.remote_ip)
+
+      if result.ok
+        redirect_to public_contatti_path, notice: t("flash.contacts.sent")
+        return
+      end
+
+      @inquiry = inquiry_params
+      flash.now[:alert] = t("flash.contacts.#{result.error}")
+      render :show, status: result.error == :throttled ? :too_many_requests : :unprocessable_entity
+    end
+
+    private
+
+    def inquiry_params
+      {
+        name: params[:name].to_s,
+        email: params[:email].to_s,
+        club_name: params[:club_name].to_s,
+        topic: params[:topic].to_s,
+        message: params[:message].to_s,
+        website: params[:website].to_s,
+        accept_privacy: params[:accept_privacy].to_s
+      }
+    end
+
+    def empty_inquiry
+      {
+        name: "",
+        email: "",
+        club_name: "",
+        topic: "commercial",
+        message: "",
+        website: "",
+        accept_privacy: ""
+      }
+    end
+  end
+end

backend/app/controllers/public/invitations_controller.rb

@@ -2,26 +2,40 @@ module Public
   class InvitationsController < WebBaseController
     def show
       @token = params[:token]
-      @invitation = TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(@token.to_s))
-      unless @invitation
+      digest = Digest::SHA256.hexdigest(@token.to_s)
+      @invitation = TeamInvitation.pending.find_by(token_digest: digest)
+      @tournament_invitation = TournamentBroadcastInvitation.pending.find_by(token_digest: digest) unless @invitation
+      unless @invitation || @tournament_invitation
         redirect_to public_pricing_path, alert: t("flash.invitations.invalid_or_expired")
       end
     end
 
     def accept
-      invitation = TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(params[:token].to_s))
-      return redirect_to public_pricing_path, alert: t("flash.invitations.invalid") unless invitation
+      token = params[:token].to_s
+      digest = Digest::SHA256.hexdigest(token)
+      invitation = TeamInvitation.pending.find_by(token_digest: digest)
+      tournament_invitation = TournamentBroadcastInvitation.pending.find_by(token_digest: digest) unless invitation
 
-      if logged_in?
-        if current_user.email.downcase != invitation.email.downcase
-          redirect_to public_pricing_path, alert: t("flash.invitations.wrong_email", email: invitation.email)
-          return
-        end
+      unless invitation || tournament_invitation
+        return redirect_to public_pricing_path, alert: t("flash.invitations.invalid")
+      end
+
+      target_email = (invitation || tournament_invitation).email
+      unless logged_in?
+        session[:pending_invite_token] = token
+        return redirect_to public_signup_path, notice: t("flash.invitations.signup_to_accept", email: target_email)
+      end
+
+      if current_user.email.downcase != target_email.downcase
+        return redirect_to public_pricing_path, alert: t("flash.invitations.wrong_email", email: target_email)
+      end
+
+      if invitation
         invitation.accept!(current_user)
         redirect_to public_team_details_path(invitation.team), notice: t("flash.invitations.joined_team")
       else
-        session[:pending_invite_token] = params[:token]
-        redirect_to public_signup_path, notice: t("flash.invitations.signup_to_accept", email: invitation.email)
+        tournament_invitation.accept!(current_user)
+        redirect_to public_account_path, notice: t("flash.invitations.joined_tournament")
       end
     end
   end

backend/app/controllers/public/live_controller.rb

@@ -33,7 +33,11 @@ module Public
         .order(scheduled_at: :asc)
         .limit(50)
 
-      @online_paths = Mediamtx::Client.new.online_path_names
+      tournaments = Tournament.listed_on_live.with_attached_logo_file.includes(:club).search_public(@query)
+      tournaments = tournaments.where(club_id: @club.id) if @club
+      @public_tournaments = tournaments.order(starts_on: :desc, name: :asc).limit(12)
+
+      @online_paths = fetch_online_paths
 
       return unless logged_in? && @club
 
@@ -51,6 +55,7 @@ module Public
         @session.status.in?(%w[connecting live reconnecting paused])
       )
       @publisher_online = !@stream_closed && mediamtx_publisher_online?(@session)
+      @cover_poster_url = Streams::CoverResolver.new(@match).effective_cover_url
     end
 
     def status
@@ -82,5 +87,13 @@ module Public
         score: session.score_state&.as_cable_payload
       }
     end
+
+    private
+
+    def fetch_online_paths
+      Mediamtx::Client.new.online_path_names
+    rescue Mediamtx::Client::Error, Errno::ECONNREFUSED, SocketError
+      []
+    end
   end
 end

backend/app/controllers/public/pages_controller.rb

@@ -11,17 +11,8 @@ module Public
       load_club_billing_context_for_pricing
     end
 
-    private
-
-    def load_club_billing_context_for_pricing
-      return unless logged_in?
-
-      @club = current_user.primary_club
-      return unless @club
-
-      @subscription = @club.subscription
-      @team = @club.teams.order(:name).first
-      @entitlements = @team&.entitlements
+    def support
+      @app_store_review_chrome = true
     end
 
     def privacy
@@ -38,5 +29,18 @@ module Public
 
     def pallavolo
     end
+
+    private
+
+    def load_club_billing_context_for_pricing
+      return unless logged_in?
+
+      @club = current_user.primary_club
+      return unless @club
+
+      @subscription = @club.subscription
+      @team = @club.teams.order(:name).first
+      @entitlements = @team&.entitlements
+    end
   end
 end

backend/app/controllers/public/password_resets_controller.rb

@@ -4,11 +4,7 @@ module Public
     end
 
     def create
-      user = User.find_by(email: params[:email]&.downcase&.strip)
-      if user
-        token = user.generate_password_reset!
-        UserMailer.password_reset(user, token).deliver_now
-      end
+      Users::RequestPasswordReset.call(email: params[:email])
 
       redirect_to public_login_path,
                   notice: t("flash.password_resets.email_sent")
@@ -17,7 +13,7 @@ module Public
     def edit
       @user = User.find_by_password_reset_token(params[:token])
       if @user.nil? || @user.password_reset_expired?
-        redirect_to new_public_password_reset_path,
+        redirect_to public_password_forgot_path,
                     alert: t("flash.password_resets.invalid_or_expired_link")
         return
       end
@@ -27,19 +23,25 @@ module Public
     def update
       @user = User.find_by_password_reset_token(params[:token])
       if @user.nil? || @user.password_reset_expired?
-        redirect_to new_public_password_reset_path,
+        redirect_to public_password_forgot_path,
                     alert: t("flash.password_resets.invalid_or_expired_link")
         return
       end
 
-      if params[:password].blank? || params[:password].length < 8
-        flash.now[:alert] = t("flash.password_resets.password_min_length")
+      if params[:password] != params[:password_confirmation]
+        flash.now[:alert] = t("flash.password_resets.password_mismatch")
         @token = params[:token]
         return render :edit, status: :unprocessable_entity
       end
 
-      if params[:password] != params[:password_confirmation]
-        flash.now[:alert] = t("flash.password_resets.password_mismatch")
+      if (code = PasswordComplexity.violation(params[:password]))
+        flash.now[:alert] = t("flash.password_resets.password_#{code == :blank ? :too_short : code}")
+        @token = params[:token]
+        return render :edit, status: :unprocessable_entity
+      end
+
+      if PasswordComplexity.same_as_current?(@user, params[:password])
+        flash.now[:alert] = t("flash.password_resets.password_same_as_current")
         @token = params[:token]
         return render :edit, status: :unprocessable_entity
       end

backend/app/controllers/public/regia_controller.rb

@@ -7,7 +7,7 @@ module Public
     layout "regia"
 
     protect_from_forgery with: :null_session
-    skip_before_action :verify_authenticity_token, only: %i[score pause resume stop]
+    skip_before_action :verify_authenticity_token, only: %i[score pause resume stop audio_mute min_quality]
 
     before_action :set_session_from_token
 
@@ -61,8 +61,26 @@ module Public
       render json: status_payload
     end
 
+    def audio_mute
+      muted = params.key?(:muted) ? params[:muted] : !@session.audio_muted
+      Sessions::SetAudioMute.new(@session, muted: muted).call
+      render json: status_payload
+    end
+
+    def min_quality
+      Sessions::SetMinQuality.new(@session, preset: params[:min_quality_preset]).call
+      render json: status_payload
+    rescue ArgumentError => e
+      render json: status_payload.merge(error: e.message), status: :unprocessable_entity
+    end
+
     private
 
+    def camera_telemetry_payload(publisher_online)
+      cam = @session.device_states.find_by(device_role: "camera")
+      (cam&.as_regia_payload || {}).merge(publisher_online: publisher_online)
+    end
+
     def set_session_from_token
       @session = Sessions::RegiaAccess.find_session_by_token(params[:token])
       return if @session
@@ -78,6 +96,7 @@ module Public
       {
         status: @session.status,
         paused: @session.paused?,
+        audio_muted: @session.audio_muted,
         stream_closed: closed,
         live: !closed && (@session.live? || @session.paused? || publisher_online),
         on_air: playable || (!closed && @session.status.in?(%w[connecting live reconnecting paused])),
@@ -86,7 +105,10 @@ module Public
         home_name: @session.match.team.name,
         away_name: @session.match.opponent_name,
         points_target: Scoring::Rules.points_target_for_match(@session.match, current_set: score&.current_set || 1),
-        score: score&.as_cable_payload
+        score: score&.as_cable_payload,
+        min_quality_preset: @session.min_quality_preset,
+        min_quality_options: Sessions::SelectQuality.allowed_min_ids(@session.quality_preset),
+        telemetry: camera_telemetry_payload(publisher_online)
       }
     end
   end

backend/app/controllers/public/registrations_controller.rb

@@ -17,11 +17,18 @@ module Public
         session[:user_id] = @user.id
         if session[:pending_invite_token].present?
           token = session.delete(:pending_invite_token)
-          invitation = TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(token))
+          digest = Digest::SHA256.hexdigest(token)
+          invitation = TeamInvitation.pending.find_by(token_digest: digest)
           if invitation && invitation.email.downcase == @user.email.downcase
             invitation.accept!(@user)
             return redirect_to public_team_details_path(invitation.team), notice: t("flash.registrations.welcome_to_team")
           end
+
+          tournament_invitation = TournamentBroadcastInvitation.pending.find_by(token_digest: digest)
+          if tournament_invitation && tournament_invitation.email.downcase == @user.email.downcase
+            tournament_invitation.accept!(@user)
+            return redirect_to public_account_path, notice: t("flash.invitations.joined_tournament")
+          end
         end
         redirect_to public_new_club_path, notice: t("flash.registrations.account_created")
       else

backend/app/controllers/public/sessions_controller.rb

@@ -1,5 +1,9 @@
 module Public
   class SessionsController < WebBaseController
+    # Logout must succeed even with a stale CSRF token (old tab after deploy /
+    # session rotate). SameSite=Lax already blocks cross-site cookie POSTs.
+    skip_before_action :verify_authenticity_token, only: :destroy
+
     def new
       if logged_in? && current_user.primary_club
         redirect_to public_club_path(current_user.primary_club)

backend/app/controllers/public/site_base_controller.rb

@@ -9,6 +9,7 @@ module Public
 
     protect_from_forgery with: :exception
     before_action :set_site_locale
+    before_action :load_site_announcements
 
     private
 
@@ -40,5 +41,29 @@ module Public
     def logged_in?
       current_user.present?
     end
+
+    PRIVATE_WEB_CONTROLLERS = %w[
+      accounts clubs teams club_recordings club_billing
+      club_matches matches team_roster_members
+      tournaments tournament_participants tournament_groups
+      tournament_matches tournament_invitations tournament_results
+    ].freeze
+
+    def load_site_announcements
+      @site_announcements = if skip_site_announcements?
+        AppAnnouncement.none
+      else
+        channel = private_web_area? ? :web_private : :web_public
+        AppAnnouncement.for_channel(channel).newest
+      end
+    end
+
+    def skip_site_announcements?
+      controller_name == "regia"
+    end
+
+    def private_web_area?
+      PRIVATE_WEB_CONTROLLERS.include?(controller_name)
+    end
   end
 end

backend/app/controllers/public/sitemap_controller.rb

@@ -8,9 +8,12 @@ module Public
         { loc: "#{base}/prezzi", changefreq: "monthly", priority: "0.9" },
         { loc: "#{base}/pallavolo-giovanile", changefreq: "monthly", priority: "0.85" },
         { loc: "#{base}/faq", changefreq: "monthly", priority: "0.8" },
+        { loc: "#{base}/contatti", changefreq: "monthly", priority: "0.6" },
         { loc: "#{base}/live", changefreq: "hourly", priority: "0.85" },
         { loc: "#{base}/squadre", changefreq: "daily", priority: "0.85" },
+        { loc: "#{base}/tornei", changefreq: "daily", priority: "0.8" },
         { loc: "#{base}/privacy", changefreq: "yearly", priority: "0.3" },
+        { loc: "#{base}/support", changefreq: "yearly", priority: "0.3" },
         { loc: "#{base}/cookie", changefreq: "yearly", priority: "0.3" },
         { loc: "#{base}/termini", changefreq: "yearly", priority: "0.3" }
       ]
@@ -23,6 +26,14 @@ module Public
         }
       end
 
+      Tournament.visible_to_public.find_each do |tournament|
+        @entries << {
+          loc: "#{base}/tornei/#{tournament.slug}",
+          changefreq: "daily",
+          priority: "0.75"
+        }
+      end
+
       respond_to do |format|
         format.xml { render layout: false }
       end

backend/app/controllers/public/teams_controller.rb

@@ -19,6 +19,7 @@ module Public
       require_club_owner!(@club)
       team = @club.teams.create!(team_params)
       attach_branding_logo(team)
+      Teams::StaffAssignment.designate_club_owner!(team: team, user: current_user)
       redirect_to public_club_path(@club), notice: t("flash.teams.added", name: team.name)
     rescue ActiveRecord::RecordInvalid => e
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
@@ -26,6 +27,11 @@ module Public
     end
 
     def details
+      if @team.tournament_broadcast? && @team.broadcast_tournament
+        redirect_to public_tournament_path(@team.broadcast_tournament)
+        return
+      end
+
       load_team_details!
       render :details
     end
@@ -41,24 +47,33 @@ module Public
     def edit
       require_club_owner_for_team!(@team)
       @club = @team.club
+      @entitlements = @team.entitlements
     end
 
     def update
       require_club_owner_for_team!(@team)
       @team.assign_attributes(team_params)
       attach_branding_logo(@team)
+      attach_cover_image(@team, entitlements: @team.entitlements)
       attach_team_photo(@team)
       @team.save!
+      enqueue_cover_slate_generation(@team)
       redirect_to public_team_details_path(@team), notice: t("flash.teams.updated")
     rescue ActiveRecord::RecordInvalid => e
       @club = @team.club
+      @entitlements = @team.entitlements
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
       render :edit, status: :unprocessable_entity
+    rescue Teams::EntitlementError, BrandingAttachments::CoverUploadError => e
+      @club = @team.club
+      @entitlements = @team.entitlements
+      flash.now[:alert] = e.message
+      render :edit, status: :unprocessable_entity
     end
 
     def invite
       require_club_owner_for_team!(@team)
-      @entitlements = @team.entitlements
+      redirect_to public_team_details_path(@team, anchor: "invita-trasmissione")
     end
 
     def assign_self_staff
@@ -87,18 +102,32 @@ module Public
       email = params[:email]&.downcase&.strip
       Teams::StaffEmailValidator.assert_available!(team: @team, email: email, staff_kind: staff_kind)
       token = TeamInvitation.generate_token
-      @team.team_invitations.create!(
+      invitation = @team.team_invitations.create!(
         email: email,
         token_digest: Digest::SHA256.hexdigest(token),
         role: "member",
         staff_kind: staff_kind,
         expires_at: 7.days.from_now
       )
-      @invite_url = join_public_invitation_url(token: token)
-      flash.now[:notice] = t("flash.teams.invite_link_generated")
-      render :invite
+      invite_url = public_invitation_url(token: token)
+      flash[:invite_url] = invite_url
+
+      begin
+        Teams::InvitationMailer.transmission_invite(
+          team: @team,
+          invitation: invitation,
+          invite_url: invite_url,
+          invited_by: current_user
+        ).deliver_now
+        flash[:notice] = t("flash.teams.invite_email_sent", email: email)
+      rescue StandardError => e
+        Rails.logger.error("[invite_email] #{e.class}: #{e.message}")
+        flash[:alert] = t("flash.teams.invite_email_failed", email: email)
+      end
+
+      redirect_to public_team_details_path(@team, anchor: "invito-generato")
     rescue Teams::EntitlementError, Teams::StaffAssignmentError => e
-      redirect_to public_team_invite_path(@team), alert: e.message
+      redirect_to public_team_details_path(@team, anchor: "invita-trasmissione"), alert: e.message
     end
 
     def remove_member

backend/app/controllers/public/tournament_assignments_controller.rb

@@ -0,0 +1,29 @@
+module Public
+  class TournamentAssignmentsController < WebBaseController
+    before_action :require_login!
+    before_action :set_tournament
+
+    def destroy
+      Tournaments::Entitlements.new(@club).assert_writable!
+      unless @tournament.writable?
+        redirect_to public_tournament_path(@tournament, tab: "dirette"),
+                    alert: t("flash.tournaments.archived_locked")
+        return
+      end
+      assignment = @tournament.broadcast_assignments.find(params[:assignment_id])
+      Tournaments::RevokeAssignment.call(assignment: assignment)
+      redirect_to public_tournament_path(@tournament, tab: "dirette"),
+                  notice: t("flash.tournaments.assignment_revoked")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
+    private
+
+    def set_tournament
+      @tournament = Tournament.find(params[:id])
+      @club = @tournament.club
+      require_club_owner!(@club)
+    end
+  end
+end

backend/app/controllers/public/tournament_groups_controller.rb

@@ -0,0 +1,32 @@
+module Public
+  class TournamentGroupsController < WebBaseController
+    before_action :require_login!
+    before_action :set_tournament
+
+    def create
+      Tournaments::Entitlements.new(@club).assert_writable!
+      position = @tournament.groups.maximum(:position).to_i + 1
+      name = params.dig(:tournament_group, :name).presence || "Girone #{('A'.ord + position).chr}"
+      @tournament.groups.create!(name: name, position: position)
+      redirect_to public_tournament_path(@tournament, tab: "struttura"), notice: t("flash.tournaments.group_added")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
+    def destroy
+      Tournaments::Entitlements.new(@club).assert_writable!
+      @tournament.groups.find(params[:group_id]).destroy!
+      redirect_to public_tournament_path(@tournament, tab: "struttura"), notice: t("flash.tournaments.group_removed")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
+    private
+
+    def set_tournament
+      @tournament = Tournament.find(params[:id])
+      @club = @tournament.club
+      require_club_owner!(@club)
+    end
+  end
+end

backend/app/controllers/public/tournament_invitations_controller.rb

@@ -0,0 +1,136 @@
+module Public
+  class TournamentInvitationsController < WebBaseController
+    before_action :require_login!
+    before_action :set_tournament
+
+    def create
+      if params[:intent] == "save"
+        save_draft
+        return
+      end
+
+      match_ids = Array(params[:match_ids]).reject(&:blank?)
+      scope_kind = if match_ids.any?
+        "matches"
+      elsif params[:whole_court].present? || params[:scope_kind].to_s == "court_day"
+        "court_day"
+      else
+        raise ArgumentError, t("tournaments.hub.stream_plan_need_selection")
+      end
+      persist_draft! unless calendar_invite?
+      invitation, token = Tournaments::Invite.call(
+        tournament: @tournament,
+        email: params[:email],
+        scope_kind: scope_kind,
+        match_ids: match_ids,
+        court: params[:court],
+        on_date: params[:on_date].presence,
+        invited_by: current_user,
+        note: params[:note]
+      )
+      invite_url = public_invitation_url(token: token)
+      flash[:invite_url] = invite_url unless calendar_invite?
+      body_html = Tournaments::ComposeInviteEmail.call(
+        html: draft_html,
+        invite_url: invite_url,
+        expires_on: I18n.l(invitation.expires_at.to_date, format: :long)
+      )
+      invitation.update!(email_html: body_html)
+      begin
+        Tournaments::InvitationMailer.transmission_invite(
+          tournament: @tournament,
+          invitation: invitation,
+          invite_url: invite_url,
+          invited_by: current_user,
+          body_html: body_html
+        ).deliver_now
+        flash[:notice] = t("flash.tournaments.invite_email_sent", email: invitation.email)
+      rescue StandardError => e
+        Rails.logger.error("[tournament_invite] #{e.class}: #{e.message}")
+        flash[:alert] = t("flash.tournaments.invite_email_failed", email: invitation.email)
+      end
+      redirect_to public_tournament_path(@tournament, tab: invite_return_tab, anchor: calendar_invite? ? nil : "invito-generato")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid, ArgumentError => e
+      redirect_to public_tournament_path(@tournament, tab: invite_return_tab), alert: e.message
+    end
+
+    def save_draft
+      Tournaments::Entitlements.new(@club).assert_writable!
+      persist_draft!
+      redirect_to public_tournament_path(@tournament, tab: "dirette"),
+                  notice: t("flash.tournaments.invite_draft_saved")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "dirette"), alert: e.message
+    end
+
+    def upload_image
+      Tournaments::Entitlements.new(@club).assert_writable!
+      file = params[:file]
+      unless file.respond_to?(:content_type) && file.content_type.to_s.in?(%w[image/png image/jpeg image/webp image/gif])
+        return render json: { error: t("tournaments.hub.invite_image_invalid") }, status: :unprocessable_entity
+      end
+      if file.size > 2.megabytes
+        return render json: { error: t("tournaments.hub.invite_image_too_big") }, status: :unprocessable_entity
+      end
+
+      @tournament.invite_email_images.attach(file)
+      blob = @tournament.invite_email_images.blobs.last
+      render json: { url: url_for(blob) }
+    rescue Tournaments::EntitlementError => e
+      render json: { error: e.message }, status: :forbidden
+    end
+
+    def destroy
+      Tournaments::Entitlements.new(@club).assert_writable!
+      invitation = @tournament.broadcast_invitations.find(params[:invitation_id])
+      invitation.destroy!
+      redirect_to public_tournament_path(@tournament, tab: invite_return_tab), notice: t("flash.tournaments.invite_canceled")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
+    private
+
+    def set_tournament
+      @tournament = Tournament.find(params[:id])
+      @club = @tournament.club
+      require_club_owner!(@club)
+    end
+
+    def persist_draft!
+      @tournament.update!(
+        invite_draft_html: Tournaments::ComposeInviteEmail.sanitize_html(draft_html),
+        invite_draft_note: params[:note].to_s.strip.presence,
+        invite_draft_email: params[:email].to_s.strip.presence,
+        invite_draft_saved_at: Time.current
+      )
+    end
+
+    def draft_html
+      html = params[:email_html].to_s
+      stripped = ActionController::Base.helpers.strip_tags(html).to_s.gsub(/\s+/, "")
+      return html if stripped.present?
+
+      stored = @tournament.invite_draft_html.to_s
+      if ActionController::Base.helpers.strip_tags(stored).to_s.gsub(/\s+/, "").present?
+        return stored
+      end
+
+      Tournaments::ComposeInviteEmail.default_html(tournament: @tournament, invited_by: current_user)
+    end
+
+    def calendar_invite?
+      params[:from].to_s == "calendar" || invite_return_tab == "calendario"
+    end
+
+    def invite_return_tab
+      tab = params[:tab].to_s
+      tab = "dirette" if tab == "delega"
+      tab.presence_in(%w[calendario dirette]) || "dirette"
+    end
+  end
+end

backend/app/controllers/public/tournament_matches_controller.rb

@@ -0,0 +1,113 @@
+module Public
+  class TournamentMatchesController < WebBaseController
+    before_action :require_login!
+    before_action :set_tournament
+
+    def create
+      Tournaments::ScheduleMatch.call(tournament: @tournament, attrs: match_params)
+      redirect_to public_tournament_path(@tournament, tab: "calendario"), notice: t("flash.tournaments.match_scheduled")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "calendario"), alert: e.record.errors.full_messages.join(", ")
+    end
+
+    def update
+      Tournaments::Entitlements.new(@club).assert_writable!
+      match = @tournament.matches.find(params[:match_id])
+      attrs = match_params
+      if match.result_recorded?
+        attrs = attrs.except(:home_participant_id, :away_participant_id)
+      end
+      match.update!(attrs)
+      schedule_changed = match.previous_changes.keys.intersect?(%w[scheduled_at court location])
+      recorded = record_result_if_present!(match)
+      notice = if recorded && !schedule_changed
+        t("flash.tournaments.result_saved")
+      else
+        t("flash.tournaments.match_updated")
+      end
+      redirect_to public_tournament_path(@tournament, tab: hub_tab), notice: notice
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "calendario"), alert: e.record.errors.full_messages.join(", ")
+    end
+
+    def swap
+      match = @tournament.matches.find(params[:match_id])
+      Tournaments::SwapSides.call(match: match)
+      respond_to do |format|
+        format.json { render json: { ok: true, matchup_label: match.reload.matchup_label } }
+        format.html { redirect_to public_tournament_path(@tournament, tab: "calendario"), notice: t("flash.tournaments.sides_swapped") }
+      end
+    rescue Tournaments::EntitlementError => e
+      respond_to do |format|
+        format.json { render json: { ok: false, error: e.message }, status: :unprocessable_entity }
+        format.html { redirect_to public_club_billing_path(@club), alert: e.message }
+      end
+    rescue Tournaments::SwapSides::LiveBroadcastError => e
+      respond_to do |format|
+        format.json { render json: { ok: false, error: e.message }, status: :unprocessable_entity }
+        format.html { redirect_to public_tournament_path(@tournament, tab: "calendario"), alert: e.message }
+      end
+    end
+
+    def destroy
+      Tournaments::Entitlements.new(@club).assert_writable!
+      match = @tournament.matches.find(params[:match_id])
+      unless match.deletable?
+        redirect_to public_tournament_path(@tournament, tab: "calendario"),
+                    alert: t("flash.matches.close_live_before_delete")
+        return
+      end
+
+      match.destroy!
+      redirect_to public_tournament_path(@tournament, tab: "calendario"), notice: t("flash.tournaments.match_deleted")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
+    private
+
+    def set_tournament
+      @tournament = Tournament.find(params[:id])
+      @club = @tournament.club
+      require_club_owner!(@club)
+    end
+
+    def record_result_if_present!(match)
+      home = params[:home_score]
+      away = params[:away_score]
+      return false if home.blank? || away.blank?
+
+      Tournaments::RecordResult.call(match: match, home_score: home, away_score: away, source: "manual")
+      true
+    end
+
+    def match_params
+      p = params.require(:match).permit(
+        :home_participant_id, :away_participant_id, :tournament_group_id,
+        :tournament_round_id, :court, :location, :scheduled_at
+      )
+      %i[home_participant_id away_participant_id].each do |key|
+        p[key] = p[key].presence if p.key?(key)
+      end
+      p[:scheduled_at] = parse_scheduled_at(p[:scheduled_at]) if p[:scheduled_at].present?
+      p
+    end
+
+    def parse_scheduled_at(value)
+      raw = value.to_s.strip
+      return nil if raw.blank?
+
+      Time.zone.strptime(raw, "%Y-%m-%dT%H:%M")
+    rescue ArgumentError
+      Time.zone.parse(raw)
+    end
+
+    def hub_tab
+      params[:tab].to_s.presence_in(%w[squadre struttura calendario dirette tabellone]) || "calendario"
+    end
+  end
+end

backend/app/controllers/public/tournament_pages_controller.rb

@@ -0,0 +1,81 @@
+module Public
+  class TournamentPagesController < SiteBaseController
+    include Public::LiveHelper
+
+    layout "marketing_live"
+
+    def index
+      @tournaments = Tournament
+        .visible_to_public
+        .with_attached_logo_file
+        .includes(:club)
+        .order(starts_on: :desc, name: :asc)
+    end
+
+    def show
+      @tournament = Tournament.find_by!(slug: params[:slug])
+      unless @tournament.published? || owner_access?
+        raise ActiveRecord::RecordNotFound
+      end
+
+      @club = @tournament.club
+      @owner_preview = !@tournament.published? && owner_access?
+      @owner_manage = owner_access?
+      @tab = params[:tab].to_s.presence_in(%w[risultati tabellone]) || "risultati"
+      load_public_content!
+    end
+
+    private
+
+    def owner_access?
+      logged_in? && @tournament.club.owned_by?(current_user)
+    end
+
+    def load_public_content!
+      @online_paths = fetch_online_paths
+
+      @matches = @tournament.matches
+        .includes(
+          :tournament_group,
+          :tournament_round,
+          :stream_sessions,
+          home_participant: { logo_file_attachment: :blob },
+          away_participant: { logo_file_attachment: :blob }
+        )
+        .order(Arel.sql("scheduled_at ASC NULLS LAST"), created_at: :asc)
+
+      broadcasting = StreamSession
+        .broadcasting
+        .includes(:score_state, match: [:home_participant, :away_participant, { team: :club }])
+        .where(match_id: @tournament.matches.select(:id))
+        .order(Arel.sql("started_at DESC NULLS LAST"), created_at: :desc)
+        .to_a
+      @live_by_match_id = {}
+      broadcasting.each { |session| @live_by_match_id[session.match_id] ||= session }
+      @live_sessions = broadcasting.select(&:public_watchable?)
+
+      @recordings = Recording.ready.publicly_listed
+        .joins(stream_session: :match)
+        .where(matches: { tournament_id: @tournament.id })
+        .includes(stream_session: { match: [:home_participant, :away_participant] })
+        .order(recorded_at: :desc)
+      @recording_by_match_id = {}
+      @recordings.each do |rec|
+        match_id = rec.stream_session.match_id
+        @recording_by_match_id[match_id] ||= rec
+      end
+
+      @groups = @tournament.groups.order(:position)
+      @standings_by_group = @groups.index_with { |group| Tournaments::Standings.call(group) }
+      @rounds = @tournament.rounds.order(:position)
+      @matches_by_round = @matches.select { |match| match.tournament_round_id.present? }
+        .group_by(&:tournament_round_id)
+    end
+
+    def fetch_online_paths
+      Mediamtx::Client.new.online_path_names
+    rescue Mediamtx::Client::Error, Errno::ECONNREFUSED, SocketError
+      []
+    end
+  end
+end

backend/app/controllers/public/tournament_participants_controller.rb

@@ -0,0 +1,51 @@
+module Public
+  class TournamentParticipantsController < WebBaseController
+    before_action :require_login!
+    before_action :set_tournament
+
+    def create
+      Tournaments::Entitlements.new(@club).assert_writable!
+      @tournament.participants.create!(participant_params)
+      redirect_to public_tournament_path(@tournament, tab: "squadre"), notice: t("flash.tournaments.participant_added")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "squadre"), alert: e.record.errors.full_messages.join(", ")
+    end
+
+    def update
+      Tournaments::Entitlements.new(@club).assert_writable!
+      participant = @tournament.participants.find(params[:participant_id])
+      participant.update!(participant_params)
+      file = params.dig(:tournament_participant, :logo_file)
+      participant.logo_file.attach(file) if file.present?
+      redirect_to public_tournament_path(@tournament, tab: "squadre"), notice: t("flash.tournaments.participant_updated")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "squadre"), alert: e.record.errors.full_messages.join(", ")
+    end
+
+    def destroy
+      Tournaments::Entitlements.new(@club).assert_writable!
+      @tournament.participants.find(params[:participant_id]).destroy!
+      redirect_to public_tournament_path(@tournament, tab: "squadre"), notice: t("flash.tournaments.participant_removed")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
+    private
+
+    def set_tournament
+      @tournament = Tournament.find(params[:id])
+      @club = @tournament.club
+      require_club_owner!(@club)
+    end
+
+    def participant_params
+      permitted = params.require(:tournament_participant).permit(:name, :group_id, :primary_color, :logo_url, :source_team_id)
+      permitted[:group_id] = permitted[:group_id].presence if permitted.key?(:group_id)
+      permitted
+    end
+  end
+end

backend/app/controllers/public/tournament_results_controller.rb

@@ -0,0 +1,32 @@
+module Public
+  class TournamentResultsController < WebBaseController
+    before_action :require_login!
+    before_action :set_tournament
+
+    def create
+      Tournaments::Entitlements.new(@club).assert_writable!
+      match = @tournament.matches.find(params[:match_id])
+      Tournaments::RecordResult.call(
+        match: match,
+        home_score: params[:home_score],
+        away_score: params[:away_score],
+        source: "manual",
+        walkover: params[:walkover].presence
+      )
+      redirect_to public_tournament_path(@tournament, tab: params[:tab].presence || "calendario"),
+                  notice: t("flash.tournaments.result_saved")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "calendario"), alert: e.record.errors.full_messages.join(", ")
+    end
+
+    private
+
+    def set_tournament
+      @tournament = Tournament.find(params[:id])
+      @club = @tournament.club
+      require_club_owner!(@club)
+    end
+  end
+end

backend/app/controllers/public/tournaments_controller.rb

@@ -0,0 +1,190 @@
+module Public
+  class TournamentsController < WebBaseController
+    before_action :require_login!
+    before_action :set_club, only: %i[index new create]
+    before_action :set_tournament, except: %i[index new create]
+    before_action :require_owner!
+    before_action :require_writable!, only: %i[update generate_group_matches propose_knockout]
+
+    def index
+      @tournaments = @club.tournaments.order(starts_on: :desc)
+      @can_create = Tournaments::Entitlements.new(@club).premium_full?
+    end
+
+    def new
+      assert_full!
+      return if performed?
+
+      @tournament = @club.tournaments.build(
+        sport_key: Sports::Catalog.normalize_key(@club.sport),
+        starts_on: Date.current,
+        ends_on: Date.current + 1,
+        format_kind: "mixed",
+        courts: ["Campo 1", "Campo 2"],
+        knockout_size: 4
+      )
+    end
+
+    def create
+      @tournament = Tournaments::Create.call(club: @club, attrs: tournament_params)
+      redirect_to public_tournament_path(@tournament), notice: t("flash.tournaments.created")
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ActiveRecord::RecordInvalid => e
+      @tournament = e.record
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :new, status: :unprocessable_entity
+    end
+
+    def show
+      if params[:tab] == "delega"
+        redirect_to public_tournament_path(@tournament, tab: "dirette")
+        return
+      end
+
+      load_hub!
+    end
+
+    def update
+      attrs = tournament_params
+      file = attrs.delete(:logo_file)
+      @tournament.assign_attributes(attrs)
+      @tournament.logo_file.attach(file) if file.present?
+      @tournament.save!
+      redirect_to public_tournament_path(@tournament, tab: hub_tab || params[:tab]), notice: t("flash.tournaments.updated")
+    rescue ActiveRecord::RecordInvalid => e
+      load_hub!
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :show, status: :unprocessable_entity
+    end
+
+    def publish
+      assert_full!
+      return if performed?
+
+      @tournament.update!(status: "published")
+      redirect_to public_tournament_path(@tournament), notice: t("flash.tournaments.published")
+    end
+
+    def unpublish
+      assert_full!
+      return if performed?
+
+      @tournament.update!(status: "draft")
+      redirect_to public_tournament_path(@tournament), notice: t("flash.tournaments.unpublished")
+    end
+
+    def archive
+      assert_full!
+      return if performed?
+
+      @tournament.update!(status: "archived")
+      redirect_to public_tournament_path(@tournament), notice: t("flash.tournaments.archived")
+    end
+
+    def destroy
+      Tournaments::Destroy.call(tournament: @tournament)
+      redirect_to public_club_tournaments_path(@club), notice: t("flash.tournaments.deleted")
+    rescue Tournaments::Destroy::LiveBroadcastError => e
+      redirect_to public_tournament_path(@tournament), alert: e.message
+    end
+
+    def generate_group_matches
+      created = Tournaments::GenerateGroupMatches.call(tournament: @tournament)
+      redirect_to public_tournament_path(@tournament, tab: "calendario"),
+                  notice: t("flash.tournaments.group_matches_created", count: created.size)
+    rescue Tournaments::EntitlementError, ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "calendario"), alert: e.message
+    end
+
+    def propose_knockout
+      updated = Tournaments::ProposeKnockout.call(@tournament)
+      redirect_to public_tournament_path(@tournament, tab: "tabellone"),
+                  notice: t("flash.tournaments.knockout_proposed", count: updated.size)
+    rescue Tournaments::EntitlementError, ActiveRecord::RecordInvalid => e
+      redirect_to public_tournament_path(@tournament, tab: "tabellone"), alert: e.message
+    end
+
+    private
+
+    def set_club
+      @club = Club.find(params[:club_id] || params[:id])
+    end
+
+    def set_tournament
+      @tournament = Tournament.find(params[:id])
+      @club = @tournament.club
+    end
+
+    def require_owner!
+      require_club_owner!(@club)
+    end
+
+    def assert_full!
+      Tournaments::Entitlements.new(@club).assert_writable!
+    rescue Tournaments::EntitlementError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
+    def require_writable!
+      assert_full!
+      return if performed?
+      return if @tournament.writable?
+
+      redirect_to public_tournament_path(@tournament), alert: t("flash.tournaments.archived_locked")
+    end
+
+    def load_hub!
+      @tab = hub_tab || "squadre"
+      @participants = @tournament.participants.with_attached_logo_file.includes(:group, :source_team).order(:position, :name)
+      @groups = @tournament.groups.order(:position)
+      @rounds = @tournament.rounds.order(:position)
+      @matches = @tournament.matches.includes(
+        { home_participant: { logo_file_attachment: :blob } },
+        { away_participant: { logo_file_attachment: :blob } },
+        :tournament_group, :tournament_round, :stream_sessions,
+        { broadcast_assignments: :user }
+      ).order(:scheduled_at)
+      @invitations = @tournament.broadcast_invitations.order(created_at: :desc)
+      @pending_invites_by_match_id = pending_invites_by_match_id
+      @standings_by_group = @groups.index_with { |group| Tournaments::Standings.call(group) }
+      @overlap_warnings = overlap_warnings
+      @writable = @tournament.writable? && Tournaments::Entitlements.new(@club).premium_full?
+    end
+
+    def hub_tab
+      raw = params[:tab].to_s
+      raw = "dirette" if raw == "delega"
+      raw.presence_in(%w[squadre struttura calendario dirette tabellone])
+    end
+
+    def pending_invites_by_match_id
+      pending = @tournament.broadcast_invitations.pending.to_a
+      map = Hash.new { |h, k| h[k] = [] }
+      @matches.each do |match|
+        pending.each do |invitation|
+          map[match.id] << invitation if invitation.covers_match?(match)
+        end
+      end
+      map
+    end
+
+    def overlap_warnings
+      limit = @tournament.concurrent_limit
+      return [] unless limit
+
+      @matches.group_by { |m| m.scheduled_at&.strftime("%Y-%m-%d %H:%M") }.filter_map do |slot, list|
+        next if slot.blank? || list.size <= limit
+
+        t("tournaments.hub.overlap_warning", slot: slot, count: list.size, limit: limit)
+      end
+    end
+
+    def tournament_params
+      params.require(:tournament).permit(
+        :name, :sport_key, :venue, :starts_on, :ends_on, :format_kind,
+        :description, :knockout_size, :courts, :logo_file
+      )
+    end
+  end
+end

backend/app/helpers/admin_helper.rb

@@ -1,4 +1,21 @@
 module AdminHelper
+  def format_euros(cents, precision: 2)
+    return I18n.t("admin.common.dash") if cents.nil?
+
+    format("%.*f €", precision, cents.to_f / 100.0)
+  end
+
+  def format_hours(hours)
+    return I18n.t("admin.common.dash") if hours.nil? || hours.to_f <= 0
+
+    total_minutes = (hours.to_f * 60).round
+    format_duration_minutes(total_minutes)
+  end
+
+  def admin_month_label(month)
+    I18n.l(month, format: "%B %Y")
+  end
+
   def format_bytes(bytes)
     return "—" if bytes.nil?
 
@@ -30,6 +47,113 @@ module AdminHelper
     links
   end
 
+  def admin_session_ingest_badge_class(role_or_node)
+    role = role_or_node.respond_to?(:role) ? role_or_node.role : role_or_node
+    case role.to_s
+    when "home" then "badge--ingest-home"
+    when "lab" then "badge--ingest-lab"
+    when "cloud" then "badge--ingest-cloud"
+    else "badge--paused"
+    end
+  end
+
+  def admin_session_ingest_role_label(role_or_node)
+    role = role_or_node.respond_to?(:role) ? role_or_node.role : role_or_node
+    I18n.t("admin.sessions.ingest.role.#{role}", default: role.to_s.humanize)
+  end
+
+  def admin_session_status_badge_class(status)
+    case status.to_s
+    when "live" then "badge--live"
+    when "connecting", "reconnecting" then "badge--connecting"
+    when "paused", "idle" then "badge--paused"
+    when "ended" then "badge--ended"
+    when "error" then "badge--error"
+    else "badge--paused"
+    end
+  end
+
+  def admin_datetime(time, with_seconds: false)
+    return I18n.t("admin.common.dash") if time.blank?
+
+    format = with_seconds ? "%d/%m/%Y %H:%M:%S" : "%d/%m/%Y %H:%M"
+    time.in_time_zone.strftime(format)
+  end
+
+  def admin_session_duration_label(session)
+    secs = session.total_duration_secs.to_i
+    if secs <= 0 && session.started_at
+      end_time = session.ended_at || (session.terminal? ? session.updated_at : Time.current)
+      secs = (end_time - session.started_at).to_i if end_time
+    end
+    return I18n.t("admin.common.dash") if secs <= 0
+
+    hours = secs / 3600
+    mins = (secs % 3600) / 60
+    rem = secs % 60
+    if hours.positive?
+      format("%dh %02dm %02ds", hours, mins, rem)
+    elsif mins.positive?
+      format("%dm %02ds", mins, rem)
+    else
+      "#{rem}s"
+    end
+  end
+
+  def admin_session_client_os_label(session)
+    case session.client_os.to_s
+    when "android" then "Android"
+    when "ios" then "iOS"
+    else I18n.t("admin.common.dash")
+    end
+  end
+
+  def admin_session_client_summary(session)
+    parts = []
+    parts << admin_session_client_os_label(session) if session.client_os.present?
+    if session.app_version.present?
+      ver = session.app_version
+      ver = "#{ver} (#{session.app_build})" if session.app_build.present?
+      parts << "app #{ver}"
+    end
+    device = [session.device_manufacturer, session.device_model].compact_blank.join(" ")
+    parts << device if device.present?
+    parts << "OS #{session.os_version}" if session.os_version.present?
+    parts << session.carrier if session.carrier.present?
+    parts.presence&.join(" · ") || I18n.t("admin.common.dash")
+  end
+
+  def admin_format_event_meta(metadata)
+    return content_tag(:span, I18n.t("admin.common.dash"), class: "muted") if metadata.blank?
+
+    pairs = metadata.to_h
+    return content_tag(:span, I18n.t("admin.common.dash"), class: "muted") if pairs.empty?
+
+    content_tag(:dl, class: "admin-event-meta") do
+      safe_join(
+        pairs.map do |key, value|
+          content_tag(:div, class: "admin-event-meta__row") do
+            content_tag(:dt, key.to_s) +
+              content_tag(:dd, admin_event_meta_value(value))
+          end
+        end
+      )
+    end
+  end
+
+  def admin_event_meta_value(value)
+    case value
+    when Hash, Array
+      content_tag(:code, value.to_json)
+    when TrueClass, FalseClass
+      value ? "true" : "false"
+    when NilClass
+      I18n.t("admin.common.dash")
+    else
+      value.to_s
+    end
+  end
+
   def admin_regia_expires_label(iso_time)
     return if iso_time.blank?
 
@@ -37,4 +161,35 @@ module AdminHelper
   rescue ArgumentError, TypeError
     nil
   end
+
+  def announcement_status_badge(item)
+    case item.status
+    when "published" then item.severity == "critical" ? "live" : "ready"
+    when "archived" then "paused"
+    else "connecting"
+    end
+  end
+
+  def announcement_window_label(item)
+    start_label = item.starts_at&.in_time_zone&.strftime("%d/%m %H:%M")
+    end_label = item.ends_at&.in_time_zone&.strftime("%d/%m %H:%M")
+    if start_label && end_label
+      "#{start_label} → #{end_label}"
+    elsif start_label
+      I18n.t("admin.announcements.window.from", time: start_label)
+    elsif end_label
+      I18n.t("admin.announcements.window.until", time: end_label)
+    else
+      I18n.t("admin.announcements.window.always")
+    end
+  end
+
+  def announcement_channels_label(item)
+    labels = item.selected_channels.map { |key| I18n.t("admin.announcements.channels.#{key}") }
+    labels.presence&.join(" · ") || I18n.t("admin.common.dash")
+  end
+
+  def admin_concurrency_violation_lookback_count
+    @admin_concurrency_violation_lookback_count ||= StreamConcurrencyViolation.lookback.count
+  end
 end

backend/app/helpers/legal_helper.rb

@@ -1,6 +1,10 @@
 module LegalHelper
   def legal_last_updated
-    "3 giugno 2026"
+    "20 agosto 2026"
+  end
+
+  def terms_last_updated
+    "31 agosto 2026"
   end
 
   def cookie_policy_last_updated

backend/app/helpers/public/billing_helper.rb

@@ -1,6 +1,6 @@
 module Public
   module BillingHelper
-    def plan_billing_action(current_slug:, target_plan:, stripe_subscription_active:, current_interval: nil, subscription: nil)
+    def plan_billing_action(current_slug:, target_plan:, stripe_subscription_active:, current_interval: nil, subscription: nil, club: nil)
       if target_plan.slug == "free"
         return { kind: :current, label: I18n.t("billing.actions.current_plan") } if current_slug == "free"
         return { kind: :none } if stripe_subscription_active
@@ -8,17 +8,50 @@ module Public
         return { kind: :contact, label: I18n.t("billing.actions.contact_for_free") }
       end
 
+      quote = club&.active_billing_quote
+      if quote
+        if quote.plan_slug == target_plan.slug
+          if current_paid_plan?(subscription, target_plan)
+            return {
+              kind: :current,
+              label: "#{I18n.t('billing.actions.current_plan')} — #{quote.price_label}"
+            }
+          end
+
+          return { kind: :quoted, plan: target_plan, quote: quote, intervals: [quote.billing_interval] }
+        end
+
+        return { kind: :quoted_other, label: I18n.t("billing.bank_transfer.quoted_other") }
+      end
+
+      intervals = bank_transfer_intervals_for(target_plan)
       unless MatchLiveTv.stripe_enabled?
+        if current_paid_plan?(subscription, target_plan)
+          return { kind: :current, label: current_plan_label(target_plan, subscription) }
+        end
+        if MatchLiveTv.bank_transfer_configured?
+          return { kind: :bank_only, plan: target_plan, intervals: intervals }
+        end
+
         return { kind: :disabled, label: I18n.t("billing.actions.stripe_not_configured") }
       end
 
-      intervals = Billing::Stripe::PriceCatalog.available_intervals(plan_slug: target_plan.slug)
-      return { kind: :disabled, label: I18n.t("billing.actions.stripe_prices_not_configured") } if intervals.empty?
+      stripe_intervals = Billing::Stripe::PriceCatalog.available_intervals(plan_slug: target_plan.slug)
+      if stripe_intervals.empty?
+        if current_paid_plan?(subscription, target_plan)
+          return { kind: :current, label: current_plan_label(target_plan, subscription) }
+        end
+        if MatchLiveTv.bank_transfer_configured?
+          return { kind: :bank_only, plan: target_plan, intervals: intervals }
+        end
+
+        return { kind: :disabled, label: I18n.t("billing.actions.stripe_prices_not_configured") }
+      end
 
       active_interval = current_interval.presence || Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
 
       if current_slug == target_plan.slug && stripe_subscription_active && !subscription&.plan_change_pending?
-        other_intervals = intervals - [active_interval]
+        other_intervals = stripe_intervals - [active_interval]
         if other_intervals.empty?
           label = "#{I18n.t('billing.actions.current_plan')} — #{Billing::Stripe::PriceCatalog.label(plan_slug: target_plan.slug, interval: active_interval)}"
           return { kind: :current, label: label }
@@ -34,13 +67,17 @@ module Public
         }
       end
 
+      if current_paid_plan?(subscription, target_plan)
+        return { kind: :current, label: current_plan_label(target_plan, subscription) }
+      end
+
       if current_slug == "free" || !stripe_subscription_active
-        { kind: :checkout_options, plan: target_plan, intervals: intervals, subscription: subscription }
+        { kind: :checkout_options, plan: target_plan, intervals: stripe_intervals.presence || intervals, subscription: subscription }
       else
         {
           kind: :change_options,
           plan: target_plan,
-          intervals: intervals,
+          intervals: stripe_intervals,
           current_slug: current_slug,
           current_interval: active_interval,
           subscription: subscription
@@ -57,6 +94,10 @@ module Public
       Billing::Stripe::PlanChangeMessages.button_label(plan: plan, interval: interval, kind: btn_kind)
     end
 
+    def plan_cta_name(plan)
+      I18n.t("pages.plans.cta_name.#{plan.slug}", default: plan.name)
+    end
+
     def billing_plan_change_info_lines(subscription: nil)
       Billing::Stripe::PlanChangeMessages.billing_info_lines(subscription: subscription)
     end
@@ -92,5 +133,41 @@ module Public
       I18n.t("billing.actions.profile_missing", fields: missing.join(", "))
     end
 
+    def bank_transfer_intervals_for(plan)
+      Billing::Stripe::PriceCatalog.catalog_intervals(plan_slug: plan.slug)
+    end
+
+    def bank_transfer_price_label(plan, interval, quote: nil)
+      if quote&.matches?(plan.slug, interval)
+        quote.price_label
+      else
+        Billing::Stripe::PriceCatalog.format_interval_price(
+          Billing::Stripe::PriceCatalog.amount_cents(plan_slug: plan.slug, interval: interval),
+          interval
+        )
+      end
+    end
+
+    def show_bank_transfer_for?(club:, plan:, interval:, quote: nil, pending_transfer: nil)
+      return false unless club.present? && plan.slug != "free"
+      return false unless MatchLiveTv.bank_transfer_configured?
+      return false if quote && !quote.matches?(plan.slug, interval)
+      return false if pending_transfer&.awaiting_payment?
+      return false if current_paid_plan?(club.subscription, plan)
+
+      true
+    end
+
+    def current_paid_plan?(subscription, target_plan)
+      return false unless subscription&.active? && subscription.premium?
+      return false if subscription.plan_change_pending?
+
+      subscription.plan.slug == target_plan.slug
+    end
+
+    def current_plan_label(target_plan, subscription)
+      interval = subscription&.billing_interval.presence || Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
+      "#{I18n.t('billing.actions.current_plan')} — #{Billing::Stripe::PriceCatalog.label(plan_slug: target_plan.slug, interval: interval)}"
+    end
   end
 end

backend/app/helpers/public/live_helper.rb

@@ -53,6 +53,18 @@ module Public
     def live_match_card_heading(match, link_team: true)
       team = match.team
       club_name = team.club&.name.presence || t("score.default_club_name")
+      if match.tournament_match?
+        tournament = match.tournament
+        heading_name = tournament&.name.presence || club_name
+        matchup = match.matchup_label
+        return content_tag(:h3, class: "live-card__title") do
+          safe_join([
+            content_tag(:span, heading_name, class: "live-card__club"),
+            content_tag(:span, matchup, class: "live-card__matchup")
+          ])
+        end
+      end
+
       team_slug = team.respond_to?(:slug) ? team.slug : nil
       team_label = if link_team && team_slug.present?
         link_to(team.name, public_team_page_path(team_slug), class: "live-card__team-link")
@@ -68,6 +80,17 @@ module Public
     end
 
     def live_match_page_heading(match)
+      if match.tournament_match?
+        tournament = match.tournament
+        club_name = tournament&.name.presence || match.team.club&.name.presence || t("score.default_club_name")
+        return content_tag(:div, class: "live-page-heading") do
+          safe_join([
+            content_tag(:p, club_name, class: "live-page-heading__club"),
+            content_tag(:h1, match.matchup_label, class: "live-page-heading__matchup")
+          ])
+        end
+      end
+
       team = match.team
       club_name = team.club&.name.presence || t("score.default_club_name")
       content_tag(:div, class: "live-page-heading") do
@@ -91,7 +114,7 @@ module Public
              else score_state.away_points
              end
 
-      t("score.points_label", team: match.team.name, home: home, away: away, opponent: match.opponent_name)
+      t("score.points_label", team: match.home_display_name, home: home, away: away, opponent: match.away_display_name)
     end
 
     private

backend/app/helpers/public/regia_helper.rb

@@ -44,25 +44,61 @@ module Public
         partialsPrefix: t("regia.board.partials_prefix"),
         resumed: t("regia.js.resumed"),
         pausedCover: t("regia.js.paused_cover"),
+        muted: t("regia.js.muted"),
+        unmuted: t("regia.js.unmuted"),
         closed: t("regia.js.closed"),
         resumeError: t("regia.js.resume_error"),
         pauseError: t("regia.js.pause_error"),
+        muteError: t("regia.js.mute_error"),
         closeError: t("regia.js.close_error"),
         closeConfirm: t("regia.js.close_confirm"),
+        pauseConfirmTitle: t("regia.js.pause_confirm_title"),
+        pauseConfirmBody: t("regia.js.pause_confirm_body"),
+        resumeConfirmTitle: t("regia.js.resume_confirm_title"),
+        resumeConfirmBody: t("regia.js.resume_confirm_body"),
+        muteConfirmTitle: t("regia.js.mute_confirm_title"),
+        muteConfirmBody: t("regia.js.mute_confirm_body"),
+        unmuteConfirmTitle: t("regia.js.unmute_confirm_title"),
+        unmuteConfirmBody: t("regia.js.unmute_confirm_body"),
+        advancePeriodTitle: t("regia.js.advance_period_title"),
+        advancePeriodBody: t("regia.js.advance_period_body"),
+        confirmAction: t("regia.modal.confirm_action"),
+        stopConfirmTitle: t("regia.js.stop_confirm_title"),
         linkUnavailable: t("regia.js.link_unavailable"),
         linkCopied: t("regia.js.link_copied"),
         copyPrompt: t("regia.js.copy_prompt"),
         shareRegiaText: t("regia.js.share_regia_text"),
         shareLiveText: t("regia.js.share_live_text"),
+        minQualityUpdated: t("regia.js.min_quality_updated"),
+        minQualityError: t("regia.js.min_quality_error"),
+        minQualityAuto: t("regia.min_quality.auto"),
         previewWaiting: t("regia.preview_waiting"),
         streamEnded: t("regia.preview_ended"),
+        previewHide: t("regia.preview_hide"),
+        previewShow: t("regia.preview_show"),
+        previewOffHint: t("regia.preview_off_hint"),
         resumeLabel: t("regia.resume"),
         pauseLabel: t("regia.pause"),
+        muteLabel: t("regia.mute"),
+        unmuteLabel: t("regia.unmute"),
         endedBadge: t("regia.status.ended"),
         pausedBadge: t("regia.status.paused"),
         liveBadge: t("regia.status.live"),
         waitingBadge: t("regia.status.waiting"),
-        subtitlePrefix: t("regia.subtitle_prefix")
+        subtitlePrefix: t("regia.subtitle_prefix"),
+        telemetryWaiting: t("regia.telemetry.waiting"),
+        telemetryStale: t("regia.telemetry.stale"),
+        telemetryJustNow: t("regia.telemetry.just_now"),
+        telemetrySecondsAgo: t("regia.telemetry.seconds_ago"),
+        telemetryPublisherOn: t("regia.telemetry.publisher_on"),
+        telemetryPublisherOff: t("regia.telemetry.publisher_off"),
+        telemetryThermalNominal: t("regia.telemetry.thermal_nominal"),
+        telemetryThermalFair: t("regia.telemetry.thermal_fair"),
+        telemetryThermalSerious: t("regia.telemetry.thermal_serious"),
+        telemetryThermalCritical: t("regia.telemetry.thermal_critical"),
+        telemetryBitrateMax: t("regia.telemetry.bitrate_max"),
+        telemetryBitrateTitle: t("regia.telemetry.bitrate_title"),
+        telemetryBitrateTap: t("regia.telemetry.bitrate_tap")
       }.to_json
     end
 

backend/app/helpers/public/tournaments_helper.rb

@@ -0,0 +1,175 @@
+module Public
+  module TournamentsHelper
+    def tournament_team_chip(participant, name: nil)
+      label = name.presence || participant&.name.presence || t("tournaments.tbd")
+      logo = participant&.effective_logo_url
+      content_tag(:span, class: "tournament-team-chip") do
+        parts = []
+        if logo.present?
+          parts << image_tag(logo, alt: "", width: 28, height: 28)
+        end
+        parts << content_tag(:span, label)
+        safe_join(parts)
+      end
+    end
+
+    def tournament_datetime_local(time)
+      time&.in_time_zone&.strftime("%Y-%m-%dT%H:%M")
+    end
+
+    def tournament_invite_default_html(tournament, invited_by)
+      Tournaments::ComposeInviteEmail.default_html(tournament: tournament, invited_by: invited_by)
+    end
+
+    def tournament_invite_editor_html(tournament, invited_by)
+      stored = tournament.invite_draft_html.to_s
+      return tournament_invite_default_html(tournament, invited_by) if stored.blank?
+
+      Tournaments::ComposeInviteEmail.sanitize_html(stored)
+    end
+
+    def tournament_streaming_operator_label(user)
+      user&.name.presence || user&.email.presence || "—"
+    end
+
+    def tournament_pending_invites_for(match)
+      Array(@pending_invites_by_match_id&.[](match.id))
+    end
+
+    def tournament_invite_cancel_confirm(invitation)
+      count = @matches.to_a.count { |match| invitation.covers_match?(match) }
+      if count > 1
+        t("tournaments.hub.streaming_cancel_multi", email: invitation.email, count: count)
+      else
+        t("tournaments.hub.streaming_cancel", email: invitation.email)
+      end
+    end
+
+    def tournament_matches_grouped_by_date(matches)
+      matches.group_by { |match| match.scheduled_at&.in_time_zone&.to_date }
+    end
+
+    def tournament_streaming_coverage(matches)
+      assigned = pending = open = 0
+      matches.each do |match|
+        if match.broadcast_assignments.any?
+          assigned += 1
+        elsif tournament_pending_invites_for(match).any?
+          pending += 1
+        else
+          open += 1
+        end
+      end
+      { assigned: assigned, pending: pending, open: open, total: matches.size }
+    end
+
+    def tournament_broadcast_live_state(match)
+      sessions = match.stream_sessions.to_a
+      latest = sessions.max_by(&:created_at)
+      if latest && !latest.status.in?(%w[ended error])
+        return :live if latest.status.in?(%w[live reconnecting paused connecting])
+
+        return :waiting_operator
+      end
+      return :ended if sessions.any? { |session| session.status.in?(%w[ended error]) } || match.played?
+
+      if match.broadcast_assignments.any?
+        return :waiting_time if match.scheduled_upcoming?
+
+        return :waiting_operator
+      end
+      return :waiting_operator if tournament_pending_invites_for(match).any?
+
+      :uncovered
+    end
+
+    def tournament_streaming_live_counts(matches)
+      counts = Hash.new(0)
+      matches.each { |match| counts[tournament_broadcast_live_state(match)] += 1 }
+      counts
+    end
+
+    def tournament_public_live_session(match)
+      @live_by_match_id&.[](match.id)
+    end
+
+    def tournament_public_recording(match)
+      @recording_by_match_id&.[](match.id)
+    end
+
+    def tournament_public_board_state(match)
+      return :live if tournament_public_live_session(match)
+      return :replay if tournament_public_recording(match)
+      return :ended if match.result_recorded?
+      return :scheduled if match.scheduled_upcoming?
+
+      :waiting
+    end
+
+    def tournament_public_watch_target(session)
+      return unless session
+      if session.matchlivetv_platform? && session.publicly_listed?
+        return [public_live_path(session), t("tournaments.page.watch_live"), {}]
+      end
+      if session.youtube_watch_url.present?
+        return [session.youtube_watch_url, t("live.show.youtube_watch_link"), { target: "_blank", rel: "noopener" }]
+      end
+
+      nil
+    end
+
+    def tournament_public_score_label(match)
+      return "#{match.home_score}–#{match.away_score}" if match.home_score.present? && match.away_score.present?
+
+      session = tournament_public_live_session(match)
+      score = session&.score_state
+      return unless score
+
+      "#{score.home_points}–#{score.away_points}"
+    end
+
+    def tournament_match_sides_locked?(match)
+      match.result_recorded?
+    end
+
+    def tournament_phase_label(match)
+      match.tournament_round&.name.presence || match.tournament_group&.name.presence || "—"
+    end
+
+    def tournament_side_blank_label(match, side)
+      source = tournament_side_source_label(match, side)
+      source.presence || t("tournaments.tbd")
+    end
+
+    def tournament_side_source_label(match, side)
+      kind = match.public_send("#{side}_source_kind").to_s
+      case kind
+      when "winner_match"
+        source = tournament_source_match(match, side)
+        return t("tournaments.hub.winner_tbd") if source.blank?
+
+        t("tournaments.hub.winner_of", match: source.matchup_label)
+      when "group_rank"
+        group = tournament_source_group(match, side)
+        rank = match.public_send("#{side}_source_rank").to_i
+        return t("tournaments.hub.group_rank_tbd") if group.blank? || rank <= 0
+
+        t("tournaments.hub.group_rank", group: group.name, rank: rank)
+      end
+    end
+
+    def tournament_source_match(match, side)
+      id = match.public_send("#{side}_source_match_id")
+      return if id.blank?
+
+      @matches&.find { |item| item.id == id } || Match.find_by(id: id)
+    end
+
+    def tournament_source_group(match, side)
+      id = match.public_send("#{side}_source_group_id")
+      return if id.blank?
+
+      @groups&.find { |item| item.id == id } || TournamentGroup.find_by(id: id)
+    end
+  end
+end

backend/app/jobs/analytics/aggregate_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Analytics
+  class AggregateJob < ApplicationJob
+    queue_as :default
+
+    def perform(purge: false)
+      redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+      lock_key = "analytics:aggregate:lock"
+      acquired = redis.set(lock_key, "1", nx: true, ex: 120)
+      return unless acquired
+
+      begin
+        service = Analytics::Aggregate.new
+        service.call
+        service.purge_old! if purge
+      ensure
+        redis.del(lock_key)
+      end
+    rescue StandardError => e
+      Rails.logger.error("[analytics] aggregate failed: #{e.class} #{e.message}")
+      raise
+    end
+  end
+end

backend/app/jobs/cleanup_expired_sessions_job.rb

@@ -6,7 +6,7 @@ class CleanupExpiredSessionsJob
                  .where("updated_at < ?", 6.hours.ago)
                  .find_each do |session|
       session.fail! if session.may_fail?
-      Mediamtx::Client.new.delete_path(session)
+      Mediamtx::Client.for_session(session).delete_path(session)
     end
   end
 end

backend/app/jobs/expire_ended_subscriptions_job.rb

@@ -6,12 +6,37 @@ class ExpireEndedSubscriptionsJob
     free_plan = Plan["free"]
 
     Subscription.where(cancel_at_period_end: true)
-                  .where("current_period_end <= ?", Time.current)
-                  .where.not(plan_id: free_plan.id)
-                  .find_each do |sub|
-      Billing::Stripe::FinalizeSubscription.call(club: sub.club)
+                .where("current_period_end <= ?", Time.current)
+                .where.not(plan_id: free_plan.id)
+                .where(admin_comped: false)
+                .find_each do |sub|
+      expire!(sub)
     rescue StandardError => e
       Rails.logger.warn("[ExpireEndedSubscriptions] club=#{sub.club_id} #{e.message}")
     end
   end
+
+  private
+
+  def expire!(sub)
+    if sub.stripe_subscription_id.present?
+      Billing::Stripe::FinalizeSubscription.call(club: sub.club)
+    else
+      Billing::AssignPlan.call(
+        club: sub.club,
+        plan_slug: "free",
+        status: "active",
+        stripe_attrs: {
+          stripe_subscription_id: nil,
+          stripe_schedule_id: nil,
+          current_period_start: nil,
+          current_period_end: nil,
+          cancel_at_period_end: false,
+          billing_interval: nil,
+          pending_plan_id: nil,
+          pending_billing_interval: nil
+        }
+      )
+    end
+  end
 end

backend/app/jobs/generate_cover_slate_job.rb

@@ -0,0 +1,19 @@
+class GenerateCoverSlateJob < ApplicationJob
+  queue_as :default
+
+  def self.enqueue_for(record)
+    return unless record&.cover_image&.attached?
+
+    queue = record.is_a?(Match) ? :critical : :default
+    set(queue: queue).perform_later(record.class.name, record.id)
+  end
+
+  def perform(class_name, record_id)
+    record = class_name.constantize.find_by(id: record_id)
+    return unless record&.cover_image&.attached?
+
+    Streams::GenerateCoverSlate.call(record)
+  rescue Streams::GenerateCoverSlate::Error => e
+    Rails.logger.warn("[GenerateCoverSlateJob] #{class_name}##{record_id} #{e.message}")
+  end
+end

backend/app/jobs/recordings/clear_temporary_media_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Recordings
+  class ClearTemporaryMediaJob
+    include Sidekiq::Job
+    sidekiq_options retry: 3, queue: "default"
+
+    def perform(recording_id, reason = "verified")
+      recording = Recording.find_by(id: recording_id)
+      return unless recording
+
+      Recordings::ClearTemporaryMedia.new(
+        recording,
+        reason: reason.to_sym,
+        force: reason.to_s == "verified"
+      ).call
+    end
+  end
+end

backend/app/jobs/recordings/post_process_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Recordings
   class PostProcessJob
     include Sidekiq::Job
@@ -7,10 +9,30 @@ module Recordings
       recording = Recording.find_by(id: recording_id)
       return unless recording&.ready?
 
-      Recordings::NotifyReady.new(recording).call
+      begin
+        Recordings::NotifyReady.new(recording).call
+      rescue StandardError => e
+        # SMTP/ntfy giù non deve bloccare VerifyYoutubeReplay né il resto del post-process.
+        Rails.logger.warn(
+          "[Recordings::PostProcessJob] notify_failed recording=#{recording.id} " \
+          "#{e.class}: #{e.message}"
+        )
+      end
 
+      if recording.temporary_storage?
+        grace = MatchLiveTv.youtube_replay_verify_grace_secs
+        Rails.logger.info(
+          "[Recordings::PostProcessJob] schedule VerifyYoutubeReplay " \
+          "recording=#{recording.id} grace=#{grace}s"
+        )
+        Recordings::VerifyYoutubeReplayJob.perform_in(grace.seconds, recording.id, 0)
+        return
+      end
+
+      # Solo MatchLiveTV-only: eventuale re-upload manuale/flag legacy (non per live YouTube).
       return unless recording.auto_publish_youtube?
       return if recording.youtube_video_id.present?
+      return if recording.source_platform == "youtube"
 
       Recordings::PublishToYoutubeJob.perform_async(recording.id)
     end

backend/app/jobs/recordings/purge_temporary_media_job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Recordings
+  # Safety net: elimina copie temp scadute (anche se verify non è mai riuscito).
+  class PurgeTemporaryMediaJob
+    include Sidekiq::Job
+    sidekiq_options retry: 1, queue: "default"
+
+    def perform
+      scope = Recording.temporary_media_pending_purge
+      count = 0
+
+      scope.find_each do |recording|
+        unless recording.youtube_verified_at.present?
+          Rails.logger.warn(
+            "[Recordings::PurgeTemporaryMediaJob] anomaly_unverified_expiry " \
+            "recording=#{recording.id} session=#{recording.stream_session_id} " \
+            "youtube_video_id=#{recording.youtube_video_id.inspect} " \
+            "temp_expires_at=#{recording.temp_expires_at.inspect}"
+          )
+        end
+
+        Recordings::ClearTemporaryMedia.new(
+          recording,
+          reason: :max_retention,
+          force: true
+        ).call
+        count += 1
+      end
+
+      Rails.logger.info("[Recordings::PurgeTemporaryMediaJob] processed=#{count}")
+      count
+    end
+  end
+end

backend/app/jobs/recordings/verify_youtube_replay_job.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Recordings
+  class VerifyYoutubeReplayJob
+    include Sidekiq::Job
+    sidekiq_options retry: 0, queue: "default"
+
+    def perform(recording_id, attempt = 0)
+      recording = Recording.find_by(id: recording_id)
+      return unless recording&.temporary_storage?
+      return if recording.deleted?
+
+      attempt = attempt.to_i
+      max = MatchLiveTv.youtube_replay_verify_max_attempts
+      result = Recordings::VerifyYoutubeReplay.new(recording).call
+
+      if result.ok?
+        recording.reload
+        embeddable = recording.metadata.is_a?(Hash) && recording.metadata.dig("youtube", "embeddable") != false
+        if embeddable
+          Recordings::ClearTemporaryMediaJob.perform_async(recording.id, "verified")
+        else
+          Rails.logger.warn(
+            "[Recordings::VerifyYoutubeReplayJob] keep_temp recording=#{recording.id} " \
+            "youtube_not_embeddable"
+          )
+        end
+        return
+      end
+
+      if result.retriable? && attempt + 1 < max
+        delay = backoff_secs(attempt)
+        Rails.logger.info(
+          "[Recordings::VerifyYoutubeReplayJob] retry recording=#{recording.id} " \
+          "attempt=#{attempt + 1}/#{max} in=#{delay}s msg=#{result.message}"
+        )
+        self.class.perform_in(delay.seconds, recording.id, attempt + 1)
+        return
+      end
+
+      Rails.logger.warn(
+        "[Recordings::VerifyYoutubeReplayJob] give_up recording=#{recording.id} " \
+        "attempts=#{attempt + 1} msg=#{result.message} " \
+        "temp_expires_at=#{recording.temp_expires_at.inspect}"
+      )
+    end
+
+    private
+
+    def backoff_secs(attempt)
+      base = MatchLiveTv.youtube_replay_verify_base_interval_secs
+      # 300, 600, 1200, ... capped at 1h
+      [base * (2**attempt), 3600].min
+    end
+  end
+end

backend/app/jobs/streams/autoscaler_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Streams
+  class AutoscalerJob
+    include Sidekiq::Job
+
+    sidekiq_options retry: 1, queue: "default"
+
+    INTERVAL_SECS = ENV.fetch("STREAM_AUTOSCALE_INTERVAL_SECS", "60").to_i
+    REDIS_CHAIN_KEY = "streams:autoscaler:chain"
+    KICK_DEBOUNCE_KEY = "streams:autoscaler:kick"
+    KICK_DEBOUNCE_SECS = ENV.fetch("STREAM_AUTOSCALE_KICK_DEBOUNCE_SECS", "5").to_i
+
+    def self.ensure_chain
+      return unless redis
+      return if redis.get(REDIS_CHAIN_KEY)
+
+      redis.set(REDIS_CHAIN_KEY, "1", ex: INTERVAL_SECS * 2)
+      perform_in(INTERVAL_SECS)
+    end
+
+    # Kick immediato (es. NoCapacity / soft-free bassi). Debounce anti-flood Sidekiq.
+    def self.kick!
+      return false unless Streams::Autoscaler.enabled?
+      return false unless redis
+      return false unless redis.set(KICK_DEBOUNCE_KEY, "1", nx: true, ex: KICK_DEBOUNCE_SECS)
+
+      perform_async
+      true
+    end
+
+    def self.redis
+      @redis ||= Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+    rescue Redis::CannotConnectError
+      nil
+    end
+
+    def perform
+      Streams::Autoscaler.reconcile!
+    ensure
+      self.class.redis&.set(REDIS_CHAIN_KEY, "1", ex: INTERVAL_SECS * 2)
+      self.class.perform_in(INTERVAL_SECS)
+    end
+  end
+end

backend/app/jobs/streams/night_cloud_sweeper_job.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Streams
+  class NightCloudSweeperJob
+    include Sidekiq::Job
+
+    sidekiq_options retry: 1, queue: "default"
+
+    INTERVAL_SECS = ENV.fetch("STREAM_NIGHT_SWEEP_INTERVAL_SECS", "900").to_i
+    REDIS_CHAIN_KEY = "streams:night_sweep:chain"
+
+    def self.ensure_chain
+      return unless redis
+      return if redis.get(REDIS_CHAIN_KEY)
+
+      redis.set(REDIS_CHAIN_KEY, "1", ex: INTERVAL_SECS * 2)
+      perform_in(INTERVAL_SECS)
+    end
+
+    def self.redis
+      @redis ||= Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+    rescue Redis::CannotConnectError
+      nil
+    end
+
+    def perform
+      Streams::NightCloudSweeper.sweep!
+    ensure
+      self.class.redis&.set(REDIS_CHAIN_KEY, "1", ex: INTERVAL_SECS * 2)
+      self.class.perform_in(INTERVAL_SECS)
+    end
+  end
+end

backend/app/jobs/youtube_relay_ensure_job.rb

@@ -1,6 +1,6 @@
-# Avvia/riavvia il relay YouTube solo nel container sidekiq (YOUTUBE_RELAY_WORKER=1).
+# Avvia/riavvia il relay YouTube sul worker del nodo (coda youtube_relay_<slug>).
 class YoutubeRelayEnsureJob < ApplicationJob
-  queue_as :default
+  queue_as Streams::YoutubeRelay::QUEUE
 
   def perform(session_id)
     session = StreamSession.find_by(id: session_id)

backend/app/jobs/youtube_relay_stop_job.rb

@@ -1,10 +1,23 @@
+# Ferma il relay solo sull'owner. Se il job gira su un altro host, requeue breve.
 class YoutubeRelayStopJob < ApplicationJob
-  queue_as :default
+  queue_as Streams::YoutubeRelay::QUEUE
 
-  def perform(session_id)
+  discard_on ActiveJob::DeserializationError
+
+  def perform(session_id, attempts = 0)
     session = StreamSession.find_by(id: session_id)
     return unless session
 
-    Streams::YoutubeRelay.stop_on_worker!(session) if Streams::YoutubeRelay.worker?
+    unless Streams::YoutubeRelay.worker?
+      # Solo i worker relay processano questa coda in modo utile.
+      return
+    end
+
+    result = Streams::YoutubeRelay.stop_on_worker!(session)
+    return unless result == :wrong_host
+    return if attempts >= 30
+
+    self.class.set(wait: 2.seconds, queue: Streams::YoutubeRelay.queue_for(session))
+      .perform_later(session_id, attempts + 1)
   end
 end

backend/app/mailers/billing/bank_transfer_mailer.rb

@@ -0,0 +1,35 @@
+module Billing
+  class BankTransferMailer < ApplicationMailer
+    def instructions
+      @order = params[:order]
+      @club = @order.club
+      @iban = MatchLiveTv.bank_transfer_iban
+      @holder = MatchLiveTv.bank_transfer_account_holder
+      @bank_name = MatchLiveTv.bank_transfer_bank_name
+      @bic = MatchLiveTv.bank_transfer_bic
+      @proof_email = MatchLiveTv.bank_transfer_proof_email
+
+      mail(
+        to: recipient_email,
+        subject: t("mailers.bank_transfer.instructions.subject", plan: @order.plan.name)
+      )
+    end
+
+    def plan_activated
+      @order = params[:order]
+      @club = @order.club
+      @subscription = @club.subscription
+
+      mail(
+        to: recipient_email,
+        subject: t("mailers.bank_transfer.plan_activated.subject", plan: @order.plan.name)
+      )
+    end
+
+    private
+
+    def recipient_email
+      @club.billing_email.presence || @club.owner&.email
+    end
+  end
+end

backend/app/mailers/billing/invoice_mailer.rb

@@ -5,17 +5,37 @@ module Billing
       @club = @invoice.club
 
       I18n.with_locale(I18n.locale) do
-        prefix = t("mailers.invoice.attachment_prefix")
-        attachments["#{prefix}-#{@invoice.number.parameterize}.pdf"] = {
-          mime_type: "application/pdf",
-          content: @invoice.pdf.download
-        }
-
+        attach_invoice_pdf!
         mail(
           to: @club.billing_email,
           subject: t("mailers.invoice.subject", number: @invoice.display_number)
         )
       end
     end
+
+    def plan_activated_with_invoice
+      @invoice = params[:invoice]
+      @club = @invoice.club
+
+      I18n.with_locale(I18n.locale) do
+        attach_invoice_pdf!
+        mail(
+          to: @club.billing_email,
+          subject: t("mailers.invoice_activated.subject",
+                     plan: @club.subscription&.plan&.name || @invoice.display_number,
+                     number: @invoice.display_number)
+        )
+      end
+    end
+
+    private
+
+    def attach_invoice_pdf!
+      prefix = t("mailers.invoice.attachment_prefix")
+      attachments["#{prefix}-#{@invoice.number.parameterize}.pdf"] = {
+        mime_type: "application/pdf",
+        content: @invoice.pdf.download
+      }
+    end
   end
 end

backend/app/mailers/contact_mailer.rb

@@ -0,0 +1,25 @@
+class ContactMailer < ApplicationMailer
+  def inquiry(name:, email:, club_name:, topic:, message:)
+    @name = name
+    @email = email
+    @club_name = club_name.presence
+    @topic = topic
+    @message = message
+
+    mail(
+      to: recipient_for(topic),
+      reply_to: email,
+      subject: t("mailers.contact.subject.#{topic}", name: name)
+    )
+  end
+
+  private
+
+  def recipient_for(topic)
+    if topic == "privacy"
+      MatchLiveTv.privacy_controller_email
+    else
+      MatchLiveTv.support_email
+    end
+  end
+end

backend/app/mailers/teams/invitation_mailer.rb

@@ -0,0 +1,25 @@
+module Teams
+  class InvitationMailer < ApplicationMailer
+    default from: -> { MatchLiveTv.mail_from }
+
+    def transmission_invite(team:, invitation:, invite_url:, invited_by:)
+      @team = team
+      @club = team.club
+      @invitation = invitation
+      @invite_url = invite_url
+      @invited_by = invited_by
+      @expires_on = I18n.l(invitation.expires_at.to_date, format: :long)
+
+      I18n.with_locale(I18n.locale) do
+        mail(
+          to: invitation.email,
+          subject: t(
+            "mailers.transmission_invite.subject",
+            team: @team.name,
+            club: @club.name
+          )
+        )
+      end
+    end
+  end
+end

backend/app/mailers/tournaments/invitation_mailer.rb

@@ -0,0 +1,27 @@
+module Tournaments
+  class InvitationMailer < ApplicationMailer
+    default from: -> { MatchLiveTv.mail_from }
+
+    def transmission_invite(tournament:, invitation:, invite_url:, invited_by:, body_html: nil)
+      @tournament = tournament
+      @club = tournament.club
+      @invitation = invitation
+      @invite_url = invite_url
+      @invited_by = invited_by
+      @expires_on = I18n.l(invitation.expires_at.to_date, format: :long)
+      @body_html = body_html.presence || invitation.email_html.presence
+      @body_text = ActionController::Base.helpers.strip_tags(@body_html.to_s).squish
+
+      I18n.with_locale(I18n.locale) do
+        mail(
+          to: invitation.email,
+          subject: t(
+            "mailers.tournament_invite.subject",
+            tournament: @tournament.name,
+            club: @club.name
+          )
+        )
+      end
+    end
+  end
+end

backend/app/models/admin_account.rb

@@ -1,5 +1,8 @@
 class AdminAccount < ApplicationRecord
+  include PasswordComplexity
+
   has_secure_password
+  has_many :app_announcements, foreign_key: :created_by_admin_id, dependent: :nullify, inverse_of: :created_by_admin
 
   validates :username, presence: true, uniqueness: true
 end

backend/app/models/analytics_event.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class AnalyticsEvent < ApplicationRecord
+  self.table_name = "analytics_events"
+
+  EVENT_TYPES = %w[click scroll pageview move].freeze
+  DEVICES = %w[mobile tablet desktop].freeze
+
+  validates :page_path, presence: true
+  validates :device, inclusion: { in: DEVICES }
+  validates :event_type, inclusion: { in: EVENT_TYPES }
+  validates :occurred_at, presence: true
+  validates :weight, numericality: { greater_than: 0, less_than_or_equal_to: 500 }
+end

backend/app/models/analytics_page_cell.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AnalyticsPageCell < ApplicationRecord
+  self.table_name = "analytics_page_cells"
+
+  GRID_SIZE = 40
+
+  validates :day, :page_path, :device, :cell_x, :cell_y, presence: true
+  validates :device, inclusion: { in: AnalyticsEvent::DEVICES }
+  validates :cell_x, :cell_y, inclusion: { in: 0...(GRID_SIZE) }
+  validates :click_count, numericality: { greater_than_or_equal_to: 0 }
+  validates :move_count, numericality: { greater_than_or_equal_to: 0 }
+end

backend/app/models/analytics_page_snapshot.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AnalyticsPageSnapshot < ApplicationRecord
+  self.table_name = "analytics_page_snapshots"
+
+  has_one_attached :image
+
+  validates :page_path, presence: true
+  validates :device, inclusion: { in: AnalyticsEvent::DEVICES }
+  validates :width, :height, numericality: { greater_than: 0 }
+  validates :captured_at, presence: true
+end

backend/app/models/analytics_page_stat.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class AnalyticsPageStat < ApplicationRecord
+  self.table_name = "analytics_page_stats"
+
+  validates :day, :page_path, :device, presence: true
+  validates :device, inclusion: { in: AnalyticsEvent::DEVICES }
+
+  def avg_scroll_pct
+    return 0 if scroll_samples.to_i <= 0
+
+    (scroll_sum_pct.to_f / scroll_samples).round
+  end
+end

backend/app/models/app_announcement.rb

@@ -0,0 +1,240 @@
+class AppAnnouncement < ApplicationRecord
+  KINDS = %w[info maintenance update].freeze
+  SEVERITIES = %w[info warning critical].freeze
+  STATUSES = %w[draft published archived].freeze
+  CHANNELS = {
+    android: :show_on_android,
+    ios: :show_on_ios,
+    web_public: :show_on_web_public,
+    web_private: :show_on_web_private
+  }.freeze
+  COPY_KEYS = %w[title body action_url action_label].freeze
+  URL_KEYS = %w[action_url].freeze
+  TITLE_KEYS = %w[title].freeze
+  BODY_KEYS = %w[body].freeze
+  LABEL_KEYS = %w[action_label].freeze
+  LOCALE_FALLBACKS = {
+    "it" => %w[it],
+    "en" => %w[en it],
+    "fr" => %w[fr en it],
+    "de" => %w[de en it],
+    "es" => %w[es en it]
+  }.freeze
+
+  belongs_to :created_by_admin, class_name: "AdminAccount", optional: true
+
+  validates :kind, :severity, :status, :title, :body, presence: true
+  validates :kind, inclusion: { in: KINDS }
+  validates :severity, inclusion: { in: SEVERITIES }
+  validates :status, inclusion: { in: STATUSES }
+  validates :title, length: { maximum: 120 }, allow_blank: true
+  validates :body, length: { maximum: 2000 }, allow_blank: true
+  validates :action_label, length: { maximum: 40 }, allow_blank: true
+  URL_KEYS.each do |field|
+    validates field, format: { with: /\Ahttps?:\/\/.+/i, allow_blank: true }
+  end
+  validate :ends_at_after_starts_at
+  validate :at_least_one_channel
+  validate :translations_are_valid
+  before_validation :normalize_translations
+
+  scope :newest, -> { order(created_at: :desc) }
+  scope :published, -> { where(status: "published") }
+  scope :active_now, lambda {
+    now = Time.current
+    published
+      .where("starts_at IS NULL OR starts_at <= ?", now)
+      .where("ends_at IS NULL OR ends_at > ?", now)
+  }
+
+  def self.for_channel(channel)
+    column = CHANNELS[channel.to_sym]
+    raise ArgumentError, "unknown announcement channel: #{channel}" if column.blank?
+
+    active_now.where(column => true)
+  end
+
+  def self.for_app
+    active_now.where("show_on_android = TRUE OR show_on_ios = TRUE")
+  end
+
+  def self.for_platform(platform)
+    case platform.to_s
+    when "android" then for_channel(:android)
+    when "ios" then for_channel(:ios)
+    else for_app
+    end
+  end
+
+  def published?
+    status == "published"
+  end
+
+  def selected_channels
+    CHANNELS.each_with_object([]) do |(key, column), keys|
+      keys << key if public_send(column)
+    end
+  end
+
+  def copy_values_for(locale)
+    loc = locale.to_s
+    if default_locale?(loc)
+      COPY_KEYS.index_with { |key| public_send(key).to_s.presence }
+    else
+      translation_hash(loc)
+    end
+  end
+
+  def filled_locale_codes
+    LocaleResolver.available.select { |loc| locale_has_copy?(loc) }.map(&:to_s)
+  end
+
+  def as_api_json(platform: nil, locale: I18n.locale)
+    {
+      id: id,
+      kind: kind,
+      severity: severity,
+      title: copy_for("title", locale: locale),
+      body: copy_for("body", locale: locale),
+      dismissible: dismissible,
+      action_url: resolved_action_url(platform, locale: locale),
+      action_label: copy_for("action_label", locale: locale).presence,
+      starts_at: starts_at&.iso8601,
+      ends_at: ends_at&.iso8601
+    }
+  end
+
+  def localized_title(locale: I18n.locale)
+    copy_for("title", locale: locale)
+  end
+
+  def localized_body(locale: I18n.locale)
+    copy_for("body", locale: locale)
+  end
+
+  def localized_action_label(locale: I18n.locale)
+    copy_for("action_label", locale: locale)
+  end
+
+  def resolved_action_url(platform, locale: I18n.locale)
+    url = copy_for("action_url", locale: locale)
+    return url if url.present?
+    return nil unless kind == "update"
+
+    case platform.to_s
+    when "android" then MatchLiveTv.play_store_url
+    when "ios" then MatchLiveTv.app_store_url
+    end
+  end
+
+  private
+
+  def copy_for(field, locale: I18n.locale)
+    field = field.to_s
+    locale_chain(locale).each do |loc|
+      value = value_for(loc, field)
+      return value if value.present?
+    end
+    nil
+  end
+
+  def value_for(locale, key)
+    copy_values_for(locale)[key].presence
+  end
+
+  def translation_hash(locale)
+    raw = translations.is_a?(Hash) ? translations : {}
+    values = raw.stringify_keys[locale.to_s]
+    return {} unless values.is_a?(Hash)
+
+    values.stringify_keys
+  end
+
+  def locale_chain(locale)
+    loc = (LocaleResolver.normalize(locale) || I18n.default_locale).to_s
+    LOCALE_FALLBACKS[loc] || [loc, I18n.default_locale.to_s].uniq
+  end
+
+  def locale_has_copy?(locale)
+    values = copy_values_for(locale)
+    values["title"].present? || values["body"].present?
+  end
+
+  def default_locale?(locale)
+    locale.to_s == I18n.default_locale.to_s
+  end
+
+  def normalize_translations
+    self.translations = self.class.sanitize_translations(translations)
+  end
+
+  def self.sanitize_translations(value)
+    raw = coerce_translation_hash(value)
+    LocaleResolver.available.each_with_object({}) do |loc, acc|
+      next if loc.to_s == I18n.default_locale.to_s
+
+      payload = raw[loc.to_s]
+      next unless payload.is_a?(Hash)
+
+      cleaned = COPY_KEYS.each_with_object({}) do |key, fields|
+        text = payload[key].to_s.strip
+        fields[key] = text if text.present?
+      end
+      acc[loc.to_s] = cleaned if cleaned.any?
+    end
+  end
+
+  def self.coerce_translation_hash(value)
+    hash = if value.is_a?(ActionController::Parameters)
+             value.to_unsafe_h
+           elsif value.is_a?(Hash)
+             value
+           else
+             {}
+           end
+    hash.deep_stringify_keys
+  end
+  private_class_method :coerce_translation_hash
+
+  def at_least_one_channel
+    return if show_on_android? || show_on_ios? || show_on_web_public? || show_on_web_private?
+
+    errors.add(:base, :no_channel)
+  end
+
+  def ends_at_after_starts_at
+    return if starts_at.blank? || ends_at.blank?
+    return if ends_at > starts_at
+
+    errors.add(:ends_at, :invalid)
+  end
+
+  def translations_are_valid
+    translation_entries.each do |locale, payload|
+      TITLE_KEYS.each do |key|
+        errors.add(:base, :translation_too_long, locale: locale, field: key) if payload[key].to_s.length > 120
+      end
+      BODY_KEYS.each do |key|
+        errors.add(:base, :translation_too_long, locale: locale, field: key) if payload[key].to_s.length > 2000
+      end
+      LABEL_KEYS.each do |key|
+        errors.add(:base, :translation_too_long, locale: locale, field: key) if payload[key].to_s.length > 40
+      end
+      URL_KEYS.each do |key|
+        url = payload[key].to_s
+        next if url.blank? || url.match?(/\Ahttps?:\/\/.+/i)
+
+        errors.add(:base, :translation_invalid_url, locale: locale)
+      end
+    end
+  end
+
+  def translation_entries
+    raw = translations.is_a?(Hash) ? translations : {}
+    raw.stringify_keys.filter_map do |locale, payload|
+      next unless payload.is_a?(Hash)
+
+      [locale, payload.stringify_keys]
+    end
+  end
+end

backend/app/models/billing/club_quote.rb

@@ -0,0 +1,34 @@
+module Billing
+  class ClubQuote < ApplicationRecord
+    self.table_name = "billing_club_quotes"
+
+    PLAN_SLUGS = %w[premium_light premium_full].freeze
+    INTERVALS = Billing::Stripe::PriceCatalog::INTERVALS
+
+    belongs_to :club
+    belongs_to :created_by_admin, class_name: "AdminAccount", optional: true
+
+    validates :plan_slug, inclusion: { in: PLAN_SLUGS }
+    validates :billing_interval, inclusion: { in: INTERVALS }
+    validates :amount_cents, numericality: { greater_than: 0 }
+    validates :currency, presence: true
+
+    scope :active, -> { where(active: true) }
+
+    def matches?(plan_slug, interval)
+      self.plan_slug == plan_slug.to_s && billing_interval == interval.to_s
+    end
+
+    def plan
+      Plan[plan_slug]
+    end
+
+    def formatted_amount
+      Billing::Stripe::PriceCatalog.format_eur(amount_cents)
+    end
+
+    def price_label
+      Billing::Stripe::PriceCatalog.format_interval_price(amount_cents, billing_interval)
+    end
+  end
+end

backend/app/models/billing/payment.rb

@@ -2,14 +2,17 @@ module Billing
   class Payment < ApplicationRecord
     self.table_name = "billing_payments"
 
-    STATUSES = %w[paid failed refunded].freeze
+    STATUSES = %w[pending paid failed refunded].freeze
+    PROVIDERS = %w[stripe bank_transfer].freeze
 
     belongs_to :club
     has_one :invoice, class_name: "Billing::Invoice", foreign_key: :billing_payment_id, dependent: :nullify
+    has_one :transfer_order, class_name: "Billing::TransferOrder", foreign_key: :billing_payment_id, dependent: :nullify
 
     validates :amount_cents, numericality: { greater_than: 0 }
     validates :currency, presence: true
     validates :status, inclusion: { in: STATUSES }
+    validates :provider, inclusion: { in: PROVIDERS }
     validates :stripe_invoice_id, uniqueness: true, allow_nil: true
 
     scope :recent, -> { order(paid_at: :desc, created_at: :desc) }
@@ -62,7 +65,12 @@ module Billing
     end
 
     def display_status
-      { "paid" => "Pagato", "failed" => "Non riuscito", "refunded" => "Rimborsato" }[status] || status
+      {
+        "pending" => "In attesa di bonifico",
+        "paid" => "Pagato",
+        "failed" => "Non riuscito",
+        "refunded" => "Rimborsato"
+      }[status] || status
     end
 
     def invoice_for_display

backend/app/models/billing/transfer_order.rb

@@ -0,0 +1,67 @@
+module Billing
+  class TransferOrder < ApplicationRecord
+    self.table_name = "billing_transfer_orders"
+
+    KINDS = %w[list_price commercial_quote].freeze
+    STATUSES = %w[awaiting_payment paid cancelled].freeze
+    PLAN_SLUGS = ClubQuote::PLAN_SLUGS
+    INTERVALS = ClubQuote::INTERVALS
+
+    belongs_to :club
+    belongs_to :billing_club_quote, class_name: "Billing::ClubQuote", optional: true
+    belongs_to :billing_payment, class_name: "Billing::Payment", optional: true
+    belongs_to :requested_by_user, class_name: "User", optional: true
+    belongs_to :confirmed_by_admin, class_name: "AdminAccount", optional: true
+
+    validates :plan_slug, inclusion: { in: PLAN_SLUGS }
+    validates :billing_interval, inclusion: { in: INTERVALS }
+    validates :amount_cents, numericality: { greater_than: 0 }
+    validates :kind, inclusion: { in: KINDS }
+    validates :status, inclusion: { in: STATUSES }
+    validates :reference_code, presence: true, uniqueness: true
+    validates :currency, presence: true
+
+    scope :awaiting_payment, -> { where(status: "awaiting_payment").order(created_at: :desc) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def awaiting_payment?
+      status == "awaiting_payment"
+    end
+
+    def paid?
+      status == "paid"
+    end
+
+    def quoted?
+      kind == "commercial_quote"
+    end
+
+    def plan
+      Plan[plan_slug]
+    end
+
+    def formatted_amount
+      format("%.2f €", amount_cents / 100.0)
+    end
+
+    def price_label
+      Billing::Stripe::PriceCatalog.format_interval_price(amount_cents, billing_interval)
+    end
+
+    def payment_causal
+      "MLTV #{reference_code} #{club.name}".truncate(140, omission: "")
+    end
+
+    def cancel!
+      return self unless awaiting_payment?
+
+      transaction do
+        update!(status: "cancelled", cancelled_at: Time.current)
+        if billing_payment&.status == "pending"
+          billing_payment.update!(status: "failed")
+        end
+      end
+      self
+    end
+  end
+end

backend/app/models/club.rb

@@ -1,14 +1,19 @@
 class Club < ApplicationRecord
   include Brandable
+  include Coverable
   include ClubBillingProfile
 
   has_many :club_memberships, dependent: :destroy
   has_many :users, through: :club_memberships
   has_many :teams, dependent: :destroy
+  has_many :tournaments, dependent: :restrict_with_error
   has_one :youtube_credential, dependent: :destroy
   has_one :subscription, dependent: :destroy
+  has_one :billing_quote, -> { where(active: true) }, class_name: "Billing::ClubQuote", inverse_of: :club
+  has_many :billing_quotes, class_name: "Billing::ClubQuote", dependent: :destroy, inverse_of: :club
   has_many :billing_payments, class_name: "Billing::Payment", dependent: :destroy
   has_many :billing_invoices, class_name: "Billing::Invoice", dependent: :destroy
+  has_many :billing_transfer_orders, class_name: "Billing::TransferOrder", dependent: :destroy
 
   validates :name, presence: true
   validates :sport, presence: true
@@ -23,6 +28,14 @@ class Club < ApplicationRecord
     club_memberships.exists?(user: user, role: "owner")
   end
 
+  def active_billing_quote
+    billing_quote
+  end
+
+  def pending_transfer_order
+    billing_transfer_orders.awaiting_payment.first
+  end
+
   private
 
   def branding_parent

backend/app/models/concerns/coverable.rb

@@ -0,0 +1,50 @@
+module Coverable
+  extend ActiveSupport::Concern
+
+  COVER_IMAGE_TYPES = %w[image/png image/jpeg image/webp].freeze
+  MAX_COVER_BYTES = 5.megabytes
+
+  included do
+    has_one_attached :cover_image
+    has_one_attached :cover_slate
+
+    validate :cover_image_file_type, if: -> { cover_image.attached? }
+    validate :cover_image_file_size, if: -> { cover_image.attached? }
+  end
+
+  def cover_image_attached?
+    cover_image.attached?
+  end
+
+  def cover_url
+    return unless cover_image.attached?
+
+    Rails.application.routes.url_helpers.rails_blob_path(cover_image, only_path: true)
+  end
+
+  def effective_cover_url
+    if cover_image.attached?
+      cover_url
+    else
+      cover_parent&.effective_cover_url
+    end
+  end
+
+  private
+
+  def cover_parent
+    nil
+  end
+
+  def cover_image_file_type
+    return if cover_image.content_type.in?(COVER_IMAGE_TYPES)
+
+    errors.add(:cover_image, I18n.t("coverable.errors.invalid_type"))
+  end
+
+  def cover_image_file_size
+    return if cover_image.byte_size <= MAX_COVER_BYTES
+
+    errors.add(:cover_image, I18n.t("coverable.errors.too_large"))
+  end
+end

backend/app/models/concerns/password_complexity.rb

@@ -0,0 +1,62 @@
+# Criteri "di mercato" (stile Cognito/Auth0 bilanciato):
+# - minimo 8 caratteri (max 72 per bcrypt)
+# - almeno 3 classi su 4: minuscole, maiuscole, numeri, simboli
+module PasswordComplexity
+  extend ActiveSupport::Concern
+
+  MIN_LENGTH = 8
+  MAX_LENGTH = 72
+  REQUIRED_CLASSES = 3
+
+  CLASS_CHECKS = {
+    lowercase: /[a-z]/,
+    uppercase: /[A-Z]/,
+    digit: /\d/,
+    symbol: /[^A-Za-z0-9]/
+  }.freeze
+
+  class << self
+    def violation(password)
+      value = password.to_s
+      return :blank if value.blank?
+      return :too_short if value.length < MIN_LENGTH
+      return :too_long if value.bytesize > MAX_LENGTH
+      return :too_weak unless strong_enough?(value)
+
+      nil
+    end
+
+    def strong_enough?(password)
+      matched = CLASS_CHECKS.count { |_, pattern| password.match?(pattern) }
+      matched >= REQUIRED_CLASSES
+    end
+
+    # Confronta con il digest già salvato (prima di assegnare la nuova password).
+    def same_as_current?(record, password)
+      return false if password.blank? || !record.respond_to?(:authenticate)
+
+      record.authenticate(password).present?
+    end
+
+    def requirement_summary
+      I18n.t("password_policy.hint")
+    end
+  end
+
+  included do
+    validate :password_meets_complexity_policy, if: -> { password.present? }
+  end
+
+  private
+
+  def password_meets_complexity_policy
+    case PasswordComplexity.violation(password)
+    when :too_short
+      errors.add(:password, :too_short, count: MIN_LENGTH)
+    when :too_long
+      errors.add(:password, :too_long, count: MAX_LENGTH)
+    when :too_weak
+      errors.add(:password, :complexity)
+    end
+  end
+end

backend/app/models/device_state.rb

@@ -16,4 +16,17 @@ class DeviceState < ApplicationRecord
       status: stream_session.status
     }
   end
+
+  def as_regia_payload
+    {
+      battery: battery_level,
+      network: network_type,
+      signal: signal_strength,
+      bitrate: current_bitrate,
+      target_bitrate: target_bitrate,
+      fps: fps,
+      thermal_state: thermal_state,
+      last_seen_at: last_seen_at&.iso8601
+    }
+  end
 end

backend/app/models/match.rb

@@ -1,6 +1,15 @@
 class Match < ApplicationRecord
+  include Coverable
+
   belongs_to :team
+  belongs_to :tournament, optional: true
+  belongs_to :home_participant, class_name: "TournamentParticipant", optional: true
+  belongs_to :away_participant, class_name: "TournamentParticipant", optional: true
+  belongs_to :tournament_group, optional: true
+  belongs_to :tournament_round, optional: true
+  belongs_to :winner_participant, class_name: "TournamentParticipant", optional: true
   has_many :stream_sessions, dependent: :destroy
+  has_many :broadcast_assignments, class_name: "TournamentBroadcastAssignment", dependent: :destroy
 
   has_one_attached :opponent_logo_file
 
@@ -18,6 +27,8 @@ class Match < ApplicationRecord
 
   before_validation :normalize_sport_key
   before_validation :inherit_sport_from_team, on: :create
+  before_validation :sync_tournament_display_names
+  after_commit :sync_tournament_broadcast_assignments, on: %i[create update]
 
   scope :scheduled_for_live, -> {
     where.not(scheduled_at: nil).where("scheduled_at >= ?", Time.zone.now)
@@ -83,14 +94,27 @@ class Match < ApplicationRecord
     opponent_primary_color.presence || DEFAULT_OPPONENT_COLOR
   end
 
+  def result_recorded?
+    played? || result_status.to_s.start_with?("walkover") || (home_score.present? && away_score.present?)
+  end
+
   def coach_hub_visible?
     active = active_stream_session
     return true if active&.resumable?
     return true if active&.idle?
-
+    return false if result_recorded?
     return false if stream_completed?
+    return true if scheduled_on_calendar?
+    return true if tournament_open_for_late_stream?
 
-    scheduled_upcoming?
+    false
+  end
+
+  def tournament_open_for_late_stream?
+    return false unless tournament_match?
+
+    event = tournament
+    event.present? && !event.archived? && event.ends_on >= Date.current
   end
 
   def effective_board_type
@@ -114,6 +138,30 @@ class Match < ApplicationRecord
     Sports::Catalog.find_optional(sport_key)&.dig(:label) || sport_key.to_s.humanize
   end
 
+  def tournament_match?
+    has_attribute?(:tournament_id) && tournament_id.present?
+  end
+
+  def home_display_name
+    home_participant&.name.presence || (tournament_match? ? I18n.t("tournaments.tbd") : team.name)
+  end
+
+  def away_display_name
+    away_participant&.name.presence || (tournament_match? ? I18n.t("tournaments.tbd") : opponent_name.presence)
+  end
+
+  def matchup_label
+    "#{home_display_name} vs #{away_display_name}"
+  end
+
+  def played?
+    result_status == "played"
+  end
+
+  def court_or_location
+    court.presence || location
+  end
+
   # Alias legacy API/spec (colonna rinominata in sport_key).
   def sport
     sport_key
@@ -130,12 +178,34 @@ class Match < ApplicationRecord
   end
 
   def inherit_sport_from_team
+    if has_attribute?(:tournament_id) && tournament.present?
+      self.sport_key = tournament.sport_key if new_record? || sport_key.blank?
+      return
+    end
+
     return unless team.present?
 
     # Il default DB (pallavolo) non deve prevalere sullo sport della squadra alla creazione.
     self.sport_key = team.sport_key if new_record? || sport_key.blank?
   end
 
+  def sync_tournament_display_names
+    return unless has_attribute?(:tournament_id) && tournament_id.present?
+
+    self.opponent_name = away_display_name if away_participant.present? || opponent_name.blank?
+    venue_court = [tournament&.venue, court].compact_blank
+    self.location = venue_court.join(" — ") if venue_court.any?
+
+    self.category = tournament.name if category.blank? && tournament.present?
+  end
+
+  def sync_tournament_broadcast_assignments
+    return unless has_attribute?(:tournament_id) && tournament_id.present?
+    return unless saved_change_to_court? || saved_change_to_scheduled_at? || previously_new_record?
+
+    Tournaments::SyncAssignments.sync_match!(self)
+  end
+
   def sport_key_known
     return if sport_key.blank?
     return if Sports::Catalog.find_optional(sport_key)
@@ -174,4 +244,8 @@ class Match < ApplicationRecord
   rescue ArgumentError => e
     errors.add(:scoring_rules, e.message)
   end
+
+  def cover_parent
+    nil
+  end
 end

backend/app/models/ops/incident.rb

@@ -4,7 +4,7 @@ module Ops
 
     KINDS = %w[
       disk_space recordings_size service_down http_public http_rails rails_latency
-      sidekiq_stale sidekiq_dead log_pattern garage_storage
+      sidekiq_stale sidekiq_dead log_pattern garage_storage stream_overflow
     ].freeze
     SEVERITIES = %w[critical warning info].freeze
     STATUSES = %w[open acknowledged resolved].freeze

backend/app/models/plan.rb

@@ -84,6 +84,10 @@ class Plan < ApplicationRecord
     feature("youtube_enabled") == true
   end
 
+  def custom_cover_enabled?
+    feature("custom_cover") == true
+  end
+
   def premium?
     slug.in?(PREMIUM_SLUGS)
   end

backend/app/models/platform_cost_entry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class PlatformCostEntry < ApplicationRecord
+  DEFAULT_LABEL = "Piattaforma produzione"
+
+  validates :month, presence: true
+  validates :label, presence: true, length: { maximum: 120 }
+  validates :amount_cents, numericality: { only_integer: true, greater_than: 0 }
+
+  before_validation :normalize_month
+
+  scope :for_month, ->(date) { where(month: date.to_date.beginning_of_month) }
+  scope :ordered, -> { order(month: :desc, created_at: :desc) }
+
+  def month=(value)
+    if value.is_a?(String) && value.match?(/\A\d{4}-\d{2}\z/)
+      super(Date.strptime(value, "%Y-%m"))
+    else
+      super(value)
+    end
+  end
+
+  def amount_euros
+    amount_cents.to_f / 100.0
+  end
+
+  private
+
+  def normalize_month
+    return if month.blank?
+
+    parsed =
+      case month
+      when Date
+        month
+      when Time, ActiveSupport::TimeWithZone
+        month.to_date
+      when String
+        if month.match?(/\A\d{4}-\d{2}\z/)
+          Date.strptime(month, "%Y-%m")
+        else
+          Date.parse(month)
+        end
+      else
+        Date.parse(month.to_s)
+      end
+    self.month = parsed.beginning_of_month
+  rescue ArgumentError, TypeError
+    errors.add(:month, :invalid)
+  end
+end

backend/app/models/recording.rb

@@ -2,6 +2,8 @@ class Recording < ApplicationRecord
   STATUSES = %w[processing ready expired failed].freeze
   PRIVACY_STATUSES = %w[public unlisted].freeze
   STORAGE_BACKENDS = %w[local s3].freeze
+  STORAGE_POLICIES = %w[temporary retained none].freeze
+  REPLAY_SOURCES = %w[youtube matchlivetv none].freeze
 
   belongs_to :stream_session
   belongs_to :team
@@ -9,6 +11,7 @@ class Recording < ApplicationRecord
   validates :status, inclusion: { in: STATUSES }
   validates :privacy_status, inclusion: { in: PRIVACY_STATUSES }
   validates :storage_backend, inclusion: { in: STORAGE_BACKENDS }
+  validates :storage_policy, inclusion: { in: STORAGE_POLICIES }
 
   scope :not_deleted, -> { where(deleted_at: nil) }
   scope :ready, lambda {
@@ -23,7 +26,16 @@ class Recording < ApplicationRecord
     ready.where(expires_at: ..days.days.from_now)
   }
   scope :expired_pending_purge, lambda {
-    not_deleted.where(status: %w[ready failed]).where("expires_at IS NOT NULL AND expires_at <= ?", Time.current)
+    not_deleted
+      .where(storage_policy: "retained")
+      .where(status: %w[ready failed])
+      .where("expires_at IS NOT NULL AND expires_at <= ?", Time.current)
+  }
+  scope :temporary_media_pending_purge, lambda {
+    not_deleted
+      .where(storage_policy: "temporary")
+      .where(local_media_purged_at: nil)
+      .where("temp_expires_at IS NOT NULL AND temp_expires_at <= ?", Time.current)
   }
   scope :search_replays, lambda { |query|
     q = query.to_s.strip
@@ -46,19 +58,30 @@ class Recording < ApplicationRecord
   end
 
   def playback_stream_url
-    return nil unless ready? && stream_session_id.present?
+    return nil unless ready? && storage_key.present? && stream_session_id.present?
 
     "#{MatchLiveTv.app_public_url.chomp('/')}/replay/#{stream_session_id}/stream"
   end
 
   def thumbnail_url
+    return youtube_thumbnail_url if thumbnail_storage_key.blank? && youtube_video_id.present?
     return nil unless thumbnail_storage_key.present? && stream_session_id.present?
 
     "#{MatchLiveTv.app_public_url.chomp('/')}/replay/#{stream_session_id}/thumbnail"
   end
 
+  def youtube_thumbnail_url
+    return nil if youtube_video_id.blank?
+    return nil if youtube_video_id.to_s.start_with?("mock_")
+
+    meta_url = metadata.is_a?(Hash) ? metadata.dig("youtube", "thumbnail_url") : nil
+    return meta_url if meta_url.present?
+
+    "https://i.ytimg.com/vi/#{youtube_video_id}/hqdefault.jpg"
+  end
+
   def download_api_path
-    return nil unless ready?
+    return nil unless ready? && storage_key.present?
 
     "/api/v1/recordings/#{id}/download"
   end
@@ -70,6 +93,30 @@ class Recording < ApplicationRecord
     "https://www.youtube.com/watch?v=#{youtube_video_id}"
   end
 
+  def temporary_storage?
+    storage_policy == "temporary"
+  end
+
+  def retained_storage?
+    storage_policy == "retained"
+  end
+
+  def local_media_purged?
+    local_media_purged_at.present?
+  end
+
+  # Sorgente fisica del player in archivio (non lo storage policy).
+  def replay_source
+    return "youtube" if youtube_watch_url.present? || (ready? && youtube_video_id.present?)
+    return "matchlivetv" if ready? && storage_key.present?
+
+    "none"
+  end
+
+  def available_in_archive?
+    ready? && (youtube_watch_url.present? || youtube_video_id.present? || storage_key.present?)
+  end
+
   def ready?
     status == "ready" && !deleted? && (expires_at.nil? || expires_at.future?)
   end
@@ -99,14 +146,22 @@ class Recording < ApplicationRecord
   end
 
   def title_or_default
-    title.presence || default_title
+    match = stream_session&.match
+    return title.presence || "Replay" unless match
+
+    generated = match.matchup_label
+    stored = title.to_s.strip
+    return generated if stored.blank?
+    return generated if stale_auto_title?(match, stored)
+
+    stored
   end
 
   def default_title
     match = stream_session&.match
     return "Replay" unless match
 
-    "#{match.team.name} vs #{match.opponent_name}"
+    match.matchup_label
   end
 
   def recorded_at_or_fallback
@@ -154,7 +209,7 @@ class Recording < ApplicationRecord
   end
 
   def playable_on_site?
-    ready? && storage_key.present?
+    available_in_archive?
   end
 
   def days_until_expiry
@@ -175,6 +230,18 @@ class Recording < ApplicationRecord
 
   private
 
+  def stale_auto_title?(match, stored)
+    return false unless match.tournament_match?
+
+    team_name = match.team&.name.to_s
+    return false if team_name.blank?
+
+    [
+      "#{team_name} vs #{match.opponent_name}",
+      "#{team_name} vs #{match.away_display_name}"
+    ].include?(stored)
+  end
+
   def normalize_privacy_status
     self.privacy_status = "public" if privacy_status == "private"
     self.privacy_status = "unlisted" if privacy_status.blank?

backend/app/models/stream_concurrency_violation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class StreamConcurrencyViolation < ApplicationRecord
+  LOOKBACK = 30.days
+
+  belongs_to :user, optional: true
+  belongs_to :occupying_session, class_name: "StreamSession", optional: true
+  belongs_to :attempted_session, class_name: "StreamSession", optional: true
+  belongs_to :occupying_club, class_name: "Club", optional: true
+  belongs_to :attempted_club, class_name: "Club", optional: true
+
+  validates :user_email, :occupying_match_label, :attempted_match_label, presence: true
+  validates :attempt_action, inclusion: { in: %w[start resume] }
+
+  scope :recent, -> { order(created_at: :desc) }
+  scope :since, ->(time) { where("created_at >= ?", time) }
+  scope :lookback, -> { since(LOOKBACK.ago) }
+  scope :two_devices, -> { where(devices_differ: true) }
+  scope :for_club, lambda { |club_id|
+    where("occupying_club_id = :id OR attempted_club_id = :id", id: club_id)
+  }
+  scope :for_session, lambda { |session_id|
+    where("occupying_session_id = :id OR attempted_session_id = :id", id: session_id)
+  }
+
+  def self.record!(attempted:, occupying:, action: "start")
+    user = attempted.user || occupying.user
+    occupying_club = occupying.match&.team&.club
+    attempted_club = attempted.match&.team&.club
+    occupying_device = occupying.client_device_label
+    attempted_device = attempted.client_device_label
+
+    create!(
+      user: user,
+      occupying_session: occupying,
+      attempted_session: attempted,
+      occupying_club: occupying_club,
+      attempted_club: attempted_club,
+      attempt_action: action.to_s,
+      user_email: user&.email.presence || "unknown",
+      user_name: user&.name,
+      occupying_club_name: occupying_club&.name,
+      attempted_club_name: attempted_club&.name,
+      occupying_match_label: occupying.match_label,
+      attempted_match_label: attempted.match_label,
+      occupying_status: occupying.status,
+      occupying_device: occupying_device,
+      attempted_device: attempted_device,
+      devices_differ: StreamSession.devices_differ?(occupying, attempted),
+      metadata: {
+        occupying_session_id: occupying.id,
+        attempted_session_id: attempted.id,
+        occupying_client_os: occupying.client_os,
+        attempted_client_os: attempted.client_os,
+        occupying_app_version: occupying.app_version,
+        attempted_app_version: attempted.app_version
+      }.compact
+    )
+  rescue StandardError => e
+    Rails.logger.error("[StreamConcurrencyViolation] record failed: #{e.class} #{e.message}")
+    nil
+  end
+
+  def club_name
+    attempted_club_name.presence || occupying_club_name
+  end
+
+  def operator_label
+    [user_name.presence, user_email].compact.join(" · ")
+  end
+end

backend/app/models/stream_event.rb

@@ -1,7 +1,7 @@
 class StreamEvent < ApplicationRecord
   EVENT_TYPES = %w[
     connected disconnected reconnected quality_changed error paused resumed
-    started ended network_test pairing youtube_ready
+    started ended network_test pairing youtube_ready audio_muted audio_unmuted
   ].freeze
 
   belongs_to :stream_session

backend/app/models/stream_node.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Nodo streaming (MediaMTX [+ relay ffmpeg]). Fase 0: registry + assignment URL.
+class StreamNode < ApplicationRecord
+  ROLES = %w[home cloud lab].freeze
+  STATUSES = %w[provisioning ready draining offline error].freeze
+  PROVIDERS = %w[local proxmox_lab hetzner].freeze
+
+  has_many :stream_sessions, dependent: :nullify
+
+  validates :slug, presence: true, uniqueness: true
+  validates :hostname, presence: true
+  validates :role, inclusion: { in: ROLES }
+  validates :status, inclusion: { in: STATUSES }
+  validates :provider, inclusion: { in: PROVIDERS }
+  validates :rtmp_base_url, :hls_base_url, :api_base_url, presence: true
+  validates :max_publishers, :max_relays, numericality: { greater_than: 0 }
+
+  scope :ready, -> { where(status: "ready") }
+  scope :allocatable, -> { ready }
+
+  # Sessioni che occupano uno slot path MediaMTX su questo nodo.
+  def occupying_sessions
+    stream_sessions.where(status: %w[idle connecting live reconnecting paused])
+  end
+
+  def active_publishers
+    occupying_sessions.count
+  end
+
+  def free_slots
+    [max_publishers - active_publishers, 0].max
+  end
+
+  def allocatable?
+    status == "ready" && free_slots.positive?
+  end
+
+  # Agent ffmpeg sul CPX (cloud-init :9100). Home Sidekiq lo chiama senza worker Docker per nodo.
+  def relay_agent_url
+    return unless role == "cloud"
+
+    ip = (metadata || {})["public_ip"].presence
+    if ip.blank?
+      host = URI.parse(api_base_url.to_s).host
+      ip = host if host.present? && host != "localhost"
+    end
+    return if ip.blank? || ip == "127.0.0.1"
+
+    "http://#{ip}:#{ENV.fetch("STREAM_NODE_AGENT_PORT", "9100")}"
+  rescue URI::InvalidURIError
+    nil
+  end
+end

backend/app/models/stream_session.rb

@@ -1,22 +1,31 @@
 class StreamSession < ApplicationRecord
   include AASM
 
-  PLATFORMS = %w[matchlivetv youtube facebook twitch].freeze
+  LIVE_PLATFORMS = %w[matchlivetv youtube].freeze
+  PLATFORMS = (LIVE_PLATFORMS + %w[facebook twitch]).freeze
   STATUSES = %w[idle connecting live reconnecting paused ended error].freeze
   PRIVACY_STATUSES = %w[public unlisted private].freeze
 
   belongs_to :match
   belongs_to :user
+  belongs_to :stream_node, optional: true
   has_many :stream_events, dependent: :destroy
+  has_many :occupying_concurrency_violations, class_name: "StreamConcurrencyViolation",
+           foreign_key: :occupying_session_id, dependent: :nullify, inverse_of: :occupying_session
+  has_many :attempted_concurrency_violations, class_name: "StreamConcurrencyViolation",
+           foreign_key: :attempted_session_id, dependent: :nullify, inverse_of: :attempted_session
   has_one :score_state, dependent: :destroy
+  has_one :recording
   has_many :device_states, dependent: :destroy
 
   validates :platform, inclusion: { in: PLATFORMS }
   validates :status, inclusion: { in: STATUSES }
   validates :privacy_status, inclusion: { in: PRIVACY_STATUSES }
+  validates :min_quality_preset, inclusion: { in: Sessions::SelectQuality::MIN_QUALITY_IDS }
 
   before_validation :normalize_privacy_status
   before_validation :ensure_publish_token, on: :create
+  before_validation :snapshot_ingest_from_node, if: -> { stream_node.present? }
 
   scope :broadcasting, -> { where(status: %w[live connecting reconnecting paused]) }
   scope :publicly_listed, -> { where(privacy_status: "public") }
@@ -71,10 +80,47 @@ class StreamSession < ApplicationRecord
     end
   end
 
+  def ingest_slug_display
+    stream_node&.slug.presence || ingest_slug
+  end
+
+  def ingest_role_display
+    stream_node&.role.presence || ingest_role
+  end
+
+  def match_label
+    team_name = match&.team&.name
+    opponent = match&.opponent_name
+    return id.to_s if team_name.blank?
+
+    opponent.present? ? "#{team_name} vs #{opponent}" : team_name
+  end
+
+  def client_device_label
+    parts = []
+    parts << client_os if client_os.present?
+    device = [device_manufacturer, device_model].compact_blank.join(" ")
+    parts << device if device.present?
+    parts << "OS #{os_version}" if os_version.present?
+    parts.join(" · ").presence
+  end
+
+  def client_device_key
+    [client_os, device_manufacturer, device_model].map { |v| v.to_s.strip.downcase }.join("|")
+  end
+
+  def self.devices_differ?(left, right)
+    ka = left.client_device_key
+    kb = right.client_device_key
+    return false if ka.delete("|").blank? || kb.delete("|").blank?
+
+    ka != kb
+  end
+
   def rtmp_ingest_url
     # RootEncoder richiede rtmp://host:port/app/stream (due segmenti).
     # MediaMTX path = live/match_{uuid} (no ?token= nel path).
-    "#{MatchLiveTv.mediamtx_rtmp_url}/#{mediamtx_path_name}"
+    "#{rtmp_base_url.chomp('/')}/#{mediamtx_path_name}"
   end
 
   def mediamtx_path_name
@@ -90,8 +136,29 @@ class StreamSession < ApplicationRecord
   end
 
   def hls_playback_url
-    base = MatchLiveTv.hls_public_url.chomp("/")
-    "#{base}/#{effective_hls_path_name}/index.m3u8"
+    "#{hls_base_url.chomp('/')}/#{effective_hls_path_name}/index.m3u8"
+  end
+
+  def rtmp_base_url
+    stream_node&.rtmp_base_url.presence || MatchLiveTv.mediamtx_rtmp_url
+  end
+
+  def hls_base_url
+    stream_node&.hls_base_url.presence || MatchLiveTv.hls_public_url
+  end
+
+  def mediamtx_api_base_url
+    stream_node&.api_base_url.presence || MatchLiveTv.mediamtx_api_url
+  end
+
+  def mediamtx_internal_rtmp_url
+    stream_node&.internal_rtmp_url.presence ||
+      ENV.fetch("MEDIAMTX_INTERNAL_RTMP_URL", "rtmp://mediamtx:1935")
+  end
+
+  def mediamtx_internal_hls_url
+    stream_node&.internal_hls_url.presence ||
+      ENV.fetch("MEDIAMTX_HLS_URL", "http://mediamtx:8888")
   end
 
   def effective_hls_path_name
@@ -119,6 +186,12 @@ class StreamSession < ApplicationRecord
     platform == "youtube" && youtube_watch_url.present?
   end
 
+  def public_watchable?
+    return true if matchlivetv_platform? && publicly_listed?
+
+    youtube_ready?
+  end
+
   def link_only?
     privacy_status.in?(%w[unlisted private])
   end
@@ -184,6 +257,11 @@ class StreamSession < ApplicationRecord
     self.privacy_status = "unlisted" if privacy_status == "private"
   end
 
+  def snapshot_ingest_from_node
+    self.ingest_slug = stream_node.slug
+    self.ingest_role = stream_node.role
+  end
+
   def record_ended_timestamps!
     now = Time.current
     update!(ended_at: now) if ended_at.nil?

backend/app/models/subscription.rb

@@ -35,4 +35,8 @@ class Subscription < ApplicationRecord
   def admin_comped?
     admin_comped
   end
+
+  def bank_transfer?
+    premium? && stripe_subscription_id.blank? && !admin_comped? && current_period_end.present?
+  end
 end

backend/app/models/team.rb

@@ -1,5 +1,8 @@
 class Team < ApplicationRecord
   include Brandable
+  include Coverable
+
+  INTERNAL_KINDS = %w[tournament_broadcast].freeze
 
   belongs_to :club
   has_many :user_teams, dependent: :destroy
@@ -8,6 +11,10 @@ class Team < ApplicationRecord
   has_many :recordings, dependent: :destroy
   has_many :team_invitations, dependent: :destroy
   has_many :roster_members, class_name: "TeamRosterMember", dependent: :destroy
+  has_one :broadcast_tournament, class_name: "Tournament", foreign_key: :broadcast_team_id, inverse_of: :broadcast_team
+
+  scope :visible, -> { where("internal_kind IS NULL OR internal_kind = ''") }
+  scope :tournament_broadcast, -> { where(internal_kind: Tournament::INTERNAL_TEAM_KIND) }
 
   has_one_attached :photo_file
 
@@ -60,6 +67,10 @@ class Team < ApplicationRecord
     Rails.application.routes.url_helpers.public_team_page_path(slug)
   end
 
+  def tournament_broadcast?
+    internal_kind == Tournament::INTERNAL_TEAM_KIND
+  end
+
   def sport_label
     Sports::Catalog.find_optional(sport_key)&.dig(:label) || sport_key.to_s.humanize
   end
@@ -99,6 +110,10 @@ class Team < ApplicationRecord
     club
   end
 
+  def cover_parent
+    club
+  end
+
   def assign_slug
     self.slug = Teams::GenerateSlug.call(self) if slug.blank?
   end

backend/app/models/tournament.rb

@@ -0,0 +1,145 @@
+class Tournament < ApplicationRecord
+  include Coverable
+
+  FORMAT_KINDS = %w[groups knockout mixed free].freeze
+  STATUSES = %w[draft published live archived].freeze
+  INTERNAL_TEAM_KIND = "tournament_broadcast"
+
+  belongs_to :club
+  belongs_to :broadcast_team, class_name: "Team", optional: true
+  has_many :broadcast_assignments, class_name: "TournamentBroadcastAssignment", dependent: :destroy
+  has_many :matches, dependent: :destroy
+  has_many :broadcast_invitations, class_name: "TournamentBroadcastInvitation", dependent: :destroy
+  has_many :participants, class_name: "TournamentParticipant", dependent: :destroy
+  has_many :rounds, class_name: "TournamentRound", dependent: :destroy
+  has_many :groups, class_name: "TournamentGroup", dependent: :destroy
+  has_many_attached :invite_email_images
+  has_one_attached :logo_file
+
+  validates :name, presence: true
+  validates :slug, presence: true, uniqueness: true,
+            format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/, message: "solo lettere minuscole, numeri e trattini" }
+  validates :sport_key, presence: true
+  validates :starts_on, :ends_on, presence: true
+  validates :format_kind, inclusion: { in: FORMAT_KINDS }
+  validates :status, inclusion: { in: STATUSES }
+  validates :invite_draft_note, length: { maximum: 2000 }, allow_blank: true
+  validate :sport_key_known
+  validate :ends_on_not_before_starts_on
+  validate :logo_file_type, if: -> { logo_file.attached? }
+
+  before_validation :normalize_sport_key
+  before_validation :assign_slug, on: :create
+  before_validation :normalize_slug, if: -> { slug_changed? && slug.present? }
+  before_validation :normalize_courts
+
+  scope :visible_to_public, -> { where(status: %w[published live archived]) }
+  scope :listed_on_live, -> { where(status: %w[published live]) }
+  scope :search_public, lambda { |query|
+    q = query.to_s.strip
+    return all if q.blank?
+
+    term = "%#{sanitize_sql_like(q)}%"
+    left_joins(:club).where(
+      "tournaments.name ILIKE :term OR clubs.name ILIKE :term OR tournaments.venue ILIKE :term",
+      term: term
+    )
+  }
+
+  def published?
+    status.in?(%w[published live archived])
+  end
+
+  def archived?
+    status == "archived"
+  end
+
+  def writable?
+    !archived?
+  end
+
+  def uses_groups?
+    format_kind.in?(%w[groups mixed])
+  end
+
+  def uses_knockout?
+    format_kind.in?(%w[knockout mixed])
+  end
+
+  def court_list
+    Array(courts).map { |c| c.to_s.strip }.reject(&:blank?)
+  end
+
+  def days
+    (starts_on..ends_on).to_a
+  end
+
+  def sport_label
+    Sports::Catalog.find_optional(sport_key)&.dig(:label) || sport_key.to_s.humanize
+  end
+
+  def public_page_path
+    Rails.application.routes.url_helpers.public_tournament_page_path(slug)
+  end
+
+  def effective_primary_color
+    club.effective_primary_color
+  end
+
+  def effective_secondary_color
+    club.effective_secondary_color
+  end
+
+  def effective_logo_url
+    return unless logo_file.attached?
+
+    Rails.application.routes.url_helpers.rails_blob_path(logo_file, only_path: true)
+  end
+
+  def concurrent_limit
+    club.subscription&.plan&.concurrent_streams_limit
+  end
+
+  private
+
+  def normalize_sport_key
+    self.sport_key = Sports::Catalog.normalize_key(sport_key) if sport_key.present?
+  end
+
+  def sport_key_known
+    return if sport_key.blank?
+    return if Sports::Catalog.find_optional(sport_key)
+
+    errors.add(:sport_key, "non valido")
+  end
+
+  def ends_on_not_before_starts_on
+    return if starts_on.blank? || ends_on.blank?
+    return if ends_on >= starts_on
+
+    errors.add(:ends_on, "non può precedere la data di inizio")
+  end
+
+  def assign_slug
+    self.slug = Tournaments::GenerateSlug.call(self) if slug.blank?
+  end
+
+  def normalize_slug
+    self.slug = slug.to_s.parameterize
+  end
+
+  def normalize_courts
+    self.courts = court_list
+    self.courts = ["Campo 1"] if courts.blank?
+  end
+
+  def cover_parent
+    club
+  end
+
+  def logo_file_type
+    return if logo_file.content_type.in?(Coverable::COVER_IMAGE_TYPES)
+
+    errors.add(:logo_file, I18n.t("coverable.errors.invalid_type"))
+  end
+end