Aggiunge bitrate adattivo con qualità minima da regia e telemetria del telefono.

L'encoder scende in congestione e risale piano; la regia imposta il pavimento, mostra lo stato del telefono e apre il selettore dal bitrate colorato.

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

backend/app/channels/session_channel.rb

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

backend/app/controllers/admin/stream_nodes_controller.rb

@@ -1,67 +0,0 @@
-# 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/api/v1/stream_sessions_controller.rb

@@ -68,6 +68,7 @@ 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
         )
         sync_publisher_when_streaming!(params[:fps].to_f)
@@ -141,6 +142,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,6 +168,11 @@ 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)
       end
@@ -180,7 +193,6 @@ 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,
@@ -188,6 +200,7 @@ 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

backend/app/controllers/public/pages_controller.rb

@@ -11,17 +11,8 @@ module Public
       load_club_billing_context_for_pricing
     end
 
-    private
+    def support
-
+      @app_store_review_chrome = true
-    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
 
     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/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 min_quality]
 
     before_action :set_session_from_token
 
@@ -61,8 +61,20 @@ module Public
       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
@@ -86,7 +98,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/sitemap_controller.rb

@@ -11,6 +11,7 @@ module Public
         { loc: "#{base}/live", changefreq: "hourly", priority: "0.85" },
         { loc: "#{base}/squadre", changefreq: "daily", priority: "0.85" },
         { 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" }
       ]

backend/app/helpers/public/regia_helper.rb

@@ -54,15 +54,34 @@ module Public
         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"),
         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/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.for_session(session).delete_path(session)
+      Mediamtx::Client.new.delete_path(session)
     end
   end
 end

backend/app/jobs/streams/autoscaler_job.rb

@@ -1,33 +0,0 @@
-# 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"
-
-    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::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/youtube_relay_ensure_job.rb

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

backend/app/jobs/youtube_relay_stop_job.rb

@@ -1,22 +1,10 @@
-# Ferma il relay solo sull'owner. Se il job gira su un altro host, requeue breve.
 class YoutubeRelayStopJob < ApplicationJob
-  queue_as Streams::YoutubeRelay::QUEUE
+  queue_as :default
 
-  discard_on ActiveJob::DeserializationError
+  def perform(session_id)
-
-  def perform(session_id, attempts = 0)
     session = StreamSession.find_by(id: session_id)
     return unless session
 
-    unless Streams::YoutubeRelay.worker?
+    Streams::YoutubeRelay.stop_on_worker!(session) if 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).perform_later(session_id, attempts + 1)
   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/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 stream_overflow
+      sidekiq_stale sidekiq_dead log_pattern garage_storage
     ].freeze
     SEVERITIES = %w[critical warning info].freeze
     STATUSES = %w[open acknowledged resolved].freeze

backend/app/models/stream_node.rb

@@ -1,38 +0,0 @@
-# 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
-end

backend/app/models/stream_session.rb

@@ -7,7 +7,6 @@ class StreamSession < ApplicationRecord
 
   belongs_to :match
   belongs_to :user
-  belongs_to :stream_node, optional: true
   has_many :stream_events, dependent: :destroy
   has_one :score_state, dependent: :destroy
   has_many :device_states, dependent: :destroy
@@ -15,6 +14,7 @@ class StreamSession < ApplicationRecord
   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
@@ -75,7 +75,7 @@ class StreamSession < ApplicationRecord
   def rtmp_ingest_url
     # RootEncoder richiede rtmp://host:port/app/stream (due segmenti).
     # MediaMTX path = live/match_{uuid} (no ?token= nel path).
-    "#{rtmp_base_url.chomp('/')}/#{mediamtx_path_name}"
+    "#{MatchLiveTv.mediamtx_rtmp_url}/#{mediamtx_path_name}"
   end
 
   def mediamtx_path_name
@@ -91,29 +91,8 @@ class StreamSession < ApplicationRecord
   end
 
   def hls_playback_url
-    "#{hls_base_url.chomp('/')}/#{effective_hls_path_name}/index.m3u8"
+    base = MatchLiveTv.hls_public_url.chomp("/")
-  end
+    "#{base}/#{effective_hls_path_name}/index.m3u8"
-
-  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

backend/app/services/mediamtx/client.rb

@@ -4,12 +4,7 @@ module Mediamtx
   class Client
     class Error < StandardError; end
 
-    def self.for_session(session)
-      new(base_url: session.mediamtx_api_base_url)
-    end
-
     def initialize(base_url: MatchLiveTv.mediamtx_api_url)
-      @base_url = base_url
       @conn = Faraday.new(url: base_url) do |f|
         f.request :json
         f.response :json
@@ -17,8 +12,6 @@ module Mediamtx
       end
     end
 
-    attr_reader :base_url
-
     def create_path(session)
       path = session.mediamtx_path_name
       # record: false finché non c'è publisher — con alwaysAvailable MediaMTX registrerebbe
@@ -105,16 +98,6 @@ module Mediamtx
       []
     end
 
-    def list_rtmp_conns
-      response = @conn.get("/v3/rtmpconns/list")
-      return [] unless response.success?
-
-      body = response.body
-      body.is_a?(Hash) ? (body["items"] || []) : []
-    rescue Error, Faraday::Error
-      []
-    end
-
     def online_path_names
       Set.new(list_paths.filter_map { |item| item["name"] if item["online"] })
     end

backend/app/services/mediamtx/publisher_online.rb

@@ -4,37 +4,17 @@ module Mediamtx
     module_function
 
     def active?(session)
-      return true if rtmp_publisher?(session)
-
       active_path?(path_info(session))
     end
 
     def path_info(session)
-      Client.for_session(session).list_paths.find { |i| i["name"] == session.mediamtx_path_name }
+      Client.new.list_paths.find { |i| i["name"] == session.mediamtx_path_name }
     end
 
-    # MediaMTX <=1.19: online + source.type=rtmpConn.
-    # MediaMTX 1.20+: online/source spesso null anche con publisher; usare rtmpconns.
     def active_path?(info)
       return false unless info
-      return true if info["online"] == true && rtmp_source?(info.dig("source", "type"))
 
-      false
+      info["online"] == true && info.dig("source", "type") == "rtmpConn"
-    end
-
-    def rtmp_publisher?(session)
-      path = session.mediamtx_path_name.to_s
-      return false if path.blank?
-
-      Client.for_session(session).list_rtmp_conns.any? do |conn|
-        conn_path = conn["path"].to_s.sub(%r{\A/}, "")
-        next false unless conn_path == path
-
-        state = conn["state"].to_s
-        state.empty? || state == "publish" || state == "idle"
-      end
-    rescue StandardError
-      false
     end
 
     def h264_video?(info)
@@ -46,14 +26,12 @@ module Mediamtx
     end
 
     def video_publishing?(session)
-      return false unless active?(session)
-
       info = path_info(session)
+      return false unless active_path?(info)
+      # Slate alwaysAvailable ha H264 ma non è il telefono.
+      return false unless info.dig("source", "type") == "rtmpConn"
+
       h264_video?(info)
     end
-
-    def rtmp_source?(type)
-      type.to_s.match?(/\Artmps?Conn\z/)
-    end
   end
 end

backend/app/services/mediamtx/publisher_sync.rb

@@ -12,7 +12,7 @@ module Mediamtx
       return @session if @session.terminal?
 
       path_info = Mediamtx::PublisherOnline.path_info(@session)
-      publisher_online = Mediamtx::PublisherOnline.active?(@session)
+      publisher_online = Mediamtx::PublisherOnline.active_path?(path_info)
 
       if publisher_online
         clear_publisher_misses!(@session.id)
@@ -86,7 +86,7 @@ module Mediamtx
       key = format("youtube:slate_disabled:%s", session.id)
       return unless redis.set(key, "1", nx: true, ex: 48.hours.to_i)
 
-      Client.for_session(session).set_always_available(session, enabled: false)
+      Client.new.set_always_available(session, enabled: false)
     rescue Client::Error => e
       redis.del(format("youtube:slate_disabled:%s", session.id))
       Rails.logger.warn("[PublisherSync] disable slate session=#{session.id}: #{e.message}")
@@ -95,7 +95,7 @@ module Mediamtx
     def restore_slate_path!(session)
       return if session.platform == "matchlivetv"
 
-      Client.for_session(session).set_always_available(session, enabled: true)
+      Client.new.set_always_available(session, enabled: true)
     rescue Client::Error => e
       Rails.logger.warn("[PublisherSync] enable slate session=#{session.id}: #{e.message}")
     end
@@ -128,7 +128,7 @@ module Mediamtx
         return
       end
 
-      Client.for_session(session).set_path_recording(session, enabled: enabled)
+      Client.new.set_path_recording(session, enabled: enabled)
       redis.set(key, desired, ex: 48.hours.to_i)
       mark_recording_patch!(session.id)
     rescue Client::Error => e
@@ -183,7 +183,7 @@ module Mediamtx
       key = format("youtube_relay:sched:%s", session.id)
       return unless redis.set(key, "1", nx: true, ex: 10)
 
-      YoutubeRelayEnsureJob.set(queue: Streams::YoutubeRelay::QUEUE).perform_later(session.id)
+      YoutubeRelayEnsureJob.perform_later(session.id)
     end
 
     def redis

backend/app/services/ops/health_checks.rb

@@ -44,8 +44,7 @@ module Ops
         check_sidekiq_heartbeat,
         check_sidekiq_dead,
         check_http_rails,
-        check_rails_latency,
+        check_rails_latency
-        check_stream_overflow
       ]
       findings << check_http_public if public_check_due?
       findings
@@ -162,58 +161,6 @@ module Ops
       fail_finding("garage_storage", "warning", "garage_storage:head", "Garage storage non raggiungibile", e.message)
     end
 
-    def check_stream_overflow
-      return ok_finding("stream_overflow:skip", "Nodi stream non migrati") unless ActiveRecord::Base.connection.data_source_exists?("stream_nodes")
-
-      orphan_hours = ENV.fetch("STREAM_OVERFLOW_ORPHAN_HOURS", "3").to_i
-      orphans = StreamNode.where.not(slug: "home").where(status: %w[ready draining]).select do |n|
-        n.active_publishers.zero? && n.created_at < orphan_hours.hours.ago
-      end
-      metrics = Streams::Autoscaler.metrics
-      over_budget = !metrics[:within_budget]
-      at_max = metrics[:overflow_nodes] >= metrics[:max_overflow_nodes] && metrics[:free_slots] <= metrics[:soft_free_slots]
-
-      if orphans.any?
-        return Finding.new(
-          kind: "stream_overflow",
-          severity: "warning",
-          healthy: false,
-          title: "Nodi stream overflow idle",
-          message: "#{orphans.size} nodo/i idle da >#{orphan_hours}h: #{orphans.map(&:slug).join(', ')}",
-          metadata: { "slugs" => orphans.map(&:slug) },
-          fingerprint: "stream_overflow:orphan_idle"
-        )
-      end
-
-      if over_budget
-        return Finding.new(
-          kind: "stream_overflow",
-          severity: "warning",
-          healthy: false,
-          title: "Budget overflow streaming",
-          message: "Stima €#{metrics[:estimated_monthly_eur]}/mese > budget €#{metrics[:monthly_budget_eur]}",
-          metadata: metrics.transform_keys(&:to_s),
-          fingerprint: "stream_overflow:budget"
-        )
-      end
-
-      if at_max
-        return Finding.new(
-          kind: "stream_overflow",
-          severity: "warning",
-          healthy: false,
-          title: "Capacità stream al massimo",
-          message: "overflow=#{metrics[:overflow_nodes]}/#{metrics[:max_overflow_nodes]} free_slots=#{metrics[:free_slots]}",
-          metadata: metrics.transform_keys(&:to_s),
-          fingerprint: "stream_overflow:at_max"
-        )
-      end
-
-      ok_finding("stream_overflow:ok", "Overflow streaming OK")
-    rescue StandardError => e
-      fail_finding("stream_overflow", "warning", "stream_overflow:error", "Check overflow fallito", e.message)
-    end
-
     def check_sidekiq_heartbeat
       redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
       last = redis.get(Ops::HealthMonitorJob::HEARTBEAT_KEY).to_i

backend/app/services/recordings/cleanup_local.rb

@@ -95,7 +95,7 @@ module Recordings
     def cleanup_mediamtx_path(session)
       return unless session.status.in?(%w[ended error])
 
-      Mediamtx::Client.for_session(session).delete_path(session)
+      Mediamtx::Client.new.delete_path(session)
     rescue Mediamtx::Client::Error => e
       @logger.warn("[Recordings::CleanupLocal] delete_path #{session.id}: #{e.message}")
     end

backend/app/services/recordings/upload_from_session.rb

@@ -95,7 +95,7 @@ module Recordings
 
     def cleanup_mediamtx_path
       Mediamtx::PublisherSync.forget_recording_state!(@session.id)
-      Mediamtx::Client.for_session(@session).delete_path(@session)
+      Mediamtx::Client.new.delete_path(@session)
     rescue Mediamtx::Client::Error => e
       Rails.logger.warn("[Recordings::UploadFromSession] delete_path: #{e.message}")
     end

backend/app/services/sessions/create.rb

@@ -34,19 +34,11 @@ module Sessions
       end
 
       StreamSession.transaction do
-        session.stream_node = Streams::NodeRegistry.allocate!
         session.save!
         Scoring::Engine.ensure_score_for(session)
-        Mediamtx::Client.for_session(session).create_path(session)
+        mtx = Mediamtx::Client.new
-        log_event(
+        mtx.create_path(session)
-          session,
+        log_event(session, "pairing", { created: true, platform: session.platform })
-          "pairing",
-          {
-            created: true,
-            platform: session.platform,
-            stream_node: session.stream_node&.slug
-          }
-        )
       end
 
       if session.platform == "youtube"
@@ -54,8 +46,6 @@ module Sessions
       end
 
       session
-    rescue Streams::NodeRegistry::NoCapacityError => e
-      raise Teams::EntitlementError.new(e.message, code: "stream_capacity_exhausted")
     end
 
     private

backend/app/services/sessions/pause.rb

@@ -9,11 +9,12 @@ module Sessions
       @session.pause! if @session.may_pause?
       Mediamtx::PublisherSync.forget_recording_state!(@session.id)
       begin
-        Mediamtx::Client.for_session(@session).set_path_recording(@session, enabled: false)
+        mtx = Mediamtx::Client.new
+        mtx.set_path_recording(@session, enabled: false)
+        mtx.set_always_available(@session, enabled: true)
       rescue Mediamtx::Client::Error => e
-        Rails.logger.warn("[Sessions::Pause] disable recording: #{e.message}")
+        Rails.logger.warn("[Sessions::Pause] MediaMTX: #{e.message}")
       end
-      Mediamtx::Client.for_session(@session).set_always_available(@session, enabled: true)
       # Slate su path per HLS in pausa; RTMP telefono si ferma via comando app.
       log_event("paused")
       SessionChannel.broadcast_message(@session, { type: "command", action: "pause_stream" })

backend/app/services/sessions/select_quality.rb

@@ -3,6 +3,8 @@ module Sessions
   class SelectQuality
     UPLOAD_HEADROOM = 0.8
     UPLOAD_HEADROOM_1080P = 1.0
+    AUTO_ID = "auto"
+    AUTO_FLOOR_BITRATE = 800_000
 
     PRESETS = [
       { id: "1080p_30_4.5mbps", target_bitrate: 4_500_000, target_fps: 30 },
@@ -11,6 +13,32 @@ module Sessions
       { id: "720p_30_1.5mbps", target_bitrate: 1_500_000, target_fps: 30 }
     ].freeze
 
+    MIN_QUALITY_IDS = ([AUTO_ID] + PRESETS.map { |preset| preset[:id] }).freeze
+
+    def self.floor_bitrate(preset_id)
+      return AUTO_FLOOR_BITRATE if preset_id.blank? || preset_id == AUTO_ID
+
+      PRESETS.find { |preset| preset[:id] == preset_id }&.fetch(:target_bitrate) || AUTO_FLOOR_BITRATE
+    end
+
+    def self.allowed_min_ids(session_preset)
+      ids = [AUTO_ID] + PRESETS.reject { |preset| preset[:id].start_with?("1080p") }.reverse.map { |preset| preset[:id] }
+      ids << "1080p_30_4.5mbps" if session_preset.to_s.start_with?("1080p")
+      ids
+    end
+
+    def self.display_name(preset_id)
+      return AUTO_ID if preset_id.blank? || preset_id == AUTO_ID
+
+      preset = PRESETS.find { |item| item[:id] == preset_id }
+      return preset_id unless preset
+
+      resolution = preset[:id].start_with?("1080p") ? "1080p" : "720p"
+      mbps = preset[:target_bitrate] / 1_000_000.0
+      mbps_text = (mbps == mbps.to_i) ? mbps.to_i.to_s : format("%.1f", mbps)
+      "#{resolution} · #{mbps_text} Mbps"
+    end
+
     def self.call(upload_mbps:)
       new(upload_mbps: upload_mbps).call
     end

backend/app/services/sessions/set_min_quality.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sessions
+  class SetMinQuality
+    def initialize(session, preset:)
+      @session = session
+      @preset = preset.to_s.strip
+    end
+
+    def call
+      id = normalize
+      unless SelectQuality.allowed_min_ids(@session.quality_preset).include?(id)
+        raise ArgumentError, "Qualità minima non valida"
+      end
+
+      return @session if @session.min_quality_preset == id
+
+      @session.update!(min_quality_preset: id)
+      @session.stream_events.create!(
+        event_type: "quality_changed",
+        occurred_at: Time.current,
+        metadata: { "min_quality_preset" => id }
+      )
+      SessionChannel.broadcast_message(
+        @session,
+        { type: "command", action: "set_min_quality", min_quality_preset: id }
+      )
+      @session
+    end
+
+    private
+
+    def normalize
+      return SelectQuality::AUTO_ID if @preset.blank? || @preset == SelectQuality::AUTO_ID
+
+      @preset
+    end
+  end
+end

backend/app/services/sessions/stop.rb

@@ -33,7 +33,7 @@ module Sessions
     end
 
     def remove_mediamtx_paths!
-      Mediamtx::Client.for_session(@session).delete_path(@session)
+      Mediamtx::Client.new.delete_path(@session)
     rescue Mediamtx::Client::Error => e
       Rails.logger.warn("[Sessions::Stop] delete_path #{@session.id}: #{e.message}")
     end

backend/app/services/streams/autoscaler.rb

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  # Scale-out / warm spare / scale-in dei nodi overflow (lab o Hetzner).
-  # Kill-switch: STREAM_AUTOSCALE_ENABLED!=1 OPPURE Redis streams:autoscaler:kill_switch=1.
-  class Autoscaler
-    Result = Struct.new(:actions, :metrics, :skipped, :error, keyword_init: true)
-
-    LOCK_KEY = "streams:autoscaler:lock"
-    KILL_SWITCH_KEY = "streams:autoscaler:kill_switch"
-
-    class << self
-      def enabled?
-        return false if kill_switch_engaged?
-        return false unless ENV["STREAM_AUTOSCALE_ENABLED"] == "1"
-
-        true
-      end
-
-      def kill_switch_engaged?
-        redis_get(KILL_SWITCH_KEY) == "1"
-      end
-
-      def engage_kill_switch!
-        redis_set(KILL_SWITCH_KEY, "1")
-      end
-
-      def clear_kill_switch!
-        redis_del(KILL_SWITCH_KEY)
-      end
-
-      def soft_free_slots
-        ENV.fetch("STREAM_AUTOSCALE_SOFT_FREE_SLOTS", "2").to_i
-      end
-
-      def warm_spare_min
-        ENV.fetch("STREAM_AUTOSCALE_WARM_SPARE", "1").to_i
-      end
-
-      def idle_minutes
-        ENV.fetch("STREAM_AUTOSCALE_IDLE_MINUTES", "30").to_i
-      end
-
-      def max_overflow_nodes
-        ENV.fetch("STREAM_AUTOSCALE_MAX_NODES", "5").to_i
-      end
-
-      def kind
-        ENV.fetch("STREAM_AUTOSCALE_KIND", "lab") # lab|cloud
-      end
-
-      def allow_cloud?
-        ENV["STREAM_AUTOSCALE_ALLOW_CLOUD"] == "1" && ENV["HCLOUD_TOKEN"].present?
-      end
-
-      def node_eur_per_hour
-        ENV.fetch("STREAM_AUTOSCALE_NODE_EUR_PER_HOUR", "0.015").to_f
-      end
-
-      def monthly_budget_eur
-        ENV.fetch("STREAM_AUTOSCALE_MONTHLY_BUDGET_EUR", "40").to_f
-      end
-
-      def estimated_monthly_eur(overflow_count = nil)
-        count = overflow_count || metrics[:overflow_nodes]
-        # Worst case: nodi sempre accesi 24/7
-        (count * node_eur_per_hour * 24 * 30).round(2)
-      end
-
-      def within_budget?(overflow_count = nil)
-        estimated_monthly_eur(overflow_count) <= monthly_budget_eur
-      end
-
-      def reconcile!(provisioner: nil)
-        return Result.new(skipped: true, actions: [], metrics: metrics) unless enabled?
-
-        redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
-        unless redis.set(LOCK_KEY, worker_id, nx: true, ex: 55)
-          return Result.new(skipped: true, actions: [], metrics: metrics, error: "locked")
-        end
-
-        begin
-          new(provisioner: provisioner).reconcile!
-        ensure
-          redis.del(LOCK_KEY)
-        end
-      end
-
-      def metrics
-        NodeRegistry.ensure_home_from_env!
-        nodes = StreamNode.ready.to_a
-        overflow = StreamNode.where.not(slug: NodeRegistry::HOME_SLUG)
-          .where(status: %w[ready draining provisioning]).to_a
-        {
-          free_slots: nodes.sum(&:free_slots),
-          ready_nodes: nodes.size,
-          spare_ready: nodes.count { |n| n.slug != NodeRegistry::HOME_SLUG && n.active_publishers.zero? },
-          overflow_nodes: overflow.size,
-          soft_free_slots: soft_free_slots,
-          warm_spare_min: warm_spare_min,
-          max_overflow_nodes: max_overflow_nodes,
-          enabled: enabled?,
-          env_enabled: ENV["STREAM_AUTOSCALE_ENABLED"] == "1",
-          kill_switch: kill_switch_engaged?,
-          kind: kind,
-          allow_cloud: allow_cloud?,
-          estimated_monthly_eur: estimated_monthly_eur(overflow.size),
-          monthly_budget_eur: monthly_budget_eur,
-          within_budget: within_budget?(overflow.size)
-        }
-      end
-
-      def worker_id
-        ENV.fetch("HOSTNAME", "autoscaler")
-      end
-
-      def redis_get(key)
-        Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0")).get(key)
-      rescue Redis::BaseError
-        nil
-      end
-
-      def redis_set(key, value)
-        Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0")).set(key, value)
-      end
-
-      def redis_del(key)
-        Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0")).del(key)
-      end
-    end
-
-    def initialize(provisioner: nil)
-      @provisioner = provisioner || NodeProvisioner.new
-    end
-
-    def reconcile!
-      actions = []
-      m = self.class.metrics
-
-      if need_capacity?(m) && can_provision?(m)
-        provision_overflow!
-        actions << :scale_out
-        m = self.class.metrics
-      elsif need_capacity?(m) && !can_provision?(m)
-        actions << :blocked_capacity
-        Rails.logger.warn("[Streams::Autoscaler] capacity needed but blocked metrics=#{m.inspect}")
-      end
-
-      if warm_spare_desired?(m) && m[:spare_ready] < self.class.warm_spare_min && can_provision?(m)
-        provision_overflow!
-        actions << :warm_spare
-        m = self.class.metrics
-      end
-
-      scale_in_candidates.each do |node|
-        next if keep_as_warm_spare?(node)
-
-        safe_scale_in!(node)
-        actions << :"scale_in_#{node.slug}"
-        m = self.class.metrics
-      rescue NodeProvisioner::BusyError, NodeProvisioner::Error => e
-        Rails.logger.warn("[Streams::Autoscaler] scale-in #{node.slug}: #{e.message}")
-      end
-
-      Rails.logger.info("[Streams::Autoscaler] actions=#{actions.inspect} metrics=#{m.inspect}")
-      Result.new(actions: actions, metrics: m, skipped: false)
-    end
-
-    private
-
-    def need_capacity?(m)
-      m[:free_slots] <= self.class.soft_free_slots
-    end
-
-    def warm_spare_desired?(m)
-      return false if self.class.warm_spare_min <= 0
-
-      need_capacity?(m) || overflow_in_use?
-    end
-
-    def overflow_in_use?
-      StreamNode.ready.where.not(slug: NodeRegistry::HOME_SLUG).any? { |n| n.active_publishers.positive? }
-    end
-
-    def can_provision?(m)
-      return false if m[:overflow_nodes] >= self.class.max_overflow_nodes
-      return false unless self.class.within_budget?(m[:overflow_nodes] + 1)
-      return false if self.class.kind == "cloud" && !self.class.allow_cloud?
-
-      true
-    end
-
-    def provision_overflow!
-      case self.class.kind
-      when "cloud"
-        raise NodeProvisioner::Error, "Cloud autoscale disabilitato (STREAM_AUTOSCALE_ALLOW_CLOUD / HCLOUD_TOKEN)" unless self.class.allow_cloud?
-
-        @provisioner.provision_cloud!
-      else
-        @provisioner.provision_lab!
-      end
-    end
-
-    def safe_scale_in!(node)
-      @provisioner.drain!(node) unless node.status == "draining"
-      node.reload
-      raise NodeProvisioner::BusyError, "sessioni ancora attive" if node.occupying_sessions.exists?
-      raise NodeProvisioner::Error, "idle insufficiente" unless idle_long_enough?(node)
-
-      @provisioner.decommission!(node)
-    end
-
-    def scale_in_candidates
-      StreamNode.where.not(slug: NodeRegistry::HOME_SLUG)
-        .where(status: %w[ready draining])
-        .order(:created_at)
-        .select { |n| n.active_publishers.zero? && idle_long_enough?(n) }
-    end
-
-    def idle_long_enough?(node)
-      idle_since(node) <= self.class.idle_minutes.minutes.ago
-    end
-
-    def idle_since(node)
-      last_end = node.stream_sessions.where(status: %w[ended error]).maximum(:ended_at)
-      last_end || node.created_at
-    end
-
-    def keep_as_warm_spare?(node)
-      return false unless warm_spare_desired?(self.class.metrics)
-
-      spares = StreamNode.ready.where.not(slug: NodeRegistry::HOME_SLUG).select { |n| n.active_publishers.zero? }
-      spares.size <= self.class.warm_spare_min && spares.map(&:id).include?(node.id)
-    end
-  end
-end

backend/app/services/streams/cloud_providers.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  module CloudProviders
-    def self.build(name = ENV.fetch("STREAM_CLOUD_PROVIDER", "local_lab"))
-      case name.to_s
-      when "local_lab" then LocalLab.new
-      when "proxmox_lab" then ProxmoxLab.new
-      when "hetzner" then Hetzner.new
-      else
-        raise Error, "STREAM_CLOUD_PROVIDER sconosciuto: #{name}"
-      end
-    end
-  end
-end

backend/app/services/streams/cloud_providers/base.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  module CloudProviders
-    class Error < StandardError; end
-
-    # Descrittore restituito da create_node / list.
-    Instance = Struct.new(
-      :id, :name, :public_ip, :private_ip, :status, :raw,
-      keyword_init: true
-    )
-
-    class Base
-      def create_node(name:, labels: {})
-        raise NotImplementedError
-      end
-
-      def destroy_node(instance_id)
-        raise NotImplementedError
-      end
-
-      def list_nodes(labels: {})
-        raise NotImplementedError
-      end
-
-      def wait_until_running(instance_id, timeout: 120)
-        raise NotImplementedError
-      end
-
-      def public_ip(instance_id)
-        raise NotImplementedError
-      end
-    end
-  end
-end

backend/app/services/streams/cloud_providers/hetzner.rb

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-
-module Streams
-  module CloudProviders
-    # Hetzner Cloud — create/destroy server per nodi stream.
-    #
-    # ENV:
-    #   HCLOUD_TOKEN (obbligatorio)
-    #   HCLOUD_LOCATION (default fsn1)
-    #   HCLOUD_SERVER_TYPE (default cpx21)
-    #   HCLOUD_IMAGE (default debian-12)
-    #   HCLOUD_SSH_KEY (nome chiave, default matchlivetv-stream)
-    #   HCLOUD_NETWORK_ID (opzionale, private network / WireGuard prep)
-    #   HCLOUD_USER_DATA_FILE (opzionale, cloud-init path)
-    class Hetzner < Base
-      # Trailing slash obbligatorio: path assoluti tipo "/servers" altrimenti droppano /v1.
-      API = "https://api.hetzner.cloud/v1/"
-
-      def initialize(token: ENV.fetch("HCLOUD_TOKEN"), conn: nil)
-        @token = token
-        @conn = conn
-      end
-
-      def create_node(name:, labels: {})
-        body = {
-          name: name,
-          server_type: ENV.fetch("HCLOUD_SERVER_TYPE", "cpx12"),
-          image: ENV.fetch("HCLOUD_IMAGE", "debian-12"),
-          location: ENV.fetch("HCLOUD_LOCATION", "nbg1"),
-          start_after_create: true,
-          labels: default_labels.merge(stringify_labels(labels)),
-          ssh_keys: [ENV.fetch("HCLOUD_SSH_KEY", "matchlivetv-stream-hetzner")],
-          public_net: {
-            enable_ipv4: true,
-            enable_ipv6: false
-          }
-        }
-        network_id = ENV["HCLOUD_NETWORK_ID"].presence
-        body[:networks] = [network_id.to_i] if network_id
-        user_data = cloud_init_user_data
-        body[:user_data] = user_data
-
-        data = post("servers", body)
-        server = data["server"] || {}
-        action = data["action"]
-        wait_action!(action) if action
-        instance = wait_until_running(server["id"].to_s)
-        instance.name = name
-        instance
-      end
-
-      def destroy_node(instance_id)
-        delete("servers/#{instance_id}")
-        true
-      end
-
-      def list_nodes(labels: {})
-        params = {}
-        label_selector = labels.map { |k, v| "#{k}=#{v}" }.join(",")
-        params[:label_selector] = label_selector if label_selector.present?
-        params[:label_selector] ||= "matchlivetv=true,role=stream-node"
-
-        data = get("servers", params)
-        Array(data["servers"]).map { |s| instance_from_server(s) }
-      end
-
-      def wait_until_running(instance_id, timeout: 180)
-        deadline = Time.now + timeout
-        loop do
-          data = get("servers/#{instance_id}")
-          server = data["server"]
-          status = server["status"]
-          if status == "running"
-            return instance_from_server(server)
-          end
-          raise Error, "Timeout attesa server Hetzner #{instance_id} (status=#{status})" if Time.now >= deadline
-
-          sleep 3
-        end
-      end
-
-      def public_ip(instance_id)
-        wait_until_running(instance_id).public_ip
-      end
-
-      private
-
-      def default_labels
-        {
-          "matchlivetv" => "true",
-          "role" => "stream-node",
-          "env" => ENV.fetch("STREAM_NODE_ENV", "prod")
-        }
-      end
-
-      def stringify_labels(labels)
-        labels.to_h.transform_keys(&:to_s).transform_values(&:to_s)
-      end
-
-      def instance_from_server(server)
-        public_ip = server.dig("public_net", "ipv4", "ip")
-        private_ip = Array(server["private_net"]).first&.dig("ip")
-        Instance.new(
-          id: server["id"].to_s,
-          name: server["name"],
-          public_ip: public_ip,
-          private_ip: private_ip.presence || public_ip,
-          status: server["status"],
-          raw: server
-        )
-      end
-
-      def cloud_init_user_data
-        path = ENV["HCLOUD_USER_DATA_FILE"].presence
-        if path.present?
-          raise Error, "HCLOUD_USER_DATA_FILE non leggibile nel container: #{path}" unless File.file?(path)
-
-          return File.read(path)
-        end
-
-        inline = ENV["HCLOUD_USER_DATA"].presence
-        raise Error, "Manca cloud-init: imposta HCLOUD_USER_DATA_FILE (montato) o HCLOUD_USER_DATA" if inline.blank?
-
-        inline
-      end
-
-      def conn
-        @conn ||= Faraday.new(url: API) do |f|
-          f.request :json
-          f.response :json, content_type: /\bjson$/
-          f.adapter Faraday.default_adapter
-        end
-      end
-
-      def auth_headers
-        { "Authorization" => "Bearer #{@token}" }
-      end
-
-      def get(path, params = {})
-        response = conn.get(path) do |req|
-          req.headers.update(auth_headers)
-          req.params.update(params)
-        end
-        unwrap!(response)
-      end
-
-      def post(path, body)
-        response = conn.post(path) do |req|
-          req.headers.update(auth_headers)
-          req.body = body
-        end
-        unwrap!(response)
-      end
-
-      def delete(path)
-        response = conn.delete(path) do |req|
-          req.headers.update(auth_headers)
-        end
-        return {} if response.status == 204
-
-        unwrap!(response)
-      end
-
-      def unwrap!(response)
-        unless response.success?
-          raise Error, "Hetzner Cloud API #{response.status}: #{response.body.inspect}"
-        end
-
-        response.body.is_a?(Hash) ? response.body : {}
-      end
-
-      def wait_action!(action, timeout: 120)
-        return unless action.is_a?(Hash) && action["id"]
-
-        deadline = Time.now + timeout
-        id = action["id"]
-        loop do
-          data = get("actions/#{id}")
-          status = data.dig("action", "status")
-          return if status == "success"
-          raise Error, "Hetzner action #{id} failed: #{data.inspect}" if status == "error"
-          raise Error, "Timeout action Hetzner #{id}" if Time.now >= deadline
-
-          sleep 2
-        end
-      end
-    end
-  end
-end

backend/app/services/streams/cloud_providers/local_lab.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  module CloudProviders
-    # Lab senza API Proxmox: simula create/destroy e riusa MediaMTX home per i path.
-    # Utile per testare registry, assignment e admin senza secondi host.
-    class LocalLab < Base
-      def create_node(name:, labels: {})
-        Instance.new(
-          id: "sim-#{name}",
-          name: name,
-          public_ip: labels[:public_ip].presence || "127.0.0.1",
-          private_ip: labels[:private_ip].presence || "127.0.0.1",
-          status: "running",
-          raw: { simulated: true, labels: labels }
-        )
-      end
-
-      def destroy_node(instance_id)
-        true
-      end
-
-      def list_nodes(labels: {})
-        StreamNode.where(provider: "local", role: "lab").map do |node|
-          Instance.new(
-            id: node.provider_instance_id,
-            name: node.slug,
-            public_ip: node.metadata["public_ip"],
-            private_ip: node.metadata["private_ip"],
-            status: node.status == "ready" ? "running" : node.status,
-            raw: node.metadata
-          )
-        end
-      end
-
-      def wait_until_running(instance_id, timeout: 120)
-        Instance.new(id: instance_id, name: instance_id, status: "running")
-      end
-
-      def public_ip(instance_id)
-        "127.0.0.1"
-      end
-    end
-  end
-end

backend/app/services/streams/cloud_providers/proxmox_lab.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-
-module Streams
-  module CloudProviders
-    # Clone/start/stop di VM template su Proxmox VE (API token).
-    #
-    # ENV richiesti:
-    #   PROXMOX_API_URL, PROXMOX_TOKEN_ID, PROXMOX_TOKEN_SECRET,
-    #   PROXMOX_NODE, PROXMOX_TEMPLATE_VMID
-    class ProxmoxLab < Base
-      def initialize(
-        api_url: ENV.fetch("PROXMOX_API_URL"),
-        token_id: ENV.fetch("PROXMOX_TOKEN_ID"),
-        token_secret: ENV.fetch("PROXMOX_TOKEN_SECRET"),
-        node: ENV.fetch("PROXMOX_NODE"),
-        template_vmid: ENV.fetch("PROXMOX_TEMPLATE_VMID"),
-        verify_ssl: ENV.fetch("PROXMOX_VERIFY_SSL", "false") == "true"
-      )
-        @api_url = api_url.to_s.chomp("/")
-        @token_id = token_id
-        @token_secret = token_secret
-        @node = node
-        @template_vmid = template_vmid.to_i
-        @verify_ssl = verify_ssl
-      end
-
-      def create_node(name:, labels: {})
-        newid = next_vmid
-        post("/nodes/#{@node}/qemu/#{@template_vmid}/clone", {
-          newid: newid,
-          name: name,
-          full: 1,
-          target: @node
-        })
-        post("/nodes/#{@node}/qemu/#{newid}/status/start", {})
-        wait_until_running(newid.to_s)
-        ip = public_ip(newid.to_s)
-        Instance.new(
-          id: newid.to_s,
-          name: name,
-          public_ip: ip,
-          private_ip: ip,
-          status: "running",
-          raw: { node: @node, vmid: newid, labels: labels }
-        )
-      end
-
-      def destroy_node(instance_id)
-        vmid = instance_id.to_i
-        begin
-          post("/nodes/#{@node}/qemu/#{vmid}/status/stop", { timeout: 30 })
-        rescue Error
-          # già spenta
-        end
-        sleep 2
-        delete("/nodes/#{@node}/qemu/#{vmid}", { purge: 1 })
-        true
-      end
-
-      def list_nodes(labels: {})
-        items = get("/nodes/#{@node}/qemu")
-        Array(items).filter_map do |row|
-          name = row["name"].to_s
-          next unless name.start_with?("mltv-stream-") || name.start_with?("ingest-")
-
-          Instance.new(
-            id: row["vmid"].to_s,
-            name: name,
-            public_ip: nil,
-            private_ip: nil,
-            status: row["status"],
-            raw: row
-          )
-        end
-      end
-
-      def wait_until_running(instance_id, timeout: 180)
-        deadline = Time.now + timeout
-        loop do
-          status = get("/nodes/#{@node}/qemu/#{instance_id}/status/current")
-          return Instance.new(id: instance_id.to_s, status: "running", raw: status) if status["status"] == "running"
-          raise Error, "Timeout attesa VM #{instance_id}" if Time.now >= deadline
-
-          sleep 3
-        end
-      end
-
-      def public_ip(instance_id)
-        agent = get("/nodes/#{@node}/qemu/#{instance_id}/agent/network-get-interfaces")
-        interfaces = agent.is_a?(Hash) ? agent["result"] : nil
-        Array(interfaces).each do |iface|
-          Array(iface["ip-addresses"]).each do |addr|
-            ip = addr["ip-address"].to_s
-            next if ip.blank? || ip.start_with?("127.") || ip.include?(":")
-
-            return ip
-          end
-        end
-        ENV["STREAM_LAB_FALLBACK_IP"].presence || "127.0.0.1"
-      rescue Error
-        ENV["STREAM_LAB_FALLBACK_IP"].presence || "127.0.0.1"
-      end
-
-      private
-
-      def next_vmid
-        used = Array(get("/cluster/resources", type: "vm")).map { |r| r["vmid"].to_i }
-        candidate = ENV.fetch("PROXMOX_VMID_START", "9100").to_i
-        candidate += 1 while used.include?(candidate)
-        candidate
-      end
-
-      def conn
-        @conn ||= Faraday.new(url: "#{@api_url}/api2/json") do |f|
-          f.request :url_encoded
-          f.response :json, content_type: /\bjson$/
-          f.adapter Faraday.default_adapter
-          f.ssl[:verify] = @verify_ssl
-        end
-      end
-
-      def auth_headers
-        { "Authorization" => "PVEAPIToken=#{@token_id}=#{@token_secret}" }
-      end
-
-      def get(path, params = {})
-        response = conn.get(path) do |req|
-          req.headers.update(auth_headers)
-          req.params.update(params)
-        end
-        unwrap!(response)
-      end
-
-      def post(path, body = {})
-        response = conn.post(path) do |req|
-          req.headers.update(auth_headers)
-          req.body = body
-        end
-        unwrap!(response)
-      end
-
-      def delete(path, params = {})
-        response = conn.delete(path) do |req|
-          req.headers.update(auth_headers)
-          req.params.update(params)
-        end
-        unwrap!(response)
-      end
-
-      def unwrap!(response)
-        unless response.success?
-          raise Error, "Proxmox API #{response.status}: #{response.body.inspect}"
-        end
-
-        body = response.body
-        body.is_a?(Hash) && body.key?("data") ? body["data"] : body
-      end
-    end
-  end
-end

backend/app/services/streams/dns_providers.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  module DnsProviders
-    def self.build(name = ENV.fetch("STREAM_DNS_PROVIDER", "lab"))
-      case name.to_s
-      when "lab" then Lab.new
-      when "hetzner" then Hetzner.new
-      else
-        raise Error, "STREAM_DNS_PROVIDER sconosciuto: #{name}"
-      end
-    end
-  end
-end

backend/app/services/streams/dns_providers/base.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  module DnsProviders
-    class Error < StandardError; end
-
-    class Base
-      def upsert_a(name, ip)
-        raise NotImplementedError
-      end
-
-      def delete_a(name)
-        raise NotImplementedError
-      end
-
-      def resolve(name)
-        raise NotImplementedError
-      end
-    end
-  end
-end

backend/app/services/streams/dns_providers/hetzner.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "cgi"
-
-module Streams
-  module DnsProviders
-    # Hetzner Cloud DNS (Console) — zone mltv-stream.net.
-    #
-    # ENV:
-    #   HCLOUD_TOKEN (stesso del Cloud)
-    #   STREAM_DNS_ZONE (default mltv-stream.net)
-    #   STREAM_DNS_TTL (default 60)
-    class Hetzner < Base
-      # Trailing slash obbligatorio: path assoluti altrimenti droppano /v1.
-      API = "https://api.hetzner.cloud/v1/"
-
-      def initialize(token: ENV.fetch("HCLOUD_TOKEN"), zone: nil, conn: nil)
-        @token = token
-        @zone = zone || ENV.fetch("STREAM_DNS_ZONE", "mltv-stream.net")
-        @ttl = ENV.fetch("STREAM_DNS_TTL", "60").to_i
-        @conn = conn
-      end
-
-      def upsert_a(name, ip)
-        rr_name = relative_name(name)
-        delete_a(name)
-        post("zones/#{CGI.escape(@zone)}/rrsets", {
-          name: rr_name,
-          type: "A",
-          ttl: @ttl,
-          records: [{ value: ip.to_s, comment: "matchlivetv stream-node" }],
-          labels: { "matchlivetv" => "true", "role" => "stream-node" }
-        })
-        true
-      end
-
-      def delete_a(name)
-        rr_name = relative_name(name)
-        encoded = CGI.escape(rr_name)
-        response = conn.delete("zones/#{CGI.escape(@zone)}/rrsets/#{encoded}/A") do |req|
-          req.headers.update(auth_headers)
-        end
-        return true if response.status == 404 || response.status == 204 || response.success?
-
-        raise Error, "Hetzner DNS API #{response.status}: #{response.body.inspect}"
-      end
-
-      def resolve(name)
-        rr_name = relative_name(name)
-        data = get("zones/#{CGI.escape(@zone)}/rrsets", name: rr_name, type: "A")
-        rrset = Array(data["rrsets"]).first
-        Array(rrset&.dig("records")).first&.dig("value")
-      rescue Error
-        nil
-      end
-
-      private
-
-      def relative_name(name)
-        host = name.to_s.strip.downcase.delete_suffix(".")
-        suffix = ".#{@zone}"
-        return "@" if host == @zone
-        return host.delete_suffix(suffix) if host.end_with?(suffix)
-
-        host
-      end
-
-      def conn
-        @conn ||= Faraday.new(url: API) do |f|
-          f.request :json
-          f.response :json, content_type: /\bjson$/
-          f.adapter Faraday.default_adapter
-        end
-      end
-
-      def auth_headers
-        { "Authorization" => "Bearer #{@token}" }
-      end
-
-      def get(path, params = {})
-        response = conn.get(path) do |req|
-          req.headers.update(auth_headers)
-          req.params.update(params)
-        end
-        unwrap!(response)
-      end
-
-      def post(path, body)
-        response = conn.post(path) do |req|
-          req.headers.update(auth_headers)
-          req.body = body
-        end
-        unwrap!(response)
-      end
-
-      def unwrap!(response)
-        unless response.success?
-          raise Error, "Hetzner DNS API #{response.status}: #{response.body.inspect}"
-        end
-
-        response.body.is_a?(Hash) ? response.body : {}
-      end
-    end
-  end
-end

backend/app/services/streams/dns_providers/lab.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  module DnsProviders
-    # DNS lab in Redis (e dump hosts). Nessuna chiamata al registrar.
-    class Lab < Base
-      REDIS_KEY = "stream_dns:a_records"
-
-      def initialize(redis: nil)
-        @redis = redis
-      end
-
-      def upsert_a(name, ip)
-        host = normalize(name)
-        redis.hset(REDIS_KEY, host, ip.to_s)
-        true
-      end
-
-      def delete_a(name)
-        redis.hdel(REDIS_KEY, normalize(name))
-        true
-      end
-
-      def resolve(name)
-        redis.hget(REDIS_KEY, normalize(name))
-      end
-
-      def all_records
-        redis.hgetall(REDIS_KEY)
-      end
-
-      def hosts_file_snippet
-        all_records.sort.map { |host, ip| "#{ip}\t#{host}" }.join("\n")
-      end
-
-      private
-
-      def normalize(name)
-        name.to_s.strip.downcase.delete_suffix(".")
-      end
-
-      def redis
-        @redis ||= Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
-      end
-    end
-  end
-end

backend/app/services/streams/node_provisioner.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  # Provisiona / decommissiona nodi stream (lab o cloud) e aggiorna DNS + registry.
-  class NodeProvisioner
-    class Error < StandardError; end
-    class BusyError < Error; end
-
-    LAB_DNS_SUFFIX = -> { ENV.fetch("STREAM_LAB_DNS_SUFFIX", "lab.mltv-stream.net") }
-    CLOUD_DNS_SUFFIX = -> { ENV.fetch("STREAM_CLOUD_DNS_SUFFIX", ENV.fetch("STREAM_DNS_ZONE", "mltv-stream.net")) }
-
-    def initialize(cloud: nil, dns: nil)
-      @cloud = cloud
-      @dns = dns
-    end
-
-    def provision_lab!(prefix: "ingest-lab")
-      provision!(
-        prefix: prefix,
-        role: "lab",
-        dns_suffix: LAB_DNS_SUFFIX.call,
-        cloud: cloud_provider(ENV.fetch("STREAM_CLOUD_PROVIDER", "local_lab")),
-        dns: dns_provider(ENV.fetch("STREAM_DNS_PROVIDER", "lab")),
-        max: ENV.fetch("STREAM_LAB_MAX_PUBLISHERS", "2").to_i,
-        use_node_hostname: ENV["STREAM_LAB_USE_NODE_HOSTNAME"] == "1"
-      )
-    end
-
-    def provision_cloud!(prefix: "ingest")
-      provision!(
-        prefix: prefix,
-        role: "cloud",
-        dns_suffix: CLOUD_DNS_SUFFIX.call,
-        cloud: cloud_provider("hetzner"),
-        dns: dns_provider("hetzner"),
-        max: ENV.fetch("STREAM_CLOUD_MAX_PUBLISHERS", "4").to_i,
-        use_node_hostname: true
-      )
-    end
-
-    def decommission!(node)
-      raise Error, "Non si può decommissionare il nodo home" if node.slug == Streams::NodeRegistry::HOME_SLUG
-      if node.occupying_sessions.exists?
-        raise BusyError, "Nodo #{node.slug} ha ancora sessioni attive"
-      end
-
-      node.update!(status: "draining")
-      cloud = cloud_for_node(node)
-      dns = dns_for_node(node)
-      cloud.destroy_node(node.provider_instance_id) if node.provider_instance_id.present?
-      dns.delete_a(node.hostname) if node.hostname.present?
-      node.destroy!
-      true
-    end
-
-    def drain!(node)
-      raise Error, "Non si può mettere in drain il nodo home" if node.slug == Streams::NodeRegistry::HOME_SLUG
-
-      node.update!(status: "draining")
-      node
-    end
-
-    private
-
-    def provision!(prefix:, role:, dns_suffix:, cloud:, dns:, max:, use_node_hostname:)
-      Streams::NodeRegistry.ensure_home_from_env!
-      home = StreamNode.find_by!(slug: Streams::NodeRegistry::HOME_SLUG)
-      slug = next_slug(prefix)
-      hostname = "#{slug}.#{dns_suffix}"
-
-      instance = cloud.create_node(
-        name: "mltv-stream-#{slug}",
-        labels: { role: "stream-node", env: role == "cloud" ? "prod" : "lab" }
-      )
-      ip = instance.public_ip.presence || "127.0.0.1"
-      private_ip = instance.private_ip.presence || ip
-      dns.upsert_a(hostname, ip)
-
-      simulated = instance.raw.is_a?(Hash) && (instance.raw[:simulated] || instance.raw["simulated"])
-      api_base = simulated ? home.api_base_url : "http://#{private_ip}:9997"
-      internal_rtmp = simulated ? home.internal_rtmp_url : "rtmp://#{private_ip}:1935"
-      internal_hls = simulated ? home.internal_hls_url : "http://#{private_ip}:8888"
-
-      StreamNode.create!(
-        slug: slug,
-        hostname: hostname,
-        role: role,
-        status: "ready",
-        provider: provider_name_for(cloud, role: role),
-        provider_instance_id: instance.id,
-        rtmp_base_url: use_node_hostname ? "rtmp://#{hostname}:1935" : home.rtmp_base_url,
-        hls_base_url: use_node_hostname ? "https://#{hostname}/hls" : home.hls_base_url,
-        api_base_url: api_base,
-        internal_rtmp_url: internal_rtmp,
-        internal_hls_url: internal_hls,
-        max_publishers: max,
-        max_relays: max,
-        last_health_at: Time.current,
-        metadata: {
-          "public_ip" => ip,
-          "private_ip" => private_ip,
-          "simulated" => simulated,
-          "cloud_raw" => instance.raw
-        }
-      )
-    end
-
-    def next_slug(prefix)
-      used = StreamNode.where("slug LIKE ?", "#{prefix}-%").pluck(:slug)
-      n = 1
-      loop do
-        candidate = format("%s-%02d", prefix, n)
-        return candidate unless used.include?(candidate)
-
-        n += 1
-      end
-    end
-
-    def cloud_provider(name)
-      @cloud || Streams::CloudProviders.build(name)
-    end
-
-    def dns_provider(name)
-      @dns || Streams::DnsProviders.build(name)
-    end
-
-    def provider_name_for(cloud, role: nil)
-      return "hetzner" if role.to_s == "cloud"
-
-      case cloud
-      when Streams::CloudProviders::ProxmoxLab then "proxmox_lab"
-      when Streams::CloudProviders::Hetzner then "hetzner"
-      else "local"
-      end
-    end
-
-    def cloud_for_node(node)
-      case node.provider
-      when "hetzner" then Streams::CloudProviders::Hetzner.new
-      when "proxmox_lab" then Streams::CloudProviders::ProxmoxLab.new
-      else Streams::CloudProviders::LocalLab.new
-      end
-    end
-
-    def dns_for_node(node)
-      case node.provider
-      when "hetzner" then Streams::DnsProviders::Hetzner.new
-      else Streams::DnsProviders::Lab.new
-      end
-    end
-  end
-end

backend/app/services/streams/node_registry.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  # Assegna un StreamNode a una nuova sessione (least-loaded tra i ready).
-  # Garantisce il nodo "home" derivato dagli ENV MediaMTX attuali.
-  class NodeRegistry
-    class NoCapacityError < StandardError; end
-
-    HOME_SLUG = "home"
-
-    class << self
-      def ensure_home_from_env!
-        StreamNode.find_or_initialize_by(slug: HOME_SLUG).tap do |node|
-          attrs = {
-            hostname: home_hostname,
-            role: "home",
-            provider: "local",
-            rtmp_base_url: MatchLiveTv.mediamtx_rtmp_url,
-            hls_base_url: MatchLiveTv.hls_public_url,
-            api_base_url: MatchLiveTv.mediamtx_api_url,
-            internal_rtmp_url: ENV.fetch("MEDIAMTX_INTERNAL_RTMP_URL", "rtmp://mediamtx:1935"),
-            internal_hls_url: ENV.fetch("MEDIAMTX_HLS_URL", "http://mediamtx:8888"),
-            max_publishers: ENV.fetch("STREAM_NODE_HOME_MAX_PUBLISHERS", "6").to_i,
-            max_relays: ENV.fetch("STREAM_NODE_HOME_MAX_RELAYS", "6").to_i
-          }
-          # Non sovrascrivere drain/offline/error (ops) a ogni allocate!
-          attrs[:status] = "ready" if node.new_record? || !%w[draining offline error].include?(node.status)
-          node.assign_attributes(attrs)
-          node.save!
-        end
-      end
-
-      def allocate!
-        ensure_home_from_env!
-
-        node = StreamNode.ready
-          .to_a
-          .select(&:allocatable?)
-          .min_by { |n| [n.active_publishers, n.role == "home" ? 1 : 0, n.slug] }
-
-        raise NoCapacityError, "Nessun nodo streaming con slot liberi" if node.nil?
-
-        node
-      end
-
-      private
-
-      def home_hostname
-        ENV["STREAM_NODE_HOME_HOSTNAME"].presence ||
-          begin
-            uri = URI.parse(MatchLiveTv.mediamtx_rtmp_url.sub(/\Artmps?:\/\//, "http://"))
-            uri.host.presence
-          rescue URI::InvalidURIError
-            nil
-          end || "home"
-      end
-    end
-  end
-end

backend/app/services/streams/youtube_relay.rb

@@ -1,35 +1,29 @@
 module Streams
   # Relay verso YouTube: legge RTMP/HLS da MediaMTX e inoltra su RTMPS (-c copy). Nessun overlay.
-  # ffmpeg gira solo sui worker Sidekiq con YOUTUBE_RELAY_WORKER=1 (coda youtube_relay).
+  # ffmpeg gira solo nel container sidekiq (YOUTUBE_RELAY_WORKER=1).
   class YoutubeRelay
     class Error < StandardError; end
 
     REDIS_KEY = "youtube_relay:pid:%s"
     OWNER_KEY = "youtube_relay:owner:%s"
-    OWNED_SET = "youtube_relay:owned:%s"
-    QUEUE = :youtube_relay
 
     class << self
       def worker?
         ENV["YOUTUBE_RELAY_WORKER"] == "1"
       end
 
-      def max_concurrent
-        ENV.fetch("RELAY_MAX_CONCURRENT", "4").to_i
-      end
-
       def start(session)
         return unless worker?
-
         start_on_worker!(session)
       end
 
-      # Non cancella owner/pid qui: solo il worker owner deve killare ffmpeg.
       def stop(session)
-        if worker? && owner_is_local?(session.id)
+        clear_pid(session.id)
+        redis.del(format(OWNER_KEY, session.id))
+        if worker?
           stop_on_worker!(session)
         else
-          YoutubeRelayStopJob.set(queue: QUEUE).perform_later(session.id)
+          YoutubeRelayStopJob.perform_later(session.id)
         end
         true
       end
@@ -37,13 +31,11 @@ module Streams
       def running?(session_id)
         owner = redis.get(format(OWNER_KEY, session_id))
         pid = pid_for(session_id)
-        return false if pid.blank? && owner.blank?
-        return false if pid.blank? && owner.present? && owner != worker_id && redis.ttl(format(OWNER_KEY, session_id)) <= 30
         return false if pid.blank?
 
         return process_alive?(pid) if owner.blank? || owner == worker_id
 
-        # Relay su altro host: attivo se lock owner ancora fresco.
+        # Relay avviato in un altro container: consideralo attivo se il lock è recente.
         redis.ttl(format(OWNER_KEY, session_id)) > 30
       end
 
@@ -55,12 +47,12 @@ module Streams
         if worker?
           ensure_on_worker!(session)
         else
-          YoutubeRelayEnsureJob.set(queue: QUEUE).perform_later(session.id)
+          YoutubeRelayEnsureJob.perform_later(session.id)
         end
       end
 
       def ensure_on_worker!(session)
-        return :not_worker unless worker?
+        return unless worker?
         return unless session.platform == "youtube"
         return if session.terminal?
         return if session.stream_key.blank?
@@ -68,64 +60,28 @@ module Streams
         return unless intake_available?(session)
 
         pid = pid_for(session.id)
-        if pid.present? && !process_alive?(pid.to_i)
+        clear_pid(session.id) if pid.present? && !process_alive?(pid.to_i)
-          clear_local_ownership(session.id)
-        end
 
-        if running?(session.id)
+        return if running?(session.id)
-          touch_owner!(session.id) if owner_is_local?(session.id)
-          return :already_running
-        end
-
-        if at_capacity?
-          YoutubeRelayEnsureJob.set(wait: 5.seconds, queue: QUEUE).perform_later(session.id)
-          Rails.logger.info("[YoutubeRelay] at capacity worker=#{worker_id} session=#{session.id} requeue")
-          return :at_capacity
-        end
 
         last_restart = redis.get(restart_debounce_key(session.id)).to_i
-        return :debounced if last_restart.positive? && (Time.now.to_i - last_restart) < 5
+        return if last_restart.positive? && (Time.now.to_i - last_restart) < 5
 
         start_on_worker!(session)
         redis.set(restart_debounce_key(session.id), Time.now.to_i, ex: 300)
-        :started
       rescue Error => e
         Rails.logger.warn("[YoutubeRelay] ensure_on_worker session=#{session.id}: #{e.message}")
-        :error
       end
 
-      # @return [Symbol] :stopped, :wrong_host, :noop
       def stop_on_worker!(session)
-        return :not_worker unless worker?
-
-        owner = redis.get(format(OWNER_KEY, session.id))
-        if owner.present? && owner != worker_id
-          return :wrong_host
-        end
-
         pid = pid_for(session.id)
-        if pid.blank?
+        return false if pid.blank?
-          clear_local_ownership(session.id)
-          return :noop
-        end
 
         terminate_pid(pid)
-        clear_local_ownership(session.id)
+        clear_pid(session.id)
-        Rails.logger.info("[YoutubeRelay] stopped pid=#{pid} session=#{session.id} worker=#{worker_id}")
+        redis.del(format(OWNER_KEY, session.id))
-        :stopped
+        Rails.logger.info("[YoutubeRelay] stopped pid=#{pid} session=#{session.id}")
-      end
+        true
-
-      def local_owned_count
-        redis.scard(format(OWNED_SET, worker_id)).to_i
-      end
-
-      def at_capacity?
-        local_owned_count >= max_concurrent
-      end
-
-      def owner_is_local?(session_id)
-        owner = redis.get(format(OWNER_KEY, session_id))
-        owner.blank? || owner == worker_id
       end
 
       private
@@ -136,9 +92,9 @@ module Streams
         return if session.terminal?
         return unless intake_available?(session)
 
-        return pid_for(session.id).to_i if running?(session.id) && owner_is_local?(session.id)
+        return pid_for(session.id).to_i if running?(session.id)
 
-        stop_on_worker!(session) if pid_for(session.id).present? && owner_is_local?(session.id)
+        stop_on_worker!(session) if pid_for(session.id).present?
 
         log_path = log_file(session)
         FileUtils.mkdir_p(File.dirname(log_path))
@@ -152,8 +108,8 @@ module Streams
         )
         Process.detach(pid)
         store_pid(session.id, pid)
-        claim_ownership!(session.id)
+        redis.set(format(OWNER_KEY, session.id), worker_id, ex: 48.hours.to_i)
-        Rails.logger.info("[YoutubeRelay] started pid=#{pid} session=#{session.id} intake=#{intake_source.join(":")} worker=#{worker_id}")
+        Rails.logger.info("[YoutubeRelay] started pid=#{pid} session=#{session.id} intake=#{intake_source.join(":")}")
         schedule_youtube_activate(session)
         pid
       rescue Errno::ENOENT => e
@@ -190,20 +146,20 @@ module Streams
       end
 
       def mediamtx_intake_source(session)
-        base = session.mediamtx_internal_rtmp_url
+        base = ENV.fetch("MEDIAMTX_INTERNAL_RTMP_URL", "rtmp://mediamtx:1935")
         if Mediamtx::PublisherOnline.active?(session)
           return [:rtmp, "#{base.chomp('/')}/#{session.mediamtx_path_name}"]
         end
 
         path = session.mediamtx_path_name
-        hls = session.mediamtx_internal_hls_url.chomp("/")
+        hls = ENV.fetch("MEDIAMTX_HLS_URL", "http://mediamtx:8888").chomp("/")
         [:hls, "#{hls}/#{path}/index.m3u8"]
       end
 
       def intake_available?(session)
         return true if Mediamtx::PublisherOnline.active?(session)
 
-        info = Mediamtx::Client.for_session(session).list_paths.find { |i| i["name"] == session.mediamtx_path_name }
+        info = Mediamtx::Client.new.list_paths.find { |i| i["name"] == session.mediamtx_path_name }
         info && (info["ready"] || info["online"] || info["available"])
       rescue StandardError
         false
@@ -229,22 +185,6 @@ module Streams
         format("youtube_relay:debounce:%s", session_id)
       end
 
-      def claim_ownership!(session_id)
-        redis.set(format(OWNER_KEY, session_id), worker_id, ex: 48.hours.to_i)
-        redis.sadd(format(OWNED_SET, worker_id), session_id)
-      end
-
-      def touch_owner!(session_id)
-        redis.expire(format(OWNER_KEY, session_id), 48.hours.to_i)
-        redis.expire(format(REDIS_KEY, session_id), 48.hours.to_i)
-      end
-
-      def clear_local_ownership(session_id)
-        redis.del(format(REDIS_KEY, session_id))
-        redis.del(format(OWNER_KEY, session_id))
-        redis.srem(format(OWNED_SET, worker_id), session_id)
-      end
-
       def store_pid(session_id, pid)
         redis.set(format(REDIS_KEY, session_id), pid, ex: 48.hours.to_i)
       end

backend/app/services/webhooks/mediamtx_handler.rb

@@ -68,13 +68,13 @@ module Webhooks
     def enable_recording(session)
       return unless session.match.team.entitlements.recording_enabled_for_mediamtx?
 
-      Mediamtx::Client.for_session(session).set_path_recording(session, enabled: true)
+      Mediamtx::Client.new.set_path_recording(session, enabled: true)
     rescue Mediamtx::Client::Error => e
       Rails.logger.warn("[MediamtxHandler] enable recording: #{e.message}")
     end
 
     def disable_recording(session)
-      Mediamtx::Client.for_session(session).set_path_recording(session, enabled: false)
+      Mediamtx::Client.new.set_path_recording(session, enabled: false)
     rescue Mediamtx::Client::Error => e
       Rails.logger.warn("[MediamtxHandler] disable recording: #{e.message}")
     end

backend/app/services/youtube/live_pipeline.rb

@@ -63,7 +63,7 @@ module Youtube
           return
         end
 
-        Mediamtx::Client.for_session(session).set_always_available(session, enabled: false)
+        Mediamtx::Client.new.set_always_available(session, enabled: false)
         session.go_live! if session.may_go_live?
         session.reconnect! if session.reconnecting? && session.may_reconnect?
 

backend/app/views/admin/stream_nodes/index.html.erb

@@ -1,83 +0,0 @@
-<% content_for :body_class, "admin-body" %>
-<h2><%= t("admin.stream_nodes.title") %></h2>
-<p class="admin-muted">
-  <%= t("admin.stream_nodes.providers", cloud: @cloud_provider, dns: @dns_provider) %>
-</p>
-
-<p class="admin-muted">
-  <%= t(
-        "admin.stream_nodes.autoscale",
-        enabled: (@autoscale_metrics[:enabled] ? "ON" : "OFF"),
-        free: @autoscale_metrics[:free_slots],
-        soft: @autoscale_metrics[:soft_free_slots],
-        spare: @autoscale_metrics[:spare_ready],
-        warm: @autoscale_metrics[:warm_spare_min],
-        overflow: @autoscale_metrics[:overflow_nodes],
-        max: @autoscale_metrics[:max_overflow_nodes],
-        kind: @autoscale_metrics[:kind]
-      ) %>
-  · <%= t(
-        "admin.stream_nodes.autoscale_budget",
-        eur: @autoscale_metrics[:estimated_monthly_eur],
-        budget: @autoscale_metrics[:monthly_budget_eur],
-        ok: (@autoscale_metrics[:within_budget] ? "OK" : "OVER")
-      ) %>
-  <% if @autoscale_metrics[:kill_switch] %>
-    · <strong><%= t("admin.stream_nodes.kill_switch_active") %></strong>
-  <% end %>
-</p>
-
-<p>
-  <%= button_to t("admin.stream_nodes.provision_lab"), admin_stream_nodes_path, method: :post, params: { kind: "lab" }, class: "admin-btn" %>
-  <% if @hetzner_configured %>
-    <%= button_to t("admin.stream_nodes.provision_cloud"), admin_stream_nodes_path, method: :post, params: { kind: "cloud" }, class: "admin-btn",
-          form: { data: { confirm: t("admin.stream_nodes.provision_cloud_confirm") } } %>
-  <% else %>
-    <span class="admin-muted"><%= t("admin.stream_nodes.hetzner_token_missing") %></span>
-  <% end %>
-  <% if @autoscale_metrics[:kill_switch] %>
-    <%= button_to t("admin.stream_nodes.clear_kill_switch"), clear_kill_switch_admin_stream_nodes_path, method: :delete, class: "admin-btn admin-btn-secondary" %>
-  <% else %>
-    <%= button_to t("admin.stream_nodes.engage_kill_switch"), kill_switch_admin_stream_nodes_path, method: :post, class: "admin-btn admin-btn-danger",
-          form: { data: { confirm: t("admin.stream_nodes.kill_switch_confirm") } } %>
-  <% end %>
-</p>
-
-<table class="admin-table">
-  <thead>
-    <tr>
-      <th><%= t("admin.stream_nodes.col.slug") %></th>
-      <th><%= t("admin.stream_nodes.col.role") %></th>
-      <th><%= t("admin.stream_nodes.col.status") %></th>
-      <th><%= t("admin.stream_nodes.col.slots") %></th>
-      <th><%= t("admin.stream_nodes.col.hostname") %></th>
-      <th><%= t("admin.stream_nodes.col.provider") %></th>
-      <th></th>
-    </tr>
-  </thead>
-  <tbody>
-    <% @nodes.each do |node| %>
-      <tr>
-        <td><code><%= node.slug %></code></td>
-        <td><%= node.role %></td>
-        <td><%= node.status %></td>
-        <td><%= node.active_publishers %> / <%= node.max_publishers %> (free <%= node.free_slots %>)</td>
-        <td><code><%= node.hostname %></code></td>
-        <td><%= node.provider %><% if node.provider_instance_id.present? %> · <%= node.provider_instance_id %><% end %></td>
-        <td class="admin-actions">
-          <% if node.slug != "home" %>
-            <% if node.status == "ready" %>
-              <%= button_to t("admin.stream_nodes.drain"), drain_admin_stream_node_path(node), method: :post, class: "admin-btn admin-btn-secondary" %>
-            <% end %>
-            <%= button_to t("admin.stream_nodes.destroy"), admin_stream_node_path(node), method: :delete, class: "admin-btn admin-btn-danger", form: { data: { confirm: t("admin.stream_nodes.destroy_confirm", slug: node.slug) } } %>
-          <% end %>
-        </td>
-      </tr>
-    <% end %>
-  </tbody>
-</table>
-
-<% if @lab_hosts.present? %>
-  <h3><%= t("admin.stream_nodes.hosts_title") %></h3>
-  <pre class="admin-pre"><%= @lab_hosts %></pre>
-<% end %>

backend/app/views/layouts/admin.html.erb

@@ -29,7 +29,6 @@
         <%= link_to t("admin.layout.nav.billing"), admin_billing_path, class: ("active" if controller_name.in?(%w[billing billing_invoices])) %>
         <%= link_to t("admin.layout.nav.youtube"), admin_youtube_platform_path, class: ("active" if controller_name == "youtube") %>
         <%= link_to t("admin.layout.nav.sessions"), admin_sessions_path, class: ("active" if controller_name == "sessions") %>
-        <%= link_to t("admin.layout.nav.stream_nodes"), admin_stream_nodes_path, class: ("active" if controller_name == "stream_nodes") %>
         <%= link_to t("admin.layout.nav.password"), edit_admin_password_path %>
         <%= button_to t("admin.layout.nav.logout"), admin_logout_path, method: :delete %>
       <% end %>

backend/app/views/layouts/marketing.html.erb

@@ -12,13 +12,13 @@
   </head>
   <body data-confirm-i18n='<%= raw confirm_dialog_i18n_json %>'<% if MatchLiveTv.google_analytics_configured? %> data-ga-id="<%= MatchLiveTv.google_analytics_measurement_id %>"<% end %>>
     <%= render "shared/cookie_banner" %>
-    <%= render "shared/marketing_nav" %>
+    <%= render(@app_store_review_chrome ? "shared/marketing_nav_app_store" : "shared/marketing_nav") %>
     <main>
       <% if flash[:notice] %><div class="wrap"><div class="flash notice"><%= flash[:notice] %></div></div><% end %>
       <% if flash[:alert] %><div class="wrap"><div class="flash alert"><%= flash[:alert] %></div></div><% end %>
       <%= yield %>
     </main>
-    <%= render "shared/marketing_footer" %>
+    <%= render(@app_store_review_chrome ? "shared/marketing_footer_app_store" : "shared/marketing_footer") %>
     <script src="/branding-form.js?v=1" defer></script>
     <script src="/roster-form.js?v=1" defer></script>
     <script src="/password-toggle.js?v=2" defer></script>

backend/app/views/layouts/regia.html.erb

@@ -7,7 +7,7 @@
     <meta name="theme-color" content="#0a0a0e">
     <title><%= content_for?(:title) ? yield(:title) : t("regia.meta_title_fallback") %></title>
     <%= render "shared/meta_tags" %>
-    <link rel="stylesheet" href="/regia.css?v=1">
+    <link rel="stylesheet" href="/regia.css?v=11">
     <%= yield :head %>
   </head>
   <body class="regia-body">

backend/app/views/public/pages/support.html.erb

@@ -0,0 +1,38 @@
+<% content_for :title, t("legal.support.title") %>
+<% content_for :meta_description, t("legal.support.meta_description") %>
+<% content_for :canonical_url, seo_absolute_url(public_support_path) %>
+
+<div class="wrap legal-doc">
+  <h1><%= t("legal.support.h1") %></h1>
+  <p><%= t("legal.support.intro") %></p>
+
+  <p>
+    <%= t("legal.support.email_label") %>
+    <a href="mailto:<%= MatchLiveTv.support_email %>"><%= MatchLiveTv.support_email %></a>
+  </p>
+
+  <section>
+    <h2><%= t("legal.support.access_title") %></h2>
+    <p><%= t("legal.support.access_body") %></p>
+  </section>
+
+  <section>
+    <h2><%= t("legal.support.live_title") %></h2>
+    <p><%= t("legal.support.live_body") %></p>
+  </section>
+
+  <section>
+    <h2><%= t("legal.support.team_title") %></h2>
+    <p><%= t("legal.support.team_body") %></p>
+  </section>
+
+  <section>
+    <h2><%= t("legal.support.privacy_title") %></h2>
+    <p>
+      <%= raw t(
+        "legal.support.privacy_body_html",
+        privacy_link: link_to(t("legal.support.privacy_link_text"), public_privacy_path)
+      ) %>
+    </p>
+  </section>
+</div>

backend/app/views/public/regia/_volley.html.erb

@@ -21,4 +21,4 @@
     <button type="button" class="regia-btn regia-btn--minus" data-action="away_undo" style="width:100%;margin-top:6px">−</button>
   </div>
 </div>
-<button type="button" class="regia-btn regia-btn--yellow" data-action="close_set" style="margin-top:12px"><%= t("regia.board.close_set") %></button>
+<button type="button" class="regia-btn regia-btn--yellow" data-action="close_set"><%= t("regia.board.close_set") %></button>

backend/app/views/public/regia/show.html.erb

@@ -16,6 +16,8 @@
      data-pause-url="<%= j public_regia_pause_path(params[:token]) %>"
      data-resume-url="<%= j public_regia_resume_path(params[:token]) %>"
      data-stop-url="<%= j public_regia_stop_path(params[:token]) %>"
+     data-min-quality-url="<%= j public_regia_min_quality_path(params[:token]) %>"
+     data-min-quality="<%= j @session.min_quality_preset %>"
      data-cable-url="<%= j "/cable?regia_token=#{params[:token]}" %>"
      data-hls-url="<%= j @session.hls_playback_url %>"
      data-home-name="<%= j @team.name %>"
@@ -29,40 +31,62 @@
      data-initial-paused="<%= @session.paused? %>">
 
   <header class="regia-header">
+    <div class="regia-header__text">
       <h1><%= @team.name %> vs <%= @match.opponent_name %></h1>
       <p id="regia-subtitle"><%= t("regia.subtitle_prefix") %> <%= regia_header_subtitle(@match, @score) %></p>
+    </div>
     <span id="regia-badge" class="regia-badge <%= @stream_closed ? 'regia-badge--ended' : (@session.paused? ? 'regia-badge--wait' : (@on_air ? 'regia-badge--live' : 'regia-badge--wait')) %>">
       <%= @stream_closed ? t("regia.status.ended") : (@session.paused? ? t("regia.status.paused") : (@on_air ? t("regia.status.live") : t("regia.status.waiting"))) %>
     </span>
   </header>
 
+  <nav class="regia-toolbar" aria-label="<%= t("regia.links_nav") %>">
     <% if @live_share_url.present? %>
-    <div class="regia-share-group">
+      <div class="regia-tool-group" role="group" aria-label="<%= t("regia.live_share_label") %>">
-      <p class="regia-share-label"><%= t("regia.live_share_label") %></p>
+        <span class="regia-tool-group__label"><%= t("regia.live_share_label") %></span>
-      <div class="regia-share">
+        <div class="regia-tool-group__btns">
-        <button type="button" class="regia-btn regia-btn--outline" id="btn-share-live" style="margin:0">
+          <button type="button" class="regia-icon-btn" id="btn-share-live" aria-label="<%= t("regia.share_live") %>" title="<%= t("regia.share_live") %>">
-          <%= t("regia.share_live") %>
+            <svg class="icon-outline" viewBox="0 0 24 24" aria-hidden="true"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><line x1="8.59" y1="13.51" x2="15.42" y2="17.49"/><line x1="15.41" y1="6.51" x2="8.59" y2="10.49"/></svg>
           </button>
-        <button type="button" class="regia-btn regia-btn--outline" id="btn-copy-live" style="margin:0">
+          <button type="button" class="regia-icon-btn" id="btn-copy-live" aria-label="<%= t("regia.copy_live") %>" title="<%= t("regia.copy_live") %>">
-          <%= t("regia.copy_link") %>
+            <svg class="icon-outline" viewBox="0 0 24 24" aria-hidden="true"><rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg>
           </button>
         </div>
       </div>
     <% end %>
-
+    <div class="regia-tool-group" role="group" aria-label="<%= t("regia.regia_share_label") %>">
-  <div class="regia-share-group">
+      <span class="regia-tool-group__label"><%= t("regia.regia_share_label") %></span>
-    <p class="regia-share-label"><%= t("regia.regia_share_label") %></p>
+      <div class="regia-tool-group__btns">
-    <div class="regia-share">
+        <button type="button" class="regia-icon-btn" id="btn-share-regia" aria-label="<%= t("regia.share_regia") %>" title="<%= t("regia.share_regia") %>">
-      <button type="button" class="regia-btn regia-btn--outline" id="btn-share-regia" style="margin:0">
+          <svg class="icon-outline" viewBox="0 0 24 24" aria-hidden="true"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><line x1="8.59" y1="13.51" x2="15.42" y2="17.49"/><line x1="15.41" y1="6.51" x2="8.59" y2="10.49"/></svg>
-        <%= t("regia.share_regia") %>
         </button>
-      <button type="button" class="regia-btn regia-btn--outline" id="btn-copy-regia" style="margin:0">
+        <button type="button" class="regia-icon-btn" id="btn-copy-regia" aria-label="<%= t("regia.copy_regia") %>" title="<%= t("regia.copy_regia") %>">
-        <%= t("regia.copy_link") %>
+          <svg class="icon-outline" viewBox="0 0 24 24" aria-hidden="true"><rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg>
         </button>
       </div>
     </div>
+    <% unless @stream_closed %>
+      <div class="regia-tool-group regia-tool-group--stream" role="group" aria-label="<%= t("regia.stream_controls_label") %>">
+        <span class="regia-tool-group__label" aria-hidden="true">&nbsp;</span>
+        <div class="regia-tool-group__btns">
+          <button type="button" class="regia-icon-btn" id="btn-toggle-preview" aria-label="<%= t("regia.preview_hide") %>" title="<%= t("regia.preview_hide") %>" aria-pressed="true">
+            <svg class="icon-fill icon-eye" viewBox="0 0 24 24" aria-hidden="true"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"/></svg>
+            <svg class="icon-fill icon-eye-off" viewBox="0 0 24 24" aria-hidden="true"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78 3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"/></svg>
+          </button>
+          <button type="button" class="regia-icon-btn<%= " is-paused" if @session.paused? %>" id="btn-pause" aria-label="<%= @session.paused? ? t("regia.resume") : t("regia.pause") %>" title="<%= @session.paused? ? t("regia.resume") : t("regia.pause") %>">
+            <svg class="icon-fill icon-pause" viewBox="0 0 24 24" aria-hidden="true"><path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/></svg>
+            <svg class="icon-fill icon-play" viewBox="0 0 24 24" aria-hidden="true"><path d="M8 5v14l11-7z"/></svg>
+          </button>
+          <button type="button" class="regia-icon-btn regia-icon-btn--danger" id="btn-stop" aria-label="<%= t("regia.stop") %>" title="<%= t("regia.stop") %>">
+            <svg class="icon-fill" viewBox="0 0 24 24" aria-hidden="true"><path d="M6 6h12v12H6z"/></svg>
+          </button>
+        </div>
+      </div>
+    <% end %>
+  </nav>
 
-  <div class="regia-preview">
+  <section class="regia-preview-wrap" id="regia-preview-wrap">
+    <div class="regia-preview" id="regia-preview-box">
       <% unless @stream_closed %>
         <video id="regia-preview" playsinline muted autoplay></video>
       <% end %>
@@ -70,14 +94,55 @@
         <%= @stream_closed ? t("regia.preview_ended") : t("regia.preview_waiting") %>
       </div>
     </div>
+  </section>
 
   <section class="regia-scoreboard">
     <%= render regia_board_partial(@match) %>
   </section>
 
   <% unless @stream_closed %>
-    <button type="button" class="regia-btn regia-btn--outline" id="btn-pause"><%= @session.paused? ? t("regia.resume") : t("regia.pause") %></button>
+    <section class="regia-telemetry" id="regia-telemetry" aria-label="<%= t("regia.telemetry.label") %>">
-    <button type="button" class="regia-btn regia-btn--danger" id="btn-stop"><%= t("regia.stop") %></button>
+      <div class="regia-telemetry__row">
+        <span class="regia-chip" id="tel-battery" title="<%= t("regia.telemetry.battery") %>">
+          <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M16 4h-1V3h-6v1H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H8V6h8v14z"/></svg>
+          <span class="regia-chip__label"><%= t("regia.telemetry.battery") %></span>
+          <span class="regia-chip__value">—</span>
+        </span>
+        <span class="regia-chip" id="tel-network" title="<%= t("regia.telemetry.network") %>">
+          <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M1 9l2 2c4.97-4.97 13.03-4.97 18 0l2-2C16.93 2.93 7.08 2.93 1 9zm8 8l3 3 3-3c-1.65-1.66-4.34-1.66-6 0zm-4-4l2 2c2.76-2.76 7.24-2.76 10 0l2-2C15.14 9.14 8.87 9.14 5 13z"/></svg>
+          <span class="regia-chip__label"><%= t("regia.telemetry.network") %></span>
+          <span class="regia-chip__value">—</span>
+        </span>
+        <button type="button" class="regia-chip regia-chip--action" id="tel-bitrate" aria-expanded="false" aria-controls="regia-quality" title="<%= t("regia.telemetry.bitrate_tap") %>">
+          <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M3 13h2v-2H3v2zm4 4h2v-6H7v6zm4 4h2V7h-2v14zm4-8h2V9h-2v4zm4-4h2V5h-2v4z"/></svg>
+          <span class="regia-chip__label"><%= t("regia.telemetry.bitrate") %></span>
+          <span class="regia-chip__value">—</span>
+          <span class="regia-chip__hint" hidden></span>
+        </button>
+        <span class="regia-chip" id="tel-fps" title="<%= t("regia.telemetry.fps") %>">
+          <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M17 10.5V7c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1v10c0 .55.45 1 1 1h12c.55 0 1-.45 1-1v-3.5l4 4v-11l-4 4z"/></svg>
+          <span class="regia-chip__label"><%= t("regia.telemetry.fps") %></span>
+          <span class="regia-chip__value">—</span>
+        </span>
+        <span class="regia-chip" id="tel-thermal" title="<%= t("regia.telemetry.thermal") %>">
+          <svg viewBox="0 0 24 24" aria-hidden="true"><path d="M15 13V5c0-1.66-1.34-3-3-3S9 3.34 9 5v8c-1.21.91-2 2.37-2 4 0 2.76 2.24 5 5 5s5-2.24 5-5c0-1.63-.79-3.09-2-4zm-3 8c-1.66 0-3-1.34-3-3 0-1.19.7-2.23 1.71-2.72L11 14.73V5c0-.55.45-1 1-1s1 .45 1 1v9.73l.29.18C14.3 15.77 15 16.81 15 18c0 1.66-1.34 3-3 3z"/></svg>
+          <span class="regia-chip__label"><%= t("regia.telemetry.thermal") %></span>
+          <span class="regia-chip__value">—</span>
+        </span>
+      </div>
+      <div class="regia-quality" id="regia-quality" hidden>
+        <p class="regia-quality__hint"><%= t("regia.min_quality.recommend") %></p>
+        <label for="min-quality"><%= t("regia.min_quality.label") %></label>
+        <select id="min-quality" title="<%= t("regia.min_quality.hint") %>">
+          <% Sessions::SelectQuality.allowed_min_ids(@session.quality_preset).each do |id| %>
+            <option value="<%= id %>" <%= "selected" if @session.min_quality_preset == id %>>
+              <%= id == Sessions::SelectQuality::AUTO_ID ? t("regia.min_quality.auto") : Sessions::SelectQuality.display_name(id) %>
+            </option>
+          <% end %>
+        </select>
+      </div>
+      <p class="regia-telemetry__meta" id="tel-meta"><%= t("regia.telemetry.waiting") %></p>
+    </section>
   <% end %>
 </div>
 
@@ -94,4 +159,4 @@
   </div>
 </div>
 
-<script src="/regia.js?v=8"></script>
+<script src="/regia.js?v=18"></script>

backend/app/views/shared/_marketing_footer.html.erb

@@ -4,6 +4,7 @@
       <strong style="color:#fff">Match Live TV</strong> — <%= t("footer.tagline") %>
     </div>
     <div>
+      <%= link_to t("common.support"), public_support_path %> ·
       <%= link_to t("common.pricing"), public_prezzi_path %> ·
       <%= link_to t("footer.live"), public_live_index_path %> ·
       <%= link_to t("common.faq"), public_faq_path %> ·

backend/app/views/shared/_marketing_footer_app_store.html.erb

@@ -0,0 +1,19 @@
+<%# Footer minimale per App Store Review: solo link legali/supporto, nessun CTA commerciale. %>
+<footer class="site-footer">
+  <div class="wrap">
+    <div>
+      <strong style="color:#fff">Match Live TV</strong> — <%= t("footer.tagline") %>
+    </div>
+    <div>
+      <%= link_to t("common.support"), public_support_path %> ·
+      <%= link_to t("common.privacy"), public_privacy_path %> ·
+      <%= link_to t("common.cookies"), public_cookies_path %> ·
+      <%= link_to t("common.terms"), public_termini_path %>
+      · <button type="button" class="footer-link-btn" data-cookie-manage><%= t("footer.manage_cookies") %></button>
+    </div>
+    <div class="site-footer__legal">
+      <p><%= t("footer.copyright") %></p>
+      <p><%= t("footer.responsibility") %></p>
+    </div>
+  </div>
+</footer>

backend/app/views/shared/_marketing_nav_app_store.html.erb

@@ -0,0 +1,86 @@
+<%# Chrome minimale per App Store Review: branding, lingua, Privacy e Supporto — senza CTA commerciali. %>
+<div class="site-chrome">
+  <div class="site-masthead">
+    <div class="wrap mast-inner">
+      <%= link_to public_support_path, class: "mast-brand", aria: { label: "Match Live TV" }, title: "Match Live TV" do %>
+        <img class="mast-brand-logo" src="/logo.png?v=3" alt="Match Live TV" width="40" height="40" decoding="async">
+        <span class="brand" aria-hidden="true">Match <span>Live TV</span></span>
+      <% end %>
+
+      <div class="mast-tools">
+        <button type="button" class="nav-toggle" aria-label="<%= t('nav.open_menu') %>" aria-expanded="false" aria-controls="site-nav">
+          <span class="nav-toggle-bar" aria-hidden="true"></span>
+          <span class="nav-toggle-bar" aria-hidden="true"></span>
+          <span class="nav-toggle-bar" aria-hidden="true"></span>
+        </button>
+      </div>
+    </div>
+  </div>
+
+  <nav id="site-nav" class="nav" aria-label="<%= t('nav.main_menu') %>" aria-hidden="true">
+    <div class="nav-panel">
+      <div class="nav-mobile-head">
+        <%= link_to public_support_path, class: "nav-mobile-brand", aria: { label: "Match Live TV" }, title: "Match Live TV" do %>
+          <img class="nav-mobile-brand-logo" src="/logo.png?v=3" alt="" width="40" height="40" decoding="async">
+          <span class="brand">Match <span>Live TV</span></span>
+        <% end %>
+        <div class="nav-lang">
+          <%= render "shared/language_switcher" %>
+        </div>
+      </div>
+      <%= link_to t("common.support"), public_support_path, class: "nav-active" %>
+      <%= link_to t("common.privacy"), public_privacy_path, class: (request.path == "/privacy" ? "nav-active" : nil) %>
+    </div>
+  </nav>
+</div>
+
+<div class="nav-backdrop" id="nav-backdrop" aria-hidden="true"></div>
+
+<script>
+(function () {
+  var chrome = document.querySelector(".site-chrome");
+  var toggle = document.querySelector(".nav-toggle");
+  var backdrop = document.getElementById("nav-backdrop");
+  var nav = document.getElementById("site-nav");
+  if (!chrome || !toggle || !nav) return;
+  var openLabel = <%= raw t("nav.open_menu").to_json %>;
+  var closeLabel = <%= raw t("nav.close_menu").to_json %>;
+
+  function setOpen(open) {
+    chrome.classList.toggle("nav-open", open);
+    document.body.classList.toggle("nav-menu-open", open);
+    toggle.setAttribute("aria-expanded", open ? "true" : "false");
+    toggle.setAttribute("aria-label", open ? closeLabel : openLabel);
+    nav.setAttribute("aria-hidden", open ? "false" : "true");
+    if (backdrop) backdrop.setAttribute("aria-hidden", open ? "false" : "true");
+  }
+
+  function closeMenu() { setOpen(false); }
+
+  toggle.addEventListener("click", function (e) {
+    e.stopPropagation();
+    document.body.classList.contains("nav-menu-open") ? closeMenu() : setOpen(true);
+  });
+
+  if (backdrop) backdrop.addEventListener("click", closeMenu);
+
+  function shouldCloseNavOnControl(el) {
+    if (!el.closest("[data-lang-switcher]")) return true;
+    return el.classList.contains("lang-switcher__option");
+  }
+
+  nav.querySelectorAll("a, button").forEach(function (el) {
+    el.addEventListener("click", function () {
+      if (shouldCloseNavOnControl(el)) closeMenu();
+    });
+  });
+
+  window.addEventListener("resize", function () {
+    if (window.matchMedia("(min-width: 900px)").matches) closeMenu();
+  });
+
+  document.addEventListener("keydown", function (e) {
+    if (e.key === "Escape") closeMenu();
+  });
+})();
+</script>

backend/config/environments/development.rb

@@ -62,8 +62,8 @@ Rails.application.configure do
   # Annotate rendered view with file names.
   config.action_view.annotate_rendered_view_with_filenames = true
 
-  # Uncomment if you wish to allow Action Cable access from any origin.
+  # Permette Action Cable dall'emulatore Android (10.0.2.2) e da altri host locali.
-  # config.action_cable.disable_request_forgery_protection = true
+  config.action_cable.disable_request_forgery_protection = true
 
   # Raise error when a before_action's only/except options reference missing actions.
   config.action_controller.raise_on_missing_callback_actions = true

backend/config/initializers/match_live_tv.rb

@@ -81,6 +81,12 @@ module MatchLiveTv
       ENV.fetch("PRIVACY_CONTACT_EMAIL", "privacy@matchlivetv.it")
     end
 
+    # Email di supporto (App Store Support URL e contatti assistenza).
+    # Preferisce SUPPORT_CONTACT_EMAIL; default = contatto commerciale già usato nel sito.
+    def support_email
+      ENV["SUPPORT_CONTACT_EMAIL"].presence || "info@matchlivetv.it"
+    end
+
     def privacy_controller_address
       ENV.fetch("PRIVACY_CONTROLLER_ADDRESS", "Via Guido De Ruggiero, 89 - 20142 - Milano (MI)")
     end

backend/config/initializers/sidekiq.rb

@@ -6,7 +6,6 @@ Sidekiq.configure_server do |config|
   config.on(:startup) do
     StreamPublisherSyncJob.ensure_chain
     Ops::HealthMonitorJob.ensure_chain
-    Streams::AutoscalerJob.ensure_chain
   end
 end
 

backend/config/locales/admin.de.yml

@@ -9,7 +9,6 @@ de:
         billing: Abrechnung
         youtube: YouTube
         sessions: Sitzungen
-        stream_nodes: Stream-Knoten
         password: Passwort
         logout: Abmelden
     flash:
@@ -27,11 +26,6 @@ de:
       ops_acknowledged: Vorfall übernommen
       ops_resolved: Vorfall gelöst
       ops_muted: Benachrichtigungen für 24 Stunden stummgeschaltet
-      stream_node_created: "Lab-Knoten %{slug} bereitgestellt."
-      stream_node_destroyed: "Knoten %{slug} entfernt."
-      stream_node_draining: "Knoten %{slug} im Drain-Modus."
-      autoscale_kill_on: "Autoscaler-Kill-Switch aktiv. Kein automatisches Scale-out."
-      autoscale_kill_off: "Autoscaler-Kill-Switch aus (STREAM_AUTOSCALE_ENABLED=1 weiterhin nötig)."
       comped_granted: "Kostenloses Abonnement %{plan} für %{club} aktiviert."
       comped_revoked: "Kostenloses Abonnement für %{club} widerrufen."
       session_already_terminated: "Sitzung bereits beendet (%{status})."
@@ -117,27 +111,6 @@ de:
         title: Teams
         matches_count: "%{count} Spiele"
         view_all: "Vereine ansehen (%{count} Teams)"
-    stream_nodes:
-      title: Stream-Knoten
-      providers: "Cloud-Provider: %{cloud} · DNS-Provider: %{dns}"
-      autoscale: "Autoscaler %{enabled} · free_slots=%{free} (soft≤%{soft}) · spare=%{spare}/%{warm} · overflow=%{overflow}/%{max} · kind=%{kind}"
-      autoscale_budget: "Budget €%{eur}/€%{budget} (%{ok})"
-      kill_switch_active: "KILL-SWITCH AKTIV"
-      engage_kill_switch: "Kill-switch ON"
-      clear_kill_switch: "Kill-switch OFF"
-      kill_switch_confirm: "Autoscaler sofort blockieren?"
-      provision_lab: Lab-Knoten bereitstellen
-      drain: Drain
-      destroy: Löschen
-      destroy_confirm: "Knoten %{slug} löschen?"
-      hosts_title: Lab-DNS (/etc/hosts)
-      col:
-        slug: Slug
-        role: Rolle
-        status: Status
-        slots: Slots
-        hostname: Hostname
-        provider: Provider
     ops:
       kpi:
         critical: Kritisch offen

backend/config/locales/admin.en.yml

@@ -9,7 +9,6 @@ en:
         billing: Billing
         youtube: YouTube
         sessions: Sessions
-        stream_nodes: Stream nodes
         password: Password
         logout: Log out
     flash:
@@ -27,11 +26,6 @@ en:
       ops_acknowledged: Incident acknowledged
       ops_resolved: Incident resolved
       ops_muted: Notifications muted for 24 hours
-      stream_node_created: "Lab node %{slug} provisioned."
-      stream_node_destroyed: "Node %{slug} removed."
-      stream_node_draining: "Node %{slug} is draining (no new sessions)."
-      autoscale_kill_on: "Autoscaler kill-switch engaged. No automatic scale-out."
-      autoscale_kill_off: "Autoscaler kill-switch cleared (still needs STREAM_AUTOSCALE_ENABLED=1)."
       comped_granted: "%{plan} complimentary subscription activated for %{club}."
       comped_revoked: "Complimentary subscription revoked for %{club}."
       session_already_terminated: "Session already ended (%{status})."
@@ -117,30 +111,6 @@ en:
         title: Teams
         matches_count: "%{count} matches"
         view_all: "View clubs (%{count} teams)"
-    stream_nodes:
-      title: Streaming nodes
-      providers: "Cloud provider: %{cloud} · DNS provider: %{dns}"
-      autoscale: "Autoscaler %{enabled} · free_slots=%{free} (soft≤%{soft}) · spare=%{spare}/%{warm} · overflow=%{overflow}/%{max} · kind=%{kind}"
-      autoscale_budget: "budget €%{eur}/€%{budget} (%{ok})"
-      kill_switch_active: "KILL-SWITCH ACTIVE"
-      engage_kill_switch: "Kill-switch ON (block autoscaler)"
-      clear_kill_switch: "Kill-switch OFF"
-      kill_switch_confirm: "Immediately block the autoscaler? Existing nodes stay up."
-      provision_lab: Provision lab node
-      provision_cloud: Provision Hetzner node
-      provision_cloud_confirm: "Create a Hetzner Cloud server + DNS record on mltv-stream.net? Billing applies until destroyed."
-      hetzner_token_missing: "Set HCLOUD_TOKEN to enable Cloud provisioning."
-      drain: Drain
-      destroy: Delete
-      destroy_confirm: "Delete node %{slug}?"
-      hosts_title: Lab DNS records (/etc/hosts snippet)
-      col:
-        slug: Slug
-        role: Role
-        status: Status
-        slots: Slots
-        hostname: Hostname
-        provider: Provider
     ops:
       kpi:
         critical: Critical open

backend/config/locales/admin.es.yml

@@ -9,7 +9,6 @@ es:
         billing: Facturación
         youtube: YouTube
         sessions: Sesiones
-        stream_nodes: Nodos stream
         password: Contraseña
         logout: Salir
     flash:
@@ -27,11 +26,6 @@ es:
       ops_acknowledged: Incidencia asumida
       ops_resolved: Incidencia resuelta
       ops_muted: Notificaciones silenciadas durante 24 horas
-      stream_node_created: "Nodo lab %{slug} provisionado."
-      stream_node_destroyed: "Nodo %{slug} eliminado."
-      stream_node_draining: "Nodo %{slug} en drain."
-      autoscale_kill_on: "Kill-switch del autoscaler activado. Sin scale-out automático."
-      autoscale_kill_off: "Kill-switch del autoscaler desactivado (hace falta STREAM_AUTOSCALE_ENABLED=1)."
       comped_granted: "Suscripción de cortesía %{plan} activada para %{club}."
       comped_revoked: "Suscripción de cortesía revocada para %{club}."
       session_already_terminated: "La sesión ya ha finalizado (%{status})."
@@ -117,27 +111,6 @@ es:
         title: Equipos
         matches_count: "%{count} partidos"
         view_all: "Ver clubes (%{count} equipos)"
-    stream_nodes:
-      title: Nodos streaming
-      providers: "Cloud provider: %{cloud} · DNS provider: %{dns}"
-      autoscale: "Autoscaler %{enabled} · free_slots=%{free} (soft≤%{soft}) · spare=%{spare}/%{warm} · overflow=%{overflow}/%{max} · kind=%{kind}"
-      autoscale_budget: "presupuesto €%{eur}/€%{budget} (%{ok})"
-      kill_switch_active: "KILL-SWITCH ACTIVO"
-      engage_kill_switch: "Kill-switch ON"
-      clear_kill_switch: "Kill-switch OFF"
-      kill_switch_confirm: "¿Bloquear el autoscaler inmediatamente?"
-      provision_lab: Provisionar nodo lab
-      drain: Drain
-      destroy: Eliminar
-      destroy_confirm: "¿Eliminar el nodo %{slug}?"
-      hosts_title: DNS lab (/etc/hosts)
-      col:
-        slug: Slug
-        role: Rol
-        status: Estado
-        slots: Slots
-        hostname: Hostname
-        provider: Provider
     ops:
       kpi:
         critical: Críticas abiertas

backend/config/locales/admin.fr.yml

@@ -9,7 +9,6 @@ fr:
         billing: Facturation
         youtube: YouTube
         sessions: Sessions
-        stream_nodes: Nœuds stream
         password: Mot de passe
         logout: Déconnexion
     flash:
@@ -27,11 +26,6 @@ fr:
       ops_acknowledged: Incident pris en charge
       ops_resolved: Incident résolu
       ops_muted: Notifications suspendues pendant 24 heures
-      stream_node_created: "Nœud lab %{slug} provisionné."
-      stream_node_destroyed: "Nœud %{slug} supprimé."
-      stream_node_draining: "Nœud %{slug} en drain."
-      autoscale_kill_on: "Kill-switch autoscaler activé. Pas de scale-out automatique."
-      autoscale_kill_off: "Kill-switch autoscaler désactivé (nécessite aussi STREAM_AUTOSCALE_ENABLED=1)."
       comped_granted: "Abonnement offert %{plan} activé pour %{club}."
       comped_revoked: "Abonnement offert révoqué pour %{club}."
       session_already_terminated: "Session déjà terminée (%{status})."
@@ -117,27 +111,6 @@ fr:
         title: Équipes
         matches_count: "%{count} matchs"
         view_all: "Voir les clubs (%{count} équipes)"
-    stream_nodes:
-      title: Nœuds streaming
-      providers: "Cloud provider: %{cloud} · DNS provider: %{dns}"
-      autoscale: "Autoscaler %{enabled} · free_slots=%{free} (soft≤%{soft}) · spare=%{spare}/%{warm} · overflow=%{overflow}/%{max} · kind=%{kind}"
-      autoscale_budget: "budget €%{eur}/€%{budget} (%{ok})"
-      kill_switch_active: "KILL-SWITCH ACTIF"
-      engage_kill_switch: "Kill-switch ON"
-      clear_kill_switch: "Kill-switch OFF"
-      kill_switch_confirm: "Bloquer immédiatement l'autoscaler ?"
-      provision_lab: Provisionner un nœud lab
-      drain: Drain
-      destroy: Supprimer
-      destroy_confirm: "Supprimer le nœud %{slug} ?"
-      hosts_title: DNS lab (/etc/hosts)
-      col:
-        slug: Slug
-        role: Rôle
-        status: Statut
-        slots: Slots
-        hostname: Hostname
-        provider: Provider
     ops:
       kpi:
         critical: Critiques ouverts

backend/config/locales/admin.it.yml

@@ -9,7 +9,6 @@ it:
         billing: Fatturazione
         youtube: YouTube
         sessions: Sessioni
-        stream_nodes: Nodi stream
         password: Password
         logout: Esci
     flash:
@@ -27,11 +26,6 @@ it:
       ops_acknowledged: Incidente preso in carico
       ops_resolved: Incidente risolto
       ops_muted: Notifiche sospese per 24 ore
-      stream_node_created: "Nodo lab %{slug} provisionato."
-      stream_node_destroyed: "Nodo %{slug} rimosso."
-      stream_node_draining: "Nodo %{slug} in drain (niente nuove sessioni)."
-      autoscale_kill_on: "Kill-switch autoscaler attivato. Nessun scale-out automatico."
-      autoscale_kill_off: "Kill-switch autoscaler disattivato (serve comunque STREAM_AUTOSCALE_ENABLED=1)."
       comped_granted: "Abbonamento omaggio %{plan} attivato per %{club}."
       comped_revoked: "Abbonamento omaggio revocato per %{club}."
       session_already_terminated: "Sessione già terminata (%{status})."
@@ -117,30 +111,6 @@ it:
         title: Squadre
         matches_count: "%{count} partite"
         view_all: "Vedi società (%{count} squadre)"
-    stream_nodes:
-      title: Nodi streaming
-      providers: "Cloud provider: %{cloud} · DNS provider: %{dns}"
-      autoscale: "Autoscaler %{enabled} · free_slots=%{free} (soft≤%{soft}) · spare=%{spare}/%{warm} · overflow=%{overflow}/%{max} · kind=%{kind}"
-      autoscale_budget: "budget €%{eur}/€%{budget} (%{ok})"
-      kill_switch_active: "KILL-SWITCH ATTIVO"
-      engage_kill_switch: "Kill-switch ON (blocca autoscaler)"
-      clear_kill_switch: "Kill-switch OFF"
-      kill_switch_confirm: "Bloccare immediatamente l'autoscaler? I nodi esistenti restano accesi."
-      provision_lab: Provisiona nodo lab
-      provision_cloud: Provisiona nodo Hetzner
-      provision_cloud_confirm: "Creare un server Hetzner Cloud + record DNS su mltv-stream.net? Verrà addebitato fino allo spegnimento."
-      hetzner_token_missing: "Imposta HCLOUD_TOKEN per abilitare il provisioning Cloud."
-      drain: Drain
-      destroy: Elimina
-      destroy_confirm: "Eliminare il nodo %{slug}?"
-      hosts_title: Record DNS lab (snippet /etc/hosts)
-      col:
-        slug: Slug
-        role: Ruolo
-        status: Stato
-        slots: Slot
-        hostname: Hostname
-        provider: Provider
     ops:
       kpi:
         critical: Critici aperti

backend/config/locales/app.de.yml

@@ -432,16 +432,51 @@ de:
       paused: Pausiert
       live: Live
       waiting: Wartet
-    live_share_label: "Live-Link (Zuschauer)"
+    live_share_label: Live
     share_live: Livestream teilen
+    share_action: Teilen
     copy_link: Link kopieren
-    regia_share_label: "Regie-Link (Punktestand)"
+    copy_action: Kopieren
+    copy_live: Live kopieren
+    copy_regia: Regie kopieren
+    links_nav: Schnellaktionen
+    regia_share_label: Regie
+    stream_controls_label: Live
     share_regia: Regie-Link teilen
     preview_ended: Livestream beendet
     preview_waiting: Vorschau wartet auf Signal…
+    preview_hide: Vorschau ausblenden
+    preview_show: Vorschau anzeigen
+    preview_off_hint: Vorschau aus · kein Video-Download
     pause: Pausieren
     resume: Livestream fortsetzen
     stop: Livestream beenden
+    min_quality:
+      label: Minimale Übertragungsqualität
+      summary: Qualität
+      hint: Der Encoder fällt nicht unter dieses Niveau. Automatisch passt die Bitrate an, um Aussetzer zu reduzieren.
+      recommend: "Automatisch wird empfohlen: passt sich an Netz und Telefon an, ohne das Maximum zu erzwingen."
+      auto: Automatisch
+    telemetry:
+      label: Telefon
+      waiting: Warte auf das Telefon…
+      stale: Telefon antwortet nicht
+      just_now: jetzt
+      seconds_ago: "vor %{n}s"
+      publisher_on: RTMP ok
+      publisher_off: RTMP fehlt
+      battery: Akku
+      network: Netz
+      bitrate: Bitrate
+      bitrate_max: "max %{n}"
+      bitrate_title: "%{current} Mbps aktuell · max. %{target} Mbps"
+      bitrate_tap: Tippen, um die Mindestqualität festzulegen
+      fps: FPS
+      thermal: Temp.
+      thermal_nominal: OK
+      thermal_fair: Warm
+      thermal_serious: Heiß
+      thermal_critical: Kritisch
     modal:
       set_won_title: Satz gewonnen
       confirm: Satz beenden
@@ -486,6 +521,8 @@ de:
       copy_prompt: "Link kopieren:"
       share_regia_text: "Öffne diesen Link, um den Live-Spielstand zu verwalten:"
       share_live_text: "Sieh dir die Übertragung auf Match Live TV an:"
+      min_quality_updated: Mindestqualität aktualisiert
+      min_quality_error: Fehler beim Aktualisieren der Mindestqualität
   recordings:
     archive:
       back_prefix: "←"

backend/config/locales/app.en.yml

@@ -427,16 +427,51 @@ en:
       paused: Paused
       live: Live
       waiting: Waiting
-    live_share_label: "Live link (viewers)"
+    live_share_label: Live
     share_live: Share live link
+    share_action: Share
     copy_link: Copy link
-    regia_share_label: "Control room link (score)"
+    copy_action: Copy
+    copy_live: Copy live
+    copy_regia: Copy room
+    links_nav: Quick actions
+    regia_share_label: Control
+    stream_controls_label: Live
     share_regia: Share control room link
     preview_ended: Stream ended
     preview_waiting: Waiting for signal…
+    preview_hide: Hide preview
+    preview_show: Show preview
+    preview_off_hint: Preview off · no video download
     pause: Pause stream
     resume: Resume stream
     stop: End stream
+    min_quality:
+      label: Minimum streaming quality
+      summary: Quality
+      hint: The encoder will not go below this level. Automatic adapts bitrate to reduce stalls.
+      recommend: "Automatic is recommended: it adapts to the network and the phone, without forcing maximum quality."
+      auto: Automatic
+    telemetry:
+      label: Phone
+      waiting: Waiting for the phone…
+      stale: Phone not responding
+      just_now: now
+      seconds_ago: "%{n}s ago"
+      publisher_on: RTMP ok
+      publisher_off: RTMP down
+      battery: Battery
+      network: Network
+      bitrate: Bitrate
+      bitrate_max: "max %{n}"
+      bitrate_title: "%{current} Mbps current · max %{target} Mbps"
+      bitrate_tap: Tap to set the minimum quality
+      fps: FPS
+      thermal: Temp.
+      thermal_nominal: OK
+      thermal_fair: Warm
+      thermal_serious: Hot
+      thermal_critical: Critical
     modal:
       set_won_title: Set won
       confirm: Close set
@@ -481,6 +516,8 @@ en:
       copy_prompt: "Copy the link:"
       share_regia_text: "Open this link to manage the live score:"
       share_live_text: "Watch the live stream on Match Live TV:"
+      min_quality_updated: Minimum quality updated
+      min_quality_error: Error updating minimum quality
   recordings:
     archive:
       back_prefix: "←"

backend/config/locales/app.es.yml

@@ -432,16 +432,51 @@ es:
       paused: En pausa
       live: En directo
       waiting: En espera
-    live_share_label: "Enlace del directo (espectadores)"
+    live_share_label: Directo
     share_live: Compartir directo
+    share_action: Compartir
     copy_link: Copiar enlace
-    regia_share_label: "Enlace de control (marcador)"
+    copy_action: Copiar
+    copy_live: Copiar directo
+    copy_regia: Copiar control
+    links_nav: Acciones rápidas
+    regia_share_label: Control
+    stream_controls_label: Live
     share_regia: Compartir enlace de control
     preview_ended: Directo finalizado
     preview_waiting: Vista previa a la espera de señal…
+    preview_hide: Ocultar vista previa
+    preview_show: Mostrar vista previa
+    preview_off_hint: Vista previa apagada · sin descarga de vídeo
     pause: Pausar directo
     resume: Reanudar directo
     stop: Finalizar directo
+    min_quality:
+      label: Calidad mínima de transmisión
+      summary: Calidad
+      hint: El encoder no baja de este nivel. Automática adapta el bitrate para reducir los cortes.
+      recommend: "Se recomienda Automática: se adapta a la red y al teléfono, sin forzar el máximo."
+      auto: Automática
+    telemetry:
+      label: Teléfono
+      waiting: Esperando al teléfono…
+      stale: El teléfono no responde
+      just_now: ahora
+      seconds_ago: "hace %{n}s"
+      publisher_on: RTMP ok
+      publisher_off: RTMP ausente
+      battery: Batería
+      network: Red
+      bitrate: Bitrate
+      bitrate_max: "máx %{n}"
+      bitrate_title: "%{current} Mbps actuales · máximo %{target} Mbps"
+      bitrate_tap: Toca para definir la calidad mínima
+      fps: FPS
+      thermal: Temp.
+      thermal_nominal: OK
+      thermal_fair: Caliente
+      thermal_serious: Muy caliente
+      thermal_critical: Crítica
     modal:
       set_won_title: Set ganado
       confirm: Cerrar set
@@ -486,6 +521,8 @@ es:
       copy_prompt: "Copia el enlace:"
       share_regia_text: "Abre este enlace para gestionar el marcador en directo:"
       share_live_text: "Mira la retransmisión en Match Live TV:"
+      min_quality_updated: Calidad mínima actualizada
+      min_quality_error: Error al actualizar la calidad mínima
   recordings:
     archive:
       back_prefix: "←"

backend/config/locales/app.fr.yml

@@ -432,16 +432,51 @@ fr:
       paused: En pause
       live: En direct
       waiting: En attente
-    live_share_label: "Lien direct (spectateurs)"
+    live_share_label: Direct
     share_live: Partager le direct
+    share_action: Partager
     copy_link: Copier le lien
-    regia_share_label: "Lien régie (score)"
+    copy_action: Copier
+    copy_live: Copier live
+    copy_regia: Copier régie
+    links_nav: Actions rapides
+    regia_share_label: Régie
+    stream_controls_label: Live
     share_regia: Partager le lien régie
     preview_ended: Direct terminé
     preview_waiting: Aperçu en attente du signal…
+    preview_hide: Masquer l'aperçu
+    preview_show: Afficher l'aperçu
+    preview_off_hint: Aperçu désactivé · aucun téléchargement vidéo
     pause: Mettre en pause
     resume: Reprendre le direct
     stop: Terminer le direct
+    min_quality:
+      label: Qualité minimale de transmission
+      summary: Qualité
+      hint: L'encodeur ne descend pas en dessous de ce niveau. Automatique adapte le débit pour limiter les coupures.
+      recommend: "Automatique est conseillé : s'adapte au réseau et au téléphone, sans forcer le maximum."
+      auto: Automatique
+    telemetry:
+      label: Téléphone
+      waiting: En attente du téléphone…
+      stale: Téléphone sans réponse
+      just_now: maintenant
+      seconds_ago: "il y a %{n}s"
+      publisher_on: RTMP ok
+      publisher_off: RTMP absent
+      battery: Batterie
+      network: Réseau
+      bitrate: Débit
+      bitrate_max: "max %{n}"
+      bitrate_title: "%{current} Mbps actuels · max %{target} Mbps"
+      bitrate_tap: Touchez pour définir la qualité minimale
+      fps: FPS
+      thermal: Temp.
+      thermal_nominal: OK
+      thermal_fair: Chaude
+      thermal_serious: Très chaude
+      thermal_critical: Critique
     modal:
       set_won_title: Set gagné
       confirm: Terminer le set
@@ -486,6 +521,8 @@ fr:
       copy_prompt: "Copiez le lien :"
       share_regia_text: "Ouvrez ce lien pour gérer le score du direct :"
       share_live_text: "Regardez le direct sur Match Live TV :"
+      min_quality_updated: Qualité minimale mise à jour
+      min_quality_error: Erreur de mise à jour de la qualité minimale
   recordings:
     archive:
       back_prefix: "←"

backend/config/locales/app.it.yml

@@ -427,16 +427,51 @@ it:
       paused: In pausa
       live: In onda
       waiting: In attesa
-    live_share_label: "Link diretta (spettatori)"
+    live_share_label: Diretta
     share_live: Condividi diretta
+    share_action: Condividi
     copy_link: Copia link
-    regia_share_label: "Link regia (punteggio)"
+    copy_action: Copia
+    copy_live: Copia live
+    copy_regia: Copia regia
+    links_nav: Azioni rapide
+    regia_share_label: Regia
+    stream_controls_label: Live
     share_regia: Condividi link regia
     preview_ended: Diretta terminata
     preview_waiting: Anteprima in attesa del segnale…
+    preview_hide: Nascondi anteprima
+    preview_show: Mostra anteprima
+    preview_off_hint: Anteprima spenta · nessun download video
     pause: Metti in pausa
     resume: Riprendi diretta
     stop: Chiudi diretta
+    min_quality:
+      label: Qualità minima di trasmissione
+      summary: Qualità
+      hint: L'encoder non scende sotto questo livello. Automatica adatta il bitrate per ridurre i salti.
+      recommend: "Consigliata Automatica: si adatta alla rete e al telefono, senza forzare il massimo."
+      auto: Automatica
+    telemetry:
+      label: Telefono
+      waiting: In attesa del telefono…
+      stale: Telefono non risponde
+      just_now: ora
+      seconds_ago: "%{n}s fa"
+      publisher_on: RTMP ok
+      publisher_off: RTMP assente
+      battery: Batteria
+      network: Rete
+      bitrate: Bitrate
+      bitrate_max: "max %{n}"
+      bitrate_title: "%{current} Mbps attuali · massimo %{target} Mbps"
+      bitrate_tap: Tocca per impostare la qualità minima
+      fps: FPS
+      thermal: Temp.
+      thermal_nominal: OK
+      thermal_fair: Calda
+      thermal_serious: Molto calda
+      thermal_critical: Critica
     modal:
       set_won_title: Set vinto
       confirm: Chiudi set
@@ -481,6 +516,8 @@ it:
       copy_prompt: "Copia il link:"
       share_regia_text: "Apri questo link per gestire il punteggio della diretta:"
       share_live_text: "Guarda la diretta su Match Live TV:"
+      min_quality_updated: Qualità minima aggiornata
+      min_quality_error: Errore aggiornamento qualità minima
   recordings:
     archive:
       back_prefix: "←"

backend/config/locales/legal.de.yml

@@ -195,3 +195,18 @@ de:
       s6_body_html: "Um die von der DSGVO vorgesehenen Rechte auszuüben (Zugang, Löschung, Widerspruch, Widerruf der Einwilligung), schreiben Sie an %{email_link}. Details finden Sie im %{privacy_doc_link}."
       s6_privacy_doc_link_text: Datenschutzdokument
       manage_button: Cookie-Einstellungen verwalten
+    support:
+      title: Match Live TV Support
+      meta_description: "Match Live TV Hilfe: Zugangsprobleme, Livestreams, Teamverwaltung und Support-Kontaktdaten."
+      h1: Match Live TV Support
+      intro: "Brauchen Sie Hilfe mit Match Live TV? Bei Problemen mit dem Zugang, der Einrichtung von Livestreams, der Spielverwaltung oder der Nutzung der App können Sie unseren Support kontaktieren."
+      email_label: "Support-E-Mail:"
+      access_title: Zugangsprobleme
+      access_body: "Wenn Sie sich nicht anmelden können, prüfen Sie die Zugangsdaten, die Sie von Ihrem Sportverein erhalten haben. Wenn das Problem weiterhin besteht, kontaktieren Sie den Support."
+      live_title: Probleme während eines Livestreams
+      live_body: "Prüfen Sie Ihre Internetverbindung und versuchen Sie erneut, die Übertragung in der App zu starten. Wenn das Problem weiterhin besteht, kontaktieren Sie den Support und geben Sie Gerät, App-Version und eine kurze Beschreibung des Problems an."
+      team_title: Teamverwaltung
+      team_body: "Konten und Übertragungsberechtigungen werden vom Sportverein verwaltet."
+      privacy_title: Datenschutz
+      privacy_body_html: "Informationen zur Verarbeitung personenbezogener Daten finden Sie auf der Seite %{privacy_link}."
+      privacy_link_text: Datenschutz

backend/config/locales/legal.en.yml

@@ -195,3 +195,18 @@ en:
       s6_body_html: "To exercise the rights provided by the GDPR (access, erasure, objection, withdrawal of consent) write to %{email_link}. Details are in the %{privacy_doc_link}."
       s6_privacy_doc_link_text: privacy document
       manage_button: Manage cookie preferences
+    support:
+      title: Match Live TV Support
+      meta_description: "Match Live TV help: access issues, live streaming, team management and support contact details."
+      h1: Match Live TV Support
+      intro: "Need help with Match Live TV? For access issues, live stream setup, match management or app usage, you can contact our support team."
+      email_label: "Support email:"
+      access_title: Access issues
+      access_body: "If you cannot sign in, check the credentials provided by your sports club. If the problem persists, contact support."
+      live_title: Issues during a live stream
+      live_body: "Check your Internet connection and try starting the broadcast from the app again. If the problem persists, contact support and include your device, app version and a short description of the issue."
+      team_title: Team management
+      team_body: "Accounts and broadcasting permissions are managed by the sports club."
+      privacy_title: Privacy
+      privacy_body_html: "For information on personal data processing, see the %{privacy_link} page."
+      privacy_link_text: Privacy

backend/config/locales/legal.es.yml

@@ -195,3 +195,18 @@ es:
       s6_body_html: "Para ejercer los derechos previstos por el RGPD (acceso, supresión, oposición, revocación del consentimiento) escribe a %{email_link}. Más detalles en el %{privacy_doc_link}."
       s6_privacy_doc_link_text: documento de privacidad
       manage_button: Gestionar preferencias de cookies
+    support:
+      title: Soporte Match Live TV
+      meta_description: "Ayuda de Match Live TV: problemas de acceso, directos, gestión del equipo y datos de contacto del soporte."
+      h1: Soporte Match Live TV
+      intro: "¿Necesitas ayuda con Match Live TV? Para problemas de acceso, configuración de directos, gestión de partidos o uso de la app puedes contactar con nuestro soporte."
+      email_label: "Correo de soporte:"
+      access_title: Problemas de acceso
+      access_body: "Si no puedes acceder, verifica las credenciales recibidas de tu club deportivo. Si el problema continúa, contacta con el soporte."
+      live_title: Problemas durante un directo
+      live_body: "Verifica la conexión a Internet e intenta de nuevo iniciar la transmisión desde la app. Si el problema continúa, contacta con el soporte indicando el dispositivo, la versión de la app y una breve descripción del problema."
+      team_title: Gestión del equipo
+      team_body: "Las cuentas y los permisos de transmisión los gestiona el club deportivo."
+      privacy_title: Privacidad
+      privacy_body_html: "Para información sobre el tratamiento de datos personales, consulta la página %{privacy_link}."
+      privacy_link_text: Privacidad

backend/config/locales/legal.fr.yml

@@ -195,3 +195,18 @@ fr:
       s6_body_html: "Pour exercer les droits prévus par le RGPD (accès, effacement, opposition, retrait du consentement), écrivez à %{email_link}. Détails dans le %{privacy_doc_link}."
       s6_privacy_doc_link_text: document de confidentialité
       manage_button: Gérer les préférences de cookies
+    support:
+      title: Support Match Live TV
+      meta_description: "Assistance Match Live TV : problèmes d'accès, directs, gestion d'équipe et coordonnées du support."
+      h1: Support Match Live TV
+      intro: "Besoin d'aide avec Match Live TV ? Pour les problèmes d'accès, la configuration des directs, la gestion des matchs ou l'utilisation de l'application, vous pouvez contacter notre support."
+      email_label: "E-mail du support :"
+      access_title: Problèmes d'accès
+      access_body: "Si vous ne parvenez pas à vous connecter, vérifiez les identifiants fournis par votre club sportif. Si le problème persiste, contactez le support."
+      live_title: Problèmes pendant un direct
+      live_body: "Vérifiez votre connexion Internet et réessayez de démarrer la diffusion depuis l'application. Si le problème persiste, contactez le support en indiquant l'appareil, la version de l'application et une brève description du problème."
+      team_title: Gestion de l'équipe
+      team_body: "Les comptes et les autorisations de diffusion sont gérés par le club sportif."
+      privacy_title: Confidentialité
+      privacy_body_html: "Pour les informations sur le traitement des données personnelles, consultez la page %{privacy_link}."
+      privacy_link_text: Confidentialité

backend/config/locales/legal.it.yml

@@ -195,3 +195,18 @@ it:
       s6_body_html: "Per esercitare i diritti previsti dal GDPR (accesso, cancellazione, opposizione, revoca consenso) scrivi a %{email_link}. Dettagli nel %{privacy_doc_link}."
       s6_privacy_doc_link_text: documento privacy
       manage_button: Gestisci preferenze cookie
+    support:
+      title: Supporto Match Live TV
+      meta_description: "Assistenza Match Live TV: problemi di accesso, dirette live, gestione squadra e contatti del supporto."
+      h1: Supporto Match Live TV
+      intro: "Hai bisogno di assistenza con Match Live TV? Per problemi di accesso, configurazione delle dirette, gestione delle partite o utilizzo dell’app puoi contattare il nostro supporto."
+      email_label: "Email di supporto:"
+      access_title: Problemi di accesso
+      access_body: "Se non riesci ad accedere, verifica le credenziali ricevute dalla tua società sportiva. Se il problema persiste, contatta il supporto."
+      live_title: Problemi durante una diretta
+      live_body: "Verifica la connessione Internet e riprova ad avviare la trasmissione dall’app. Se il problema persiste, contatta il supporto indicando dispositivo, versione dell’app e una breve descrizione del problema."
+      team_title: Gestione della squadra
+      team_body: "Gli account e le autorizzazioni per la trasmissione sono gestiti dalla società sportiva."
+      privacy_title: Privacy
+      privacy_body_html: "Per informazioni sul trattamento dei dati personali consulta la pagina %{privacy_link}."
+      privacy_link_text: Privacy

backend/config/locales/ui.de.yml

@@ -133,6 +133,7 @@ de:
       save_password: Passwort aktualisieren
   common:
     privacy: Datenschutz
+    support: Support
     cookies: Cookies
     terms: AGB
     pricing: Preise

backend/config/locales/ui.en.yml

@@ -133,6 +133,7 @@ en:
       save_password: Update password
   common:
     privacy: Privacy
+    support: Support
     cookies: Cookies
     terms: Terms
     pricing: Pricing

backend/config/locales/ui.es.yml

@@ -133,6 +133,7 @@ es:
       save_password: Actualizar contraseña
   common:
     privacy: Privacidad
+    support: Soporte
     cookies: Cookies
     terms: Términos
     pricing: Precios

backend/config/locales/ui.fr.yml

@@ -133,6 +133,7 @@ fr:
       save_password: Mettre à jour le mot de passe
   common:
     privacy: Confidentialité
+    support: Support
     cookies: Cookies
     terms: Conditions
     pricing: Tarifs

backend/config/locales/ui.it.yml

@@ -133,6 +133,7 @@ it:
       save_password: Aggiorna password
   common:
     privacy: Privacy
+    support: Supporto
     cookies: Cookie
     terms: Termini
     pricing: Prezzi

backend/config/routes.rb

@@ -55,6 +55,7 @@ Rails.application.routes.draw do
           post :claim_pairing
           post :regia_link
           post :network_test
+          patch :min_quality
           get :youtube_stats
         end
       end
@@ -110,15 +111,6 @@ Rails.application.routes.draw do
         post :regia_link
       end
     end
-    resources :stream_nodes, only: %i[index create destroy] do
-      member do
-        post :drain
-      end
-      collection do
-        post :kill_switch
-        delete :clear_kill_switch
-      end
-    end
     get "youtube/platform", to: "youtube#platform", as: :youtube_platform
   end
 
@@ -152,6 +144,7 @@ Rails.application.routes.draw do
   post "regia/:token/pause", to: "public/regia#pause", as: :public_regia_pause
   post "regia/:token/resume", to: "public/regia#resume", as: :public_regia_resume
   post "regia/:token/stop", to: "public/regia#stop", as: :public_regia_stop
+  patch "regia/:token/min_quality", to: "public/regia#min_quality", as: :public_regia_min_quality
 
   root to: "public/pages#home"
   get "sitemap.xml", to: "public/sitemap#show", defaults: { format: :xml }
@@ -163,6 +156,7 @@ Rails.application.routes.draw do
     get "prezzi", to: "pages#pricing", as: :prezzi
     get "pricing", to: redirect("/prezzi")
     get "privacy", to: "pages#privacy", as: :privacy
+    get "support", to: "pages#support", as: :support
     get "cookie", to: "pages#cookies", as: :cookies
     get "cookies", to: redirect("/cookie")
     get "termini", to: "pages#terms", as: :termini

backend/config/sidekiq.yml

@@ -1,5 +1,4 @@
 :concurrency: 5
 :queues:
-  - critical
-  - youtube_relay
   - default
+  - critical

backend/db/migrate/20260809120000_create_stream_nodes.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-class CreateStreamNodes < ActiveRecord::Migration[7.2]
-  def change
-    create_table :stream_nodes, id: :uuid, default: -> { "gen_random_uuid()" } do |t|
-      t.string :slug, null: false
-      t.string :hostname, null: false
-      t.string :role, null: false, default: "home"
-      t.string :status, null: false, default: "ready"
-      t.string :rtmp_base_url, null: false
-      t.string :hls_base_url, null: false
-      t.string :api_base_url, null: false
-      t.string :internal_rtmp_url
-      t.string :internal_hls_url
-      t.integer :max_publishers, null: false, default: 6
-      t.integer :max_relays, null: false, default: 6
-      t.string :provider, null: false, default: "local"
-      t.string :provider_instance_id
-      t.datetime :last_health_at
-      t.jsonb :metadata, null: false, default: {}
-      t.timestamps
-    end
-
-    add_index :stream_nodes, :slug, unique: true
-    add_index :stream_nodes, :status
-    add_index :stream_nodes, :role
-
-    add_reference :stream_sessions, :stream_node, type: :uuid, foreign_key: true, null: true, index: true
-  end
-end

backend/db/migrate/20260813170000_add_min_quality_preset_to_stream_sessions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddMinQualityPresetToStreamSessions < ActiveRecord::Migration[7.2]
+  def change
+    add_column :stream_sessions, :min_quality_preset, :string, default: "auto", null: false
+  end
+end

backend/db/migrate/20260813184100_add_thermal_state_to_device_states.rb

@@ -0,0 +1,5 @@
+class AddThermalStateToDeviceStates < ActiveRecord::Migration[7.2]
+  def change
+    add_column :device_states, :thermal_state, :string
+  end
+end

backend/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.2].define(version: 2026_08_09_120000) do
+ActiveRecord::Schema[7.2].define(version: 2026_08_13_184100) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "pgcrypto"
   enable_extension "plpgsql"
@@ -138,6 +138,7 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_09_120000) do
     t.datetime "last_seen_at"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.string "thermal_state"
     t.index ["stream_session_id", "device_role"], name: "index_device_states_on_stream_session_id_and_device_role", unique: true
     t.index ["stream_session_id"], name: "index_device_states_on_stream_session_id"
   end
@@ -304,6 +305,7 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_09_120000) do
     t.string "regia_token_digest"
     t.datetime "regia_token_expires_at"
     t.uuid "stream_node_id"
+    t.string "min_quality_preset", default: "auto", null: false
     t.index ["match_id"], name: "index_stream_sessions_on_match_id"
     t.index ["publish_token"], name: "index_stream_sessions_on_publish_token", unique: true
     t.index ["regia_token_digest"], name: "index_stream_sessions_on_regia_token_digest", unique: true

backend/db/seeds.rb

@@ -43,6 +43,3 @@ end
 
 puts "Seed OK: coach@matchlivetv.test / Password123"
 puts "Club: #{club.name}, Team: #{team.name}, Match: #{match.opponent_name}"
-
-home = Streams::NodeRegistry.ensure_home_from_env!
-puts "Stream node home: #{home.slug} rtmp=#{home.rtmp_base_url}"

backend/lib/tasks/streams_nodes.rake

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-namespace :streams do
-  namespace :nodes do
-    desc "Assicura il nodo home dagli ENV MediaMTX"
-    task ensure_home: :environment do
-      node = Streams::NodeRegistry.ensure_home_from_env!
-      puts "home ready slug=#{node.slug} rtmp=#{node.rtmp_base_url} max=#{node.max_publishers}"
-    end
-
-    desc "Provisiona un nodo lab (STREAM_CLOUD_PROVIDER=local_lab|proxmox_lab)"
-    task provision_lab: :environment do
-      node = Streams::NodeProvisioner.new.provision_lab!
-      puts "lab node ready slug=#{node.slug} host=#{node.hostname} id=#{node.provider_instance_id}"
-      if ENV.fetch("STREAM_DNS_PROVIDER", "lab") == "lab"
-        puts "DNS lab snippet:"
-        puts Streams::DnsProviders::Lab.new.hosts_file_snippet
-      end
-    end
-
-    desc "Provisiona un nodo Hetzner Cloud + DNS mltv-stream.net (richiede HCLOUD_TOKEN)"
-    task provision_cloud: :environment do
-      node = Streams::NodeProvisioner.new.provision_cloud!
-      puts "cloud node ready slug=#{node.slug} host=#{node.hostname} id=#{node.provider_instance_id} ip=#{node.metadata['public_ip']}"
-    end
-
-    desc "Dump record DNS lab (Redis)"
-    task dns_lab_dump: :environment do
-      puts Streams::DnsProviders::Lab.new.hosts_file_snippet
-    end
-  end
-end

backend/public/regia.css

@@ -4,6 +4,8 @@
   --regia-surface: #14141c;
   --regia-red: #e53935;
   --regia-yellow: #f9a825;
+  --regia-green: #43a047;
+  --regia-orange: #fb8c00;
   --regia-text: #f5f5f5;
   --regia-muted: #9ca3af;
   --regia-safe-bottom: env(safe-area-inset-bottom, 0px);
@@ -22,37 +24,166 @@
 .regia-page {
   max-width: 480px;
   margin: 0 auto;
-  padding: 12px 16px calc(24px + var(--regia-safe-bottom));
+  padding: 8px 12px calc(12px + var(--regia-safe-bottom));
+}
+
+.regia-header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.regia-header__text {
+  min-width: 0;
+  flex: 1;
 }
 
 .regia-header h1 {
   margin: 0;
-  font-size: 1.1rem;
+  font-size: 1rem;
   font-weight: 700;
+  line-height: 1.25;
 }
 
 .regia-header p {
-  margin: 4px 0 0;
+  margin: 2px 0 0;
-  font-size: 0.85rem;
+  font-size: 0.78rem;
   color: var(--regia-muted);
 }
 
 .regia-badge {
   display: inline-block;
-  margin-top: 8px;
+  margin-top: 0;
-  padding: 4px 10px;
+  padding: 3px 8px;
   border-radius: 999px;
-  font-size: 0.7rem;
+  font-size: 0.65rem;
   font-weight: 700;
   text-transform: uppercase;
+  flex-shrink: 0;
 }
 
 .regia-badge--live { background: #2e7d32; color: #fff; }
 .regia-badge--wait { background: #444; color: #ddd; }
 .regia-badge--ended { background: #374151; color: #ddd; }
 
+.regia-toolbar {
+  margin: 8px 0 6px;
+  display: flex;
+  align-items: flex-end;
+  gap: 8px;
+}
+
+.regia-tool-group {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 3px;
+  min-width: 0;
+}
+
+.regia-tool-group__label {
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--regia-muted);
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.regia-tool-group__btns {
+  display: flex;
+  gap: 3px;
+}
+
+.regia-tool-group--stream {
+  margin-left: auto;
+  padding-left: 8px;
+  border-left: 1px solid #333;
+}
+
+.regia-icon-btn {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 40px;
+  height: 40px;
+  margin: 0;
+  padding: 0;
+  border: 1px solid #333;
+  border-radius: 10px;
+  background: #16161f;
+  color: var(--regia-text);
+  cursor: pointer;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.regia-icon-btn svg {
+  width: 20px;
+  height: 20px;
+  pointer-events: none;
+}
+
+.regia-icon-btn svg.icon-fill {
+  fill: currentColor;
+}
+
+.regia-icon-btn svg.icon-outline {
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 2;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+.regia-icon-btn .icon-eye-off,
+.regia-icon-btn .icon-play {
+  display: none;
+}
+
+.regia-icon-btn.is-off .icon-eye {
+  display: none;
+}
+
+.regia-icon-btn.is-off .icon-eye-off {
+  display: block;
+}
+
+.regia-icon-btn.is-paused .icon-pause {
+  display: none;
+}
+
+.regia-icon-btn.is-paused .icon-play {
+  display: block;
+}
+
+.regia-icon-btn:active { transform: scale(0.96); }
+
+.regia-icon-btn.is-off {
+  color: var(--regia-yellow);
+  border-color: #5a4a1a;
+}
+
+.regia-icon-btn--danger {
+  color: var(--regia-red);
+  border-color: #7a2a28;
+}
+
+.regia-preview-wrap {
+  margin: 6px 0 10px;
+}
+
+.regia-preview-wrap.is-off {
+  margin: 0;
+  height: 0;
+  overflow: hidden;
+}
+
 .regia-preview {
-  margin: 14px 0;
+  margin: 0;
   border-radius: 12px;
   overflow: hidden;
   background: #000;
@@ -90,29 +221,29 @@
 .regia-scoreboard {
   background: var(--regia-surface);
   border-radius: 12px;
-  padding: 16px;
+  padding: 10px 12px;
-  margin-bottom: 12px;
+  margin-bottom: 8px;
 }
 
 .regia-sets {
   text-align: center;
-  font-size: 0.82rem;
+  font-size: 0.78rem;
   color: var(--regia-muted);
-  margin: 0 0 8px;
+  margin: 0 0 4px;
 }
 
 .regia-score-line {
   text-align: center;
-  font-size: 1.5rem;
+  font-size: 1.2rem;
   font-weight: 800;
   margin: 0;
 }
 
 .regia-partials {
   text-align: center;
-  font-size: 0.78rem;
+  font-size: 0.75rem;
   color: var(--regia-muted);
-  margin: 8px 0 0;
+  margin: 4px 0 0;
 }
 
 .regia-team-row {
@@ -120,7 +251,7 @@
   grid-template-columns: 1fr auto 1fr;
   gap: 8px;
   align-items: center;
-  margin-top: 16px;
+  margin-top: 8px;
 }
 
 .regia-team-name {
@@ -131,7 +262,7 @@
 }
 
 .regia-points {
-  font-size: 2rem;
+  font-size: 1.55rem;
   font-weight: 800;
   text-align: center;
 }
@@ -146,7 +277,7 @@
 .regia-btn {
   border: none;
   border-radius: 10px;
-  padding: 16px 12px;
+  padding: 10px 8px;
   font-size: 1rem;
   font-weight: 700;
   cursor: pointer;
@@ -156,8 +287,8 @@
 
 .regia-btn:active { transform: scale(0.98); }
 .regia-btn--point { background: var(--regia-red); color: #fff; }
-.regia-btn--minus { background: #2a2a36; color: #fff; font-size: 0.9rem; padding: 12px; }
+.regia-btn--minus { background: #2a2a36; color: #fff; font-size: 0.9rem; padding: 8px; }
-.regia-btn--yellow { background: var(--regia-yellow); color: #111; width: 100%; margin-top: 10px; }
+.regia-btn--yellow { background: var(--regia-yellow); color: #111; width: 100%; margin-top: 8px; padding: 12px; }
 .regia-btn--outline {
   background: transparent;
   border: 1px solid #444;
@@ -173,26 +304,6 @@
   margin-top: 8px;
 }
 
-.regia-share-group {
-  margin: 12px 0;
-}
-
-.regia-share-label {
-  margin: 0 0 6px;
-  font-size: 0.72rem;
-  font-weight: 600;
-  letter-spacing: 0.04em;
-  text-transform: uppercase;
-  color: var(--regia-muted);
-}
-
-.regia-share {
-  display: flex;
-  gap: 8px;
-}
-
-.regia-share .regia-btn { flex: 1; font-size: 0.9rem; padding: 12px; }
-
 .regia-toast {
   position: fixed;
   bottom: calc(16px + var(--regia-safe-bottom));
@@ -240,7 +351,7 @@
   text-align: center;
   color: var(--regia-muted);
   font-size: 0.72rem;
-  padding-top: 24px;
+  padding-top: 8px;
 }
 
 .regia-clock-line {
@@ -255,3 +366,128 @@
   gap: 8px;
   margin-top: 12px;
 }
+
+.regia-quality {
+  margin: 6px 0 0;
+  padding: 8px 10px 10px;
+  background: var(--regia-surface);
+  border-radius: 10px;
+}
+
+.regia-quality[hidden] { display: none !important; }
+
+.regia-quality__hint {
+  margin: 0 0 8px;
+  font-size: 0.68rem;
+  line-height: 1.35;
+  color: var(--regia-muted);
+}
+
+.regia-quality label {
+  display: block;
+  font-size: 0.68rem;
+  color: var(--regia-muted);
+  margin: 0 0 4px;
+}
+
+.regia-quality select {
+  width: 100%;
+  background: #0a0a0e;
+  color: var(--regia-text);
+  border: 1px solid #2a2a35;
+  border-radius: 8px;
+  padding: 8px 10px;
+  font-size: 0.82rem;
+}
+
+.regia-telemetry {
+  margin-top: 8px;
+}
+
+.regia-telemetry__row {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+  gap: 4px;
+}
+
+.regia-chip {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 2px;
+  min-width: 0;
+  text-align: center;
+  padding: 6px 2px 5px;
+  border-radius: 8px;
+  background: var(--regia-surface);
+  color: var(--regia-text);
+  border: 1px solid transparent;
+}
+
+.regia-chip--action {
+  appearance: none;
+  -webkit-appearance: none;
+  font: inherit;
+  cursor: pointer;
+  width: 100%;
+}
+
+.regia-chip--action:focus-visible {
+  outline: 2px solid var(--regia-yellow);
+  outline-offset: 1px;
+}
+
+.regia-chip--action.is-open {
+  border-color: #3a3a48;
+}
+
+.regia-chip svg {
+  width: 14px;
+  height: 14px;
+  fill: currentColor;
+}
+
+.regia-chip__label {
+  font-size: 0.55rem;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+  color: var(--regia-muted);
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.regia-chip__value {
+  font-size: 0.72rem;
+  font-weight: 800;
+  line-height: 1.15;
+  max-width: 100%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.regia-chip__hint {
+  font-size: 0.55rem;
+  font-weight: 600;
+  color: var(--regia-muted);
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.regia-chip__hint[hidden] { display: none; }
+
+.regia-chip.is-ok { color: var(--regia-green); }
+.regia-chip.is-warn { color: var(--regia-orange); }
+.regia-chip.is-bad { color: var(--regia-red); }
+
+.regia-telemetry__meta {
+  margin: 4px 0 0;
+  font-size: 0.65rem;
+  color: var(--regia-muted);
+  text-align: center;
+}
+
+.regia-telemetry.is-stale .regia-telemetry__meta {
+  color: var(--regia-yellow);
+}

backend/public/regia.js

@@ -37,13 +37,32 @@
     shareLiveText: "Guarda la diretta su Match Live TV:",
     previewWaiting: "Anteprima in attesa del segnale…",
     streamEnded: "Diretta terminata",
+    previewHide: "Nascondi anteprima",
+    previewShow: "Mostra anteprima",
+    previewOffHint: "Anteprima spenta · nessun download video",
     resumeLabel: "Riprendi diretta",
     pauseLabel: "Metti in pausa",
     endedBadge: "Terminata",
     pausedBadge: "In pausa",
     liveBadge: "In onda",
     waitingBadge: "In attesa",
-    subtitlePrefix: "Regia ·"
+    subtitlePrefix: "Regia ·",
+    minQualityUpdated: "Qualità minima aggiornata",
+    minQualityError: "Errore aggiornamento qualità minima",
+    minQualityAuto: "Automatica",
+    telemetryWaiting: "In attesa del telefono…",
+    telemetryStale: "Telefono non risponde",
+    telemetryJustNow: "ora",
+    telemetrySecondsAgo: "%{n}s fa",
+    telemetryPublisherOn: "RTMP ok",
+    telemetryPublisherOff: "RTMP assente",
+    telemetryThermalNominal: "OK",
+    telemetryThermalFair: "Calda",
+    telemetryThermalSerious: "Calda",
+    telemetryThermalCritical: "Critica",
+    telemetryBitrateMax: "max %{n}",
+    telemetryBitrateTitle: "%{current} Mbps attuali · massimo %{target} Mbps",
+    telemetryBitrateTap: "Tocca per impostare la qualità minima"
   };
 
   function loadI18n() {
@@ -77,6 +96,7 @@
     pauseUrl: root.dataset.pauseUrl,
     resumeUrl: root.dataset.resumeUrl,
     stopUrl: root.dataset.stopUrl,
+    minQualityUrl: root.dataset.minQualityUrl,
     cableUrl: root.dataset.cableUrl,
     hlsUrl: root.dataset.hlsUrl,
     homeName: root.dataset.homeName,
@@ -102,15 +122,28 @@
     modalCancel: document.getElementById("modal-cancel"),
     preview: document.getElementById("regia-preview"),
     previewPlaceholder: document.getElementById("regia-preview-placeholder"),
+    previewWrap: document.getElementById("regia-preview-wrap"),
+    btnTogglePreview: document.getElementById("btn-toggle-preview"),
     btnPause: document.getElementById("btn-pause"),
-    subtitle: document.getElementById("regia-subtitle")
+    minQuality: document.getElementById("min-quality"),
+    subtitle: document.getElementById("regia-subtitle"),
+    telemetry: document.getElementById("regia-telemetry"),
+    telBattery: document.getElementById("tel-battery"),
+    telNetwork: document.getElementById("tel-network"),
+    telBitrate: document.getElementById("tel-bitrate"),
+    telFps: document.getElementById("tel-fps"),
+    telThermal: document.getElementById("tel-thermal"),
+    telMeta: document.getElementById("tel-meta"),
+    qualityPanel: document.getElementById("regia-quality")
   };
 
   let pendingAction = null;
   let hls = null;
   let previewStarted = false;
+  let previewWanted = true;
   let wasPausedPreview = false;
   let streamPaused = root.dataset.initialPaused === "true";
+  const PREVIEW_PREF_KEY = "mltv-regia-preview";
 
   function hlsUrlFresh() {
     const sep = cfg.hlsUrl.includes("?") ? "&" : "?";
@@ -139,8 +172,43 @@
     }
   }
 
+  function readPreviewPref() {
+    try {
+      return localStorage.getItem(PREVIEW_PREF_KEY) !== "0";
+    } catch (_) {
+      return true;
+    }
+  }
+
+  function writePreviewPref(on) {
+    try {
+      localStorage.setItem(PREVIEW_PREF_KEY, on ? "1" : "0");
+    } catch (_) {}
+  }
+
+  function syncPreviewToggleUi() {
+    if (!els.previewWrap || !els.btnTogglePreview) return;
+    const label = previewWanted ? I18N.previewHide : I18N.previewShow;
+    els.previewWrap.classList.toggle("is-off", !previewWanted);
+    els.btnTogglePreview.classList.toggle("is-off", !previewWanted);
+    els.btnTogglePreview.setAttribute("aria-pressed", previewWanted ? "true" : "false");
+    els.btnTogglePreview.setAttribute("aria-label", label);
+    els.btnTogglePreview.title = previewWanted ? I18N.previewHide : I18N.previewOffHint;
+  }
+
+  function setPreviewWanted(on) {
+    previewWanted = !!on;
+    writePreviewPref(previewWanted);
+    syncPreviewToggleUi();
+    if (previewWanted) {
+      startPreview();
+    } else {
+      destroyPreview();
+    }
+  }
+
   function refreshPreviewForCover() {
-    if (!els.preview || !cfg.hlsUrl || cfg.streamClosed) return;
+    if (!els.preview || !cfg.hlsUrl || cfg.streamClosed || !previewWanted) return;
     destroyPreview();
     previewStarted = false;
     startPreview();
@@ -243,7 +311,10 @@
     if (!els.btnPause) return;
     const paused = !!(data.paused || data.status === "paused");
     streamPaused = paused;
-    els.btnPause.textContent = paused ? I18N.resumeLabel : I18N.pauseLabel;
+    const label = paused ? I18N.resumeLabel : I18N.pauseLabel;
+    els.btnPause.classList.toggle("is-paused", paused);
+    els.btnPause.setAttribute("aria-label", label);
+    els.btnPause.title = label;
   }
 
   function setBadge(data) {
@@ -364,6 +435,11 @@
     }
 
     const paused = data.paused || data.status === "paused";
+    if (!previewWanted) {
+      destroyPreview();
+      wasPausedPreview = paused;
+      return;
+    }
     if (data.on_air) {
       if (!previewStarted) {
         startPreview();
@@ -382,6 +458,119 @@
     wasPausedPreview = paused;
   }
 
+  function mbpsNumber(bps) {
+    const n = Number(bps);
+    if (!n || n <= 0) return null;
+    const mbps = n >= 10_000 ? n / 1e6 : n / 1e3;
+    return mbps >= 10 ? mbps.toFixed(0) : mbps.toFixed(1);
+  }
+
+  function formatAge(iso) {
+    if (!iso) return null;
+    const then = Date.parse(iso);
+    if (!then) return null;
+    const secs = Math.max(0, Math.round((Date.now() - then) / 1000));
+    if (secs < 8) return I18N.telemetryJustNow;
+    return fillTemplate(I18N.telemetrySecondsAgo, { n: secs });
+  }
+
+  function setChip(el, text, level, hint) {
+    if (!el) return;
+    const valueEl = el.querySelector(".regia-chip__value") || el;
+    valueEl.textContent = text;
+    el.classList.toggle("is-ok", level === "ok");
+    el.classList.toggle("is-warn", level === "warn");
+    el.classList.toggle("is-bad", level === "bad");
+    const hintEl = el.querySelector(".regia-chip__hint");
+    if (hintEl) {
+      hintEl.textContent = hint || "";
+      hintEl.hidden = !hint;
+    }
+  }
+
+  function formatThermal(state) {
+    const key = String(state || "").toLowerCase();
+    if (key === "nominal") return { text: I18N.telemetryThermalNominal, level: "ok" };
+    if (key === "fair") return { text: I18N.telemetryThermalFair, level: "warn" };
+    if (key === "serious") return { text: I18N.telemetryThermalSerious, level: "bad" };
+    if (key === "critical") return { text: I18N.telemetryThermalCritical, level: "bad" };
+    return { text: "—", level: null };
+  }
+
+  function bitrateLevel(current, target, paused) {
+    if (paused || !current || current <= 0) return null;
+    if (target && target > 0) {
+      const ratio = current / target;
+      if (ratio >= 0.7) return "ok";
+      if (ratio >= 0.4) return "warn";
+      return "bad";
+    }
+    const mbps = current >= 10_000 ? current / 1e6 : current / 1e3;
+    if (mbps >= 2.5) return "ok";
+    if (mbps >= 1.5) return "warn";
+    return "bad";
+  }
+
+  function bitrateTitle(currentMbps, targetMbps) {
+    const tap = I18N.telemetryBitrateTap;
+    if (currentMbps && targetMbps) {
+      return `${fillTemplate(I18N.telemetryBitrateTitle, { current: currentMbps, target: targetMbps })} · ${tap}`;
+    }
+    if (currentMbps) return `${currentMbps} Mbps · ${tap}`;
+    return tap;
+  }
+
+  function syncTelemetry(data) {
+    if (!els.telemetry) return;
+    const tel = data.telemetry || {};
+    const battery = tel.battery;
+    const fps = tel.fps;
+    const bitrate = tel.bitrate;
+    const target = tel.target_bitrate || tel.targetBitrate;
+    const lastSeen = tel.last_seen_at || tel.lastSeenAt;
+    const ageSecs = lastSeen ? Math.max(0, Math.round((Date.now() - Date.parse(lastSeen)) / 1000)) : null;
+    const stale = ageSecs == null || ageSecs > 25;
+    const publishing = !!tel.publisher_online || !!tel.publisherOnline;
+
+    let battLevel = null;
+    let battText = "—";
+    if (battery != null && battery !== "") {
+      battText = `${battery}%`;
+      if (battery <= 15) battLevel = "bad";
+      else if (battery <= 25) battLevel = "warn";
+    }
+    setChip(els.telBattery, battText, battLevel);
+    setChip(els.telNetwork, tel.network || "—");
+
+    const currentMbps = mbpsNumber(bitrate);
+    const targetMbps = mbpsNumber(target);
+    const rateText = currentMbps || "—";
+    const rateHint = currentMbps && targetMbps
+      ? fillTemplate(I18N.telemetryBitrateMax, { n: targetMbps })
+      : null;
+    if (els.telBitrate) els.telBitrate.title = bitrateTitle(currentMbps, targetMbps);
+    setChip(els.telBitrate, rateText, bitrateLevel(Number(bitrate), Number(target), data.paused), rateHint);
+
+    let fpsLevel = null;
+    if (fps != null && fps !== "" && Number(fps) > 0 && Number(fps) < 20) fpsLevel = "warn";
+    setChip(els.telFps, fps && Number(fps) > 0 ? String(fps) : "—", fpsLevel);
+
+    const thermal = formatThermal(tel.thermal_state || tel.thermalState);
+    setChip(els.telThermal, thermal.text, thermal.level);
+
+    els.telemetry.classList.toggle("is-stale", stale && !data.paused && !data.stream_closed);
+    if (!els.telMeta) return;
+    if (stale && !lastSeen) {
+      els.telMeta.textContent = I18N.telemetryWaiting;
+      return;
+    }
+    const parts = [publishing ? I18N.telemetryPublisherOn : I18N.telemetryPublisherOff];
+    const age = formatAge(lastSeen);
+    if (age) parts.push(age);
+    if (stale && !data.paused && !data.stream_closed) parts.push(I18N.telemetryStale);
+    els.telMeta.textContent = parts.join(" · ");
+  }
+
   async function pollStatus() {
     try {
       const res = await fetch(cfg.statusUrl, { headers: { Accept: "application/json" } });
@@ -389,6 +578,8 @@
       const data = await res.json();
       applyScorePayload(data);
       setBadge(data);
+      syncMinQuality(data);
+      syncTelemetry(data);
       syncPreviewFromStatus(data);
     } catch (_) {}
   }
@@ -401,7 +592,7 @@
   }
 
   function startPreview() {
-    if (cfg.streamClosed || !els.preview || !cfg.hlsUrl || previewStarted) return;
+    if (cfg.streamClosed || !previewWanted || !els.preview || !cfg.hlsUrl || previewStarted) return;
 
     previewStarted = true;
     const url = hlsUrlFresh();
@@ -454,6 +645,8 @@
     const wasPaused = streamPaused;
     applyScorePayload(data);
     setBadge(data);
+    syncMinQuality(data);
+    syncTelemetry(data);
     syncPreviewFromStatus(data);
     toast(wasPaused ? I18N.resumed : I18N.pausedCover);
   }
@@ -473,6 +666,70 @@
   els.btnPause?.addEventListener("click", () => togglePauseStream().catch((e) => toast(e.message)));
   document.getElementById("btn-stop")?.addEventListener("click", () => stopStream().catch((e) => toast(e.message)));
 
+  let minQualityBusy = false;
+
+  function setQualityPanelOpen(open) {
+    if (!els.qualityPanel || !els.telBitrate) return;
+    els.qualityPanel.hidden = !open;
+    els.telBitrate.setAttribute("aria-expanded", open ? "true" : "false");
+    els.telBitrate.classList.toggle("is-open", open);
+    if (open && els.minQuality) {
+      window.requestAnimationFrame(() => els.minQuality.focus());
+    }
+  }
+
+  function syncMinQuality(data) {
+    if (!els.minQuality || minQualityBusy) return;
+    const value = data.min_quality_preset || "auto";
+    if (els.minQuality.value !== value) els.minQuality.value = value;
+  }
+
+  async function setMinQuality(preset) {
+    if (!cfg.minQualityUrl) return;
+    minQualityBusy = true;
+    try {
+      const res = await fetch(cfg.minQualityUrl, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({ min_quality_preset: preset })
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) throw new Error(data.error || I18N.minQualityError);
+      minQualityBusy = false;
+      syncMinQuality(data);
+      toast(I18N.minQualityUpdated);
+    } catch (e) {
+      toast(e.message || I18N.minQualityError);
+    } finally {
+      minQualityBusy = false;
+    }
+  }
+
+  els.minQuality?.addEventListener("change", () => {
+    setMinQuality(els.minQuality.value);
+  });
+
+  els.telBitrate?.addEventListener("click", (e) => {
+    e.stopPropagation();
+    const opening = !!(els.qualityPanel && els.qualityPanel.hidden);
+    setQualityPanelOpen(opening);
+  });
+
+  document.addEventListener("click", (e) => {
+    if (!els.qualityPanel || els.qualityPanel.hidden) return;
+    if (els.qualityPanel.contains(e.target) || els.telBitrate?.contains(e.target)) return;
+    setQualityPanelOpen(false);
+  });
+
+  document.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") setQualityPanelOpen(false);
+  });
+
+  els.btnTogglePreview?.addEventListener("click", () => setPreviewWanted(!previewWanted));
+  previewWanted = readPreviewPref();
+  syncPreviewToggleUi();
+  if (!previewWanted) destroyPreview();
+
   async function shareLink(url, title, text) {
     if (!url) {
       toast(I18N.linkUnavailable);

backend/spec/jobs/youtube_relay_stop_job_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe YoutubeRelayStopJob, type: :job do
-  it "requeues when stop runs on the wrong host" do
-    session = instance_double(StreamSession, id: SecureRandom.uuid)
-    allow(StreamSession).to receive(:find_by).and_return(session)
-    allow(Streams::YoutubeRelay).to receive(:worker?).and_return(true)
-    allow(Streams::YoutubeRelay).to receive(:stop_on_worker!).and_return(:wrong_host)
-
-    job_proxy = double("ConfiguredJob")
-    expect(described_class).to receive(:set).with(wait: 2.seconds).and_return(job_proxy)
-    expect(job_proxy).to receive(:perform_later).with(session.id, 1)
-
-    described_class.new.perform(session.id, 0)
-  end
-end

backend/spec/models/stream_session_node_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe StreamSession do
-  it "builds ingest/hls URLs from the assigned stream node" do
-    node = StreamNode.create!(
-      slug: "ingest-01",
-      hostname: "ingest-01.mltv-stream.net",
-      role: "cloud",
-      status: "ready",
-      provider: "hetzner",
-      rtmp_base_url: "rtmp://ingest-01.mltv-stream.net:1935",
-      hls_base_url: "https://ingest-01.mltv-stream.net/hls",
-      api_base_url: "http://10.0.0.2:9997",
-      internal_rtmp_url: "rtmp://10.0.0.2:1935",
-      max_publishers: 4,
-      max_relays: 4
-    )
-    user = User.create!(email: "s@example.com", name: "S", password: "Password123", role: "coach")
-    club = Club.create!(name: "Club", sport: "volleyball")
-    team = club.teams.create!(name: "Team", sport: "volleyball", slug: "team-url")
-    match = team.matches.create!(opponent_name: "Opp", scheduled_at: 1.hour.from_now)
-    session = StreamSession.create!(
-      match: match, user: user, platform: "matchlivetv", status: "idle", stream_node: node
-    )
-
-    expect(session.rtmp_ingest_url).to eq(
-      "rtmp://ingest-01.mltv-stream.net:1935/live/match_#{session.id}"
-    )
-    expect(session.hls_playback_url).to eq(
-      "https://ingest-01.mltv-stream.net/hls/live/match_#{session.id}/index.m3u8"
-    )
-    expect(session.mediamtx_api_base_url).to eq("http://10.0.0.2:9997")
-    expect(session.mediamtx_internal_rtmp_url).to eq("rtmp://10.0.0.2:1935")
-  end
-end

backend/spec/requests/public/regia_spec.rb

@@ -1,7 +1,7 @@
 require "rails_helper"
 
 RSpec.describe "Public regia", type: :request do
-  let!(:user) { User.create!(email: "regia@test.it", name: "U", password: "password123", role: "coach") }
+  let!(:user) { User.create!(email: "regia@test.it", name: "U", password: "Password123", role: "coach") }
   let!(:club) { Club.create!(name: "C", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff") }
   let!(:team) { club.teams.create!(name: "T", sport: "volleyball") }
   let!(:match) { team.matches.create!(opponent_name: "Opp", sport: "volleyball") }
@@ -12,7 +12,18 @@ RSpec.describe "Public regia", type: :request do
     get public_regia_path(token)
     expect(response).to have_http_status(:ok)
     expect(response.body).to include("Condividi diretta")
+    expect(response.body).to include("Copia live")
     expect(response.body).to include("Condividi link regia")
+    expect(response.body).to include("Copia regia")
+    expect(response.body).to include(">Diretta<")
+    expect(response.body).to include(">Regia<")
+    expect(response.body).to include("regia-tool-group")
+    expect(response.body).to include("Nascondi anteprima")
+    expect(response.body).to include('id="btn-pause"')
+    expect(response.body).to include('id="btn-stop"')
+    expect(response.body).to include("Qualità minima di trasmissione")
+    expect(response.body).to include('id="tel-bitrate"')
+    expect(response.body).to include('aria-controls="regia-quality"')
     expect(response.body).to include("/live/#{session.id}")
     expect(response.body).not_to include("Aruba")
   end
@@ -156,4 +167,39 @@ RSpec.describe "Public regia", type: :request do
     get public_regia_path(token)
     expect(response).to have_http_status(:ok)
   end
+
+  it "aggiorna la qualità minima di trasmissione" do
+    token = Sessions::RegiaAccess.new(session).issue_token!
+    patch public_regia_min_quality_path(token), params: { min_quality_preset: "720p_30_1.5mbps" }
+    expect(response).to have_http_status(:ok)
+    expect(session.reload.min_quality_preset).to eq("720p_30_1.5mbps")
+    json = JSON.parse(response.body)
+    expect(json["min_quality_preset"]).to eq("720p_30_1.5mbps")
+  end
+
+  it "espone la telemetria della camera nello status" do
+    session.device_states.create!(
+      device_role: "camera",
+      battery_level: 81,
+      network_type: "WiFi",
+      current_bitrate: 2_400_000,
+      target_bitrate: 4_500_000,
+      fps: 30,
+      thermal_state: "nominal",
+      last_seen_at: Time.current
+    )
+    token = Sessions::RegiaAccess.new(session).issue_token!
+    get public_regia_path(token)
+    expect(response.body).to include('id="regia-telemetry"')
+
+    get public_regia_status_path(token)
+    expect(response).to have_http_status(:ok)
+    tel = response.parsed_body["telemetry"]
+    expect(tel["battery"]).to eq(81)
+    expect(tel["network"]).to eq("WiFi")
+    expect(tel["fps"]).to eq(30)
+    expect(tel["bitrate"]).to eq(2_400_000)
+    expect(tel["thermal_state"]).to eq("nominal")
+    expect(tel).to have_key("publisher_online")
+  end
 end

backend/spec/requests/public/support_page_spec.rb

@@ -0,0 +1,57 @@
+require "rails_helper"
+
+RSpec.describe "Public support page", type: :request do
+  it "è pubblica, indicizzabile e mostra l'email di supporto configurata" do
+    get public_support_path
+
+    expect(response).to have_http_status(:ok)
+    expect(response.body).to include(MatchLiveTv.support_email)
+    expect(response.body).to include("mailto:#{MatchLiveTv.support_email}")
+    expect(response.body).to include(I18n.t("legal.support.h1", locale: :it))
+    expect(response.body).to include('rel="canonical"')
+    expect(response.body).to include(public_support_path)
+    expect(response.body).to include(public_privacy_path)
+  end
+
+  it "non espone CTA o link commerciali (App Store Review)" do
+    get public_support_path
+    body = response.body
+
+    expect(body).not_to include(public_prezzi_path)
+    expect(body).not_to include(public_signup_path)
+    expect(body).not_to include('href="/prezzi"')
+    expect(body).not_to include('href="/signup"')
+    expect(body).not_to include(I18n.t("nav.signup", locale: :it))
+    expect(body).not_to include(I18n.t("nav.pricing", locale: :it))
+    expect(body).not_to include(I18n.t("common.pricing", locale: :it))
+    expect(body).not_to match(/\bPremium Light\b/i)
+    expect(body).not_to match(/\bPremium Full\b/i)
+    expect(body).not_to match(/\bpiano Free\b/i)
+    expect(body).not_to match(/\bAbbonati\b/i)
+    expect(body).not_to match(/\bAcquista\b/i)
+  end
+
+  {
+    "it" => "Supporto Match Live TV",
+    "en" => "Match Live TV Support",
+    "fr" => "Support Match Live TV",
+    "de" => "Match Live TV Support",
+    "es" => "Soporte Match Live TV"
+  }.each do |locale, heading|
+    it "renderizza correttamente in #{locale} senza translation missing" do
+      cookies[:mltv_locale] = locale
+      get public_support_path
+
+      expect(response).to have_http_status(:ok)
+      expect(response.body).to include(heading)
+      expect(response.body).not_to include("translation missing")
+    end
+  end
+
+  it "include /support nella sitemap" do
+    get "/sitemap.xml"
+
+    expect(response).to have_http_status(:ok)
+    expect(response.body).to include("#{MatchLiveTv.app_public_url.chomp('/')}/support")
+  end
+end

backend/spec/services/mediamtx/publisher_sync_spec.rb

@@ -1,7 +1,7 @@
 require "rails_helper"
 
 RSpec.describe Mediamtx::PublisherSync do
-  let(:user) { User.create!(email: "sync@test.com", name: "Sync", password: "Password123", role: "coach") }
+  let(:user) { User.create!(email: "sync@test.com", name: "Sync", password: "password123", role: "coach") }
   let(:club) { Club.create!(name: "Sync Club", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff") }
   let(:team) { club.teams.create!(name: "Under 16", sport: "volleyball") }
   let!(:match) { team.matches.create!(opponent_name: "Avversario") }
@@ -20,11 +20,8 @@ RSpec.describe Mediamtx::PublisherSync do
   before do
     Billing::AssignPlan.call(club: club, plan_slug: "premium_full")
     allow(Mediamtx::Client).to receive(:new).and_return(client)
-    allow(Mediamtx::Client).to receive(:for_session).and_return(client)
     allow(Mediamtx::PublisherOnline).to receive(:path_info).and_return(path_info)
     allow(Mediamtx::PublisherOnline).to receive(:active_path?).and_return(true)
-    allow(Mediamtx::PublisherOnline).to receive(:rtmp_publisher?).and_return(false)
-    allow(Mediamtx::PublisherOnline).to receive(:active?).and_return(true)
     allow_any_instance_of(described_class).to receive(:redis).and_return(redis)
     allow(client).to receive(:set_path_recording)
   end
@@ -39,7 +36,6 @@ RSpec.describe Mediamtx::PublisherSync do
 
   it "non abilita la registrazione in connecting senza publisher online" do
     allow(Mediamtx::PublisherOnline).to receive(:active_path?).and_return(false)
-    allow(Mediamtx::PublisherOnline).to receive(:active?).and_return(false)
     path_info["online"] = false
 
     described_class.new(session).call
@@ -57,7 +53,6 @@ RSpec.describe Mediamtx::PublisherSync do
   it "non disabilita la registrazione su reconnecting con publisher offline" do
     session.update!(status: "reconnecting")
     allow(Mediamtx::PublisherOnline).to receive(:active_path?).and_return(false)
-    allow(Mediamtx::PublisherOnline).to receive(:active?).and_return(false)
 
     described_class.new(session).call
 

backend/spec/services/ops/health_checks_spec.rb

@@ -25,7 +25,6 @@ RSpec.describe Ops::HealthChecks do
       %i[
         check_recordings_size check_postgres check_redis check_mediamtx check_garage
         check_sidekiq_heartbeat check_sidekiq_dead check_http_rails check_rails_latency
-        check_stream_overflow
       ].each do |method|
         allow_any_instance_of(described_class).to receive(method).and_return(
           described_class::Finding.new(
@@ -53,7 +52,6 @@ RSpec.describe Ops::HealthChecks do
       %i[
         check_recordings_size check_postgres check_redis check_mediamtx check_garage
         check_sidekiq_heartbeat check_sidekiq_dead check_http_rails check_rails_latency
-        check_stream_overflow
       ].each do |method|
         allow_any_instance_of(described_class).to receive(method).and_return(
           described_class::Finding.new(
@@ -67,7 +65,7 @@ RSpec.describe Ops::HealthChecks do
       summary = described_class.new.summary
 
       expect(summary[:status]).to eq("ok")
-      expect(summary[:checks].size).to eq(11)
+      expect(summary[:checks].size).to eq(10)
     end
 
     it "degraded quando la latenza p95 supera la soglia warning" do

backend/spec/services/sessions/select_quality_spec.rb

@@ -11,4 +11,11 @@ RSpec.describe Sessions::SelectQuality do
 
     expect(preset[:id]).to eq("1080p_30_4.5mbps")
   end
+
+  it "offre 1080p come qualità minima solo se la sessione è 1080p" do
+    expect(described_class.allowed_min_ids("720p_30_2.5mbps")).to eq(
+      %w[auto 720p_30_1.5mbps 720p_30_2.5mbps 720p_30_4mbps]
+    )
+    expect(described_class.allowed_min_ids("1080p_30_4.5mbps")).to include("1080p_30_4.5mbps")
+  end
 end

backend/spec/services/sessions/set_min_quality_spec.rb

@@ -0,0 +1,41 @@
+require "rails_helper"
+
+RSpec.describe Sessions::SetMinQuality do
+  let!(:user) { User.create!(email: "abr@test.it", name: "U", password: "Password123", role: "coach") }
+  let!(:club) { Club.create!(name: "C", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff") }
+  let!(:team) { club.teams.create!(name: "T", sport: "volleyball") }
+  let!(:match) { team.matches.create!(opponent_name: "Opp", sport: "volleyball") }
+  let!(:session) do
+    StreamSession.create!(
+      match: match,
+      user: user,
+      platform: "matchlivetv",
+      status: "live",
+      quality_preset: "720p_30_2.5mbps"
+    )
+  end
+
+  it "salva il pavimento e notifica i client" do
+    expect(SessionChannel).to receive(:broadcast_message).with(
+      session,
+      hash_including(action: "set_min_quality", min_quality_preset: "720p_30_1.5mbps")
+    )
+
+    described_class.new(session, preset: "720p_30_1.5mbps").call
+
+    expect(session.reload.min_quality_preset).to eq("720p_30_1.5mbps")
+    expect(session.stream_events.where(event_type: "quality_changed")).to exist
+  end
+
+  it "rifiuta 1080p se la sessione è 720p" do
+    expect {
+      described_class.new(session, preset: "1080p_30_4.5mbps").call
+    }.to raise_error(ArgumentError)
+  end
+
+  it "accetta auto come qualità minima" do
+    session.update!(min_quality_preset: "720p_30_1.5mbps")
+    described_class.new(session, preset: "auto").call
+    expect(session.reload.min_quality_preset).to eq("auto")
+  end
+end

backend/spec/services/streams/autoscaler_spec.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Streams::Autoscaler do
-  def with_env(vars)
-    previous = vars.keys.index_with { |k| ENV[k] }
-    vars.each { |k, v| ENV[k] = v }
-    yield
-  ensure
-    previous.each { |k, v| v.nil? ? ENV.delete(k) : ENV[k] = v }
-  end
-
-  let(:redis) { Redis.new(url: ENV.fetch("REDIS_URL", "redis://redis:6379/0")) }
-
-  before do
-    redis.del(Streams::Autoscaler::LOCK_KEY)
-    redis.del(Streams::Autoscaler::KILL_SWITCH_KEY)
-    redis.del(Streams::DnsProviders::Lab::REDIS_KEY)
-    StreamSession.where.not(stream_node_id: nil).update_all(stream_node_id: nil, status: "ended", ended_at: Time.current)
-    StreamNode.where.not(slug: Streams::NodeRegistry::HOME_SLUG).delete_all
-  end
-
-  it "is a no-op when disabled" do
-    with_env("STREAM_AUTOSCALE_ENABLED" => "0") do
-      result = described_class.reconcile!
-      expect(result.skipped).to eq(true)
-      expect(result.actions).to eq([])
-    end
-  end
-
-  it "scales out and creates a warm spare when free slots are low" do
-    with_env(
-      "STREAM_AUTOSCALE_ENABLED" => "1",
-      "STREAM_AUTOSCALE_SOFT_FREE_SLOTS" => "2",
-      "STREAM_AUTOSCALE_WARM_SPARE" => "1",
-      "STREAM_AUTOSCALE_KIND" => "lab",
-      "STREAM_AUTOSCALE_MAX_NODES" => "5",
-      "STREAM_CLOUD_PROVIDER" => "local_lab",
-      "STREAM_DNS_PROVIDER" => "lab",
-      "STREAM_NODE_HOME_MAX_PUBLISHERS" => "2",
-      "MEDIAMTX_API_URL" => "http://mtx-home:9997",
-      "MEDIAMTX_RTMP_URL" => "rtmp://home.example:1935",
-      "HLS_PUBLIC_URL" => "https://home.example/hls"
-    ) do
-      home = Streams::NodeRegistry.ensure_home_from_env!
-      user = User.create!(email: "as@example.com", name: "A", password: "Password123", role: "coach")
-      club = Club.create!(name: "AS", sport: "volleyball")
-      team = club.teams.create!(name: "T", sport: "volleyball", slug: "as-t")
-      match = team.matches.create!(opponent_name: "X", scheduled_at: 1.hour.from_now)
-      # Fill home (2/2) → free_slots=0
-      2.times do
-        StreamSession.create!(match: match, user: user, platform: "matchlivetv", status: "live", stream_node: home)
-      end
-
-      provisioner = instance_double(Streams::NodeProvisioner)
-      created = []
-      allow(provisioner).to receive(:provision_lab!) do
-        node = StreamNode.create!(
-          slug: "ingest-lab-#{created.size + 1}",
-          hostname: "h#{created.size}.lab",
-          role: "lab",
-          status: "ready",
-          provider: "local",
-          rtmp_base_url: "rtmp://h:1935",
-          hls_base_url: "https://h/hls",
-          api_base_url: "http://h:9997",
-          max_publishers: 2,
-          max_relays: 2
-        )
-        created << node
-        node
-      end
-
-      result = described_class.reconcile!(provisioner: provisioner)
-      expect(result.actions).to include(:scale_out)
-      expect(created.size).to eq(1)
-      expect(result.metrics[:free_slots]).to be >= 2
-
-      # Riempi il nodo overflow → spare_ready=0 ma carico presente → warm spare
-      StreamSession.create!(
-        match: match, user: user, platform: "matchlivetv", status: "live", stream_node: created.first
-      )
-      StreamSession.create!(
-        match: match, user: user, platform: "matchlivetv", status: "live", stream_node: created.first
-      )
-
-      result2 = described_class.reconcile!(provisioner: provisioner)
-      expect(result2.actions).to include(:warm_spare).or include(:scale_out)
-      expect(created.size).to be >= 2
-    end
-  end
-
-  it "scales in an idle overflow node when warm spare is not required" do
-    with_env(
-      "STREAM_AUTOSCALE_ENABLED" => "1",
-      "STREAM_AUTOSCALE_SOFT_FREE_SLOTS" => "0",
-      "STREAM_AUTOSCALE_WARM_SPARE" => "0",
-      "STREAM_AUTOSCALE_IDLE_MINUTES" => "0",
-      "STREAM_NODE_HOME_MAX_PUBLISHERS" => "6",
-      "MEDIAMTX_API_URL" => "http://mtx-home:9997",
-      "MEDIAMTX_RTMP_URL" => "rtmp://home.example:1935",
-      "HLS_PUBLIC_URL" => "https://home.example/hls"
-    ) do
-      Streams::NodeRegistry.ensure_home_from_env!
-      idle = StreamNode.create!(
-        slug: "ingest-lab-99",
-        hostname: "idle.lab",
-        role: "lab",
-        status: "ready",
-        provider: "local",
-        provider_instance_id: "sim-x",
-        rtmp_base_url: "rtmp://h:1935",
-        hls_base_url: "https://h/hls",
-        api_base_url: "http://h:9997",
-        max_publishers: 2,
-        max_relays: 2,
-        created_at: 2.hours.ago
-      )
-
-      provisioner = instance_double(Streams::NodeProvisioner)
-      allow(provisioner).to receive(:drain!)
-      expect(provisioner).to receive(:decommission!).with(idle)
-
-      result = described_class.reconcile!(provisioner: provisioner)
-      expect(result.actions.map(&:to_s)).to include("scale_in_ingest-lab-99")
-    end
-  end
-
-  it "skips when Redis kill-switch is engaged even if ENV is enabled" do
-    redis.del(described_class::KILL_SWITCH_KEY)
-    with_env("STREAM_AUTOSCALE_ENABLED" => "1") do
-      described_class.engage_kill_switch!
-      expect(described_class.enabled?).to eq(false)
-      result = described_class.reconcile!
-      expect(result.skipped).to eq(true)
-    ensure
-      described_class.clear_kill_switch!
-    end
-  end
-
-  it "blocks scale-out when next node would exceed monthly budget" do
-    with_env(
-      "STREAM_AUTOSCALE_ENABLED" => "1",
-      "STREAM_AUTOSCALE_SOFT_FREE_SLOTS" => "2",
-      "STREAM_AUTOSCALE_WARM_SPARE" => "0",
-      "STREAM_AUTOSCALE_KIND" => "lab",
-      "STREAM_AUTOSCALE_MAX_NODES" => "5",
-      "STREAM_AUTOSCALE_NODE_EUR_PER_HOUR" => "1",
-      "STREAM_AUTOSCALE_MONTHLY_BUDGET_EUR" => "10",
-      "STREAM_CLOUD_PROVIDER" => "local_lab",
-      "STREAM_DNS_PROVIDER" => "lab",
-      "STREAM_NODE_HOME_MAX_PUBLISHERS" => "1",
-      "MEDIAMTX_API_URL" => "http://mtx-home:9997",
-      "MEDIAMTX_RTMP_URL" => "rtmp://home.example:1935",
-      "HLS_PUBLIC_URL" => "https://home.example/hls"
-    ) do
-      StreamSession.where.not(stream_node_id: nil).update_all(stream_node_id: nil, status: "ended", ended_at: Time.current)
-      StreamNode.where.not(slug: Streams::NodeRegistry::HOME_SLUG).delete_all
-      home = Streams::NodeRegistry.ensure_home_from_env!
-      home.update!(max_publishers: 1)
-      user = User.create!(email: "budget@example.com", name: "B", password: "Password123", role: "coach")
-      club = Club.create!(name: "Budget", sport: "volleyball")
-      team = club.teams.create!(name: "T", sport: "volleyball", slug: "budget-t")
-      match = team.matches.create!(opponent_name: "X", scheduled_at: 1.hour.from_now)
-      StreamSession.create!(match: match, user: user, platform: "matchlivetv", status: "live", stream_node: home)
-
-      provisioner = instance_double(Streams::NodeProvisioner)
-      expect(provisioner).not_to receive(:provision_lab!)
-
-      result = described_class.reconcile!(provisioner: provisioner)
-      expect(result.actions).to include(:blocked_capacity)
-      # 0 overflow nodes → stima 0€ ≤ budget; il blocco è sul nodo successivo (+1)
-      expect(described_class.within_budget?(0)).to eq(true)
-      expect(described_class.within_budget?(1)).to eq(false)
-    end
-  end
-end

backend/spec/services/streams/cloud_providers/hetzner_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Streams::CloudProviders::Hetzner do
-  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
-  let(:conn) do
-    Faraday.new(url: Streams::CloudProviders::Hetzner::API) do |f|
-      f.request :json
-      f.response :json
-      f.adapter :test, stubs
-    end
-  end
-  let(:provider) { described_class.new(token: "test-token", conn: conn) }
-
-  def with_env(vars)
-    previous = vars.keys.index_with { |k| ENV[k] }
-    vars.each { |k, v| ENV[k] = v }
-    yield
-  ensure
-    previous.each { |k, v| v.nil? ? ENV.delete(k) : ENV[k] = v }
-  end
-
-  after { stubs.verify_stubbed_calls }
-
-  it "creates a server and waits until running" do
-    with_env(
-      "HCLOUD_LOCATION" => "nbg1",
-      "HCLOUD_SERVER_TYPE" => "cpx12",
-      "HCLOUD_IMAGE" => "debian-12",
-      "HCLOUD_SSH_KEY" => "matchlivetv-stream-hetzner"
-    ) do
-      stubs.post("https://api.hetzner.cloud/v1/servers") do |env|
-        body = JSON.parse(env.body)
-        expect(body["name"]).to eq("mltv-stream-ingest-01")
-        expect(body["location"]).to eq("nbg1")
-        [
-          201,
-          { "Content-Type" => "application/json" },
-          {
-            "server" => {
-              "id" => 42,
-              "name" => "mltv-stream-ingest-01",
-              "status" => "initializing",
-              "public_net" => { "ipv4" => { "ip" => "49.13.1.2" } },
-              "private_net" => []
-            },
-            "action" => { "id" => 7, "status" => "running" }
-          }
-        ]
-      end
-      stubs.get("https://api.hetzner.cloud/v1/actions/7") do
-        [200, { "Content-Type" => "application/json" }, { "action" => { "id" => 7, "status" => "success" } }]
-      end
-      stubs.get("https://api.hetzner.cloud/v1/servers/42") do
-        [
-          200,
-          { "Content-Type" => "application/json" },
-          {
-            "server" => {
-              "id" => 42,
-              "name" => "mltv-stream-ingest-01",
-              "status" => "running",
-              "public_net" => { "ipv4" => { "ip" => "49.13.1.2" } },
-              "private_net" => []
-            }
-          }
-        ]
-      end
-
-      instance = provider.create_node(name: "mltv-stream-ingest-01", labels: { role: "stream-node" })
-      expect(instance.id).to eq("42")
-      expect(instance.public_ip).to eq("49.13.1.2")
-      expect(instance.status).to eq("running")
-    end
-  end
-
-  it "destroys a server" do
-    stubs.delete("https://api.hetzner.cloud/v1/servers/42") { [204, {}, ""] }
-    expect(provider.destroy_node("42")).to eq(true)
-  end
-end

backend/spec/services/streams/dns_providers/hetzner_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Streams::DnsProviders::Hetzner do
-  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
-  let(:conn) do
-    Faraday.new(url: Streams::DnsProviders::Hetzner::API) do |f|
-      f.request :json
-      f.response :json
-      f.adapter :test, stubs
-    end
-  end
-  let(:provider) { described_class.new(token: "test-token", zone: "mltv-stream.net", conn: conn) }
-
-  after { stubs.verify_stubbed_calls }
-
-  it "upserts an A record (delete then create)" do
-    stubs.delete("https://api.hetzner.cloud/v1/zones/mltv-stream.net/rrsets/ingest-01/A") { [404, {}, ""] }
-    stubs.post("https://api.hetzner.cloud/v1/zones/mltv-stream.net/rrsets") do |env|
-      body = JSON.parse(env.body)
-      expect(body["name"]).to eq("ingest-01")
-      expect(body["type"]).to eq("A")
-      expect(body["records"].first["value"]).to eq("49.13.1.2")
-      [201, { "Content-Type" => "application/json" }, { "rrset" => { "name" => "ingest-01" } }]
-    end
-
-    expect(provider.upsert_a("ingest-01.mltv-stream.net", "49.13.1.2")).to eq(true)
-  end
-
-  it "deletes an A record" do
-    stubs.delete("https://api.hetzner.cloud/v1/zones/mltv-stream.net/rrsets/ingest-01/A") { [204, {}, ""] }
-    expect(provider.delete_a("ingest-01.mltv-stream.net")).to eq(true)
-  end
-end

backend/spec/services/streams/node_provisioner_cloud_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe "Streams::NodeProvisioner cloud" do
-  it "registers a cloud node using injected providers" do
-    cloud = instance_double(
-      Streams::CloudProviders::Hetzner,
-      create_node: Streams::CloudProviders::Instance.new(
-        id: "99",
-        name: "mltv-stream-ingest-01",
-        public_ip: "49.13.9.9",
-        private_ip: "10.0.0.9",
-        status: "running",
-        raw: {}
-      )
-    )
-    dns = instance_double(Streams::DnsProviders::Hetzner)
-    allow(dns).to receive(:upsert_a)
-
-    ENV["MEDIAMTX_API_URL"] = "http://mtx-home:9997"
-    ENV["MEDIAMTX_RTMP_URL"] = "rtmp://home.example:1935"
-    ENV["HLS_PUBLIC_URL"] = "https://home.example/hls"
-    ENV["STREAM_CLOUD_DNS_SUFFIX"] = "mltv-stream.net"
-    ENV["STREAM_CLOUD_MAX_PUBLISHERS"] = "4"
-
-    node = Streams::NodeProvisioner.new(cloud: cloud, dns: dns).provision_cloud!
-    expect(node.slug).to eq("ingest-01")
-    expect(node.role).to eq("cloud")
-    expect(node.provider).to eq("hetzner")
-    expect(node.hostname).to eq("ingest-01.mltv-stream.net")
-    expect(node.rtmp_base_url).to eq("rtmp://ingest-01.mltv-stream.net:1935")
-    expect(node.api_base_url).to eq("http://10.0.0.9:9997")
-    expect(dns).to have_received(:upsert_a).with("ingest-01.mltv-stream.net", "49.13.9.9")
-  ensure
-    %w[
-      MEDIAMTX_API_URL MEDIAMTX_RTMP_URL HLS_PUBLIC_URL
-      STREAM_CLOUD_DNS_SUFFIX STREAM_CLOUD_MAX_PUBLISHERS
-    ].each { |k| ENV.delete(k) }
-  end
-end

backend/spec/services/streams/node_provisioner_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Streams::NodeProvisioner do
-  def with_env(vars)
-    previous = vars.keys.index_with { |k| ENV[k] }
-    vars.each { |k, v| ENV[k] = v }
-    yield
-  ensure
-    previous.each { |k, v| v.nil? ? ENV.delete(k) : ENV[k] = v }
-  end
-
-  let(:redis) { Redis.new(url: ENV.fetch("REDIS_URL", "redis://redis:6379/0")) }
-
-  before do
-    redis.del(Streams::DnsProviders::Lab::REDIS_KEY)
-    StreamSession.where.not(stream_node_id: nil).update_all(stream_node_id: nil, status: "ended", ended_at: Time.current)
-    StreamNode.where.not(slug: Streams::NodeRegistry::HOME_SLUG).delete_all
-  end
-
-  it "provisions and decommissions a simulated lab node" do
-    with_env(
-      "STREAM_CLOUD_PROVIDER" => "local_lab",
-      "STREAM_DNS_PROVIDER" => "lab",
-      "STREAM_LAB_DNS_SUFFIX" => "lab.mltv-stream.net",
-      "MEDIAMTX_API_URL" => "http://mtx-home:9997",
-      "MEDIAMTX_RTMP_URL" => "rtmp://ingest-home.example:1935",
-      "HLS_PUBLIC_URL" => "https://ingest-home.example/hls",
-      "STREAM_LAB_MAX_PUBLISHERS" => "2"
-    ) do
-      provisioner = described_class.new
-      node = provisioner.provision_lab!
-
-      expect(node.slug).to eq("ingest-lab-01")
-      expect(node.role).to eq("lab")
-      expect(node.status).to eq("ready")
-      expect(node.hostname).to eq("ingest-lab-01.lab.mltv-stream.net")
-      expect(node.api_base_url).to eq("http://mtx-home:9997")
-      expect(Streams::DnsProviders::Lab.new.resolve(node.hostname)).to eq("127.0.0.1")
-
-      provisioner.decommission!(node)
-      expect(StreamNode.find_by(slug: "ingest-lab-01")).to be_nil
-      expect(Streams::DnsProviders::Lab.new.resolve("ingest-lab-01.lab.mltv-stream.net")).to be_nil
-    end
-  end
-
-  it "refuses to decommission a busy node" do
-    with_env(
-      "STREAM_CLOUD_PROVIDER" => "local_lab",
-      "STREAM_DNS_PROVIDER" => "lab",
-      "MEDIAMTX_API_URL" => "http://mtx-home:9997",
-      "MEDIAMTX_RTMP_URL" => "rtmp://ingest-home.example:1935",
-      "HLS_PUBLIC_URL" => "https://ingest-home.example/hls"
-    ) do
-      node = described_class.new.provision_lab!
-      user = User.create!(email: "lab@example.com", name: "L", password: "Password123", role: "coach")
-      club = Club.create!(name: "LabClub", sport: "volleyball")
-      team = club.teams.create!(name: "T", sport: "volleyball", slug: "lab-t")
-      match = team.matches.create!(opponent_name: "X", scheduled_at: 1.hour.from_now)
-      StreamSession.create!(match: match, user: user, platform: "matchlivetv", status: "live", stream_node: node)
-
-      expect { described_class.new.decommission!(node) }.to raise_error(Streams::NodeProvisioner::BusyError)
-    end
-  end
-end

backend/spec/services/streams/node_registry_spec.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_helper"
-
-RSpec.describe Streams::NodeRegistry do
-  def with_env(vars)
-    previous = vars.keys.index_with { |k| ENV[k] }
-    vars.each { |k, v| ENV[k] = v }
-    yield
-  ensure
-    previous.each { |k, v| v.nil? ? ENV.delete(k) : ENV[k] = v }
-  end
-
-  let(:home_env) do
-    {
-      "MEDIAMTX_API_URL" => "http://mtx-home:9997",
-      "MEDIAMTX_RTMP_URL" => "rtmp://ingest-home.example:1935",
-      "HLS_PUBLIC_URL" => "https://ingest-home.example/hls",
-      "MEDIAMTX_INTERNAL_RTMP_URL" => "rtmp://mtx-home:1935",
-      "MEDIAMTX_HLS_URL" => "http://mtx-home:8888",
-      "STREAM_NODE_HOME_MAX_PUBLISHERS" => "2"
-    }
-  end
-
-  before do
-    StreamSession.where.not(stream_node_id: nil).update_all(stream_node_id: nil, status: "ended", ended_at: Time.current)
-    StreamNode.where.not(slug: Streams::NodeRegistry::HOME_SLUG).delete_all
-    StreamNode.find_by(slug: Streams::NodeRegistry::HOME_SLUG)&.update!(max_publishers: 2, status: "ready")
-  end
-
-  it "creates home node from ENV" do
-    with_env(home_env) do
-      node = described_class.ensure_home_from_env!
-      expect(node.slug).to eq("home")
-      expect(node.rtmp_base_url).to eq("rtmp://ingest-home.example:1935")
-      expect(node.api_base_url).to eq("http://mtx-home:9997")
-      expect(node.max_publishers).to eq(2)
-      expect(node.status).to eq("ready")
-    end
-  end
-
-  it "does not reset home drain/offline/error status on ensure" do
-    with_env(home_env) do
-      home = described_class.ensure_home_from_env!
-      home.update!(status: "draining")
-
-      expect(described_class.ensure_home_from_env!.status).to eq("draining")
-      expect { described_class.allocate! }.to raise_error(Streams::NodeRegistry::NoCapacityError)
-    end
-  end
-
-  it "allocates the least loaded ready node" do
-    with_env(home_env) do
-      home = described_class.ensure_home_from_env!
-      cloud = StreamNode.create!(
-        slug: "ingest-01",
-        hostname: "ingest-01.mltv-stream.net",
-        role: "cloud",
-        status: "ready",
-        provider: "hetzner",
-        rtmp_base_url: "rtmp://ingest-01.mltv-stream.net:1935",
-        hls_base_url: "https://ingest-01.mltv-stream.net/hls",
-        api_base_url: "http://10.0.0.2:9997",
-        max_publishers: 2,
-        max_relays: 2
-      )
-
-      user = User.create!(email: "n@example.com", name: "N", password: "Password123", role: "coach")
-      club = Club.create!(name: "C", sport: "volleyball")
-      team = club.teams.create!(name: "T", sport: "volleyball", slug: "t-node")
-      match = team.matches.create!(opponent_name: "X", scheduled_at: 1.hour.from_now)
-
-      StreamSession.create!(
-        match: match, user: user, platform: "matchlivetv", status: "live", stream_node: home
-      )
-
-      expect(described_class.allocate!).to eq(cloud)
-    end
-  end
-
-  it "raises when no capacity remains" do
-    with_env(home_env.merge("STREAM_NODE_HOME_MAX_PUBLISHERS" => "1")) do
-      home = described_class.ensure_home_from_env!
-      user = User.create!(email: "full@example.com", name: "F", password: "Password123", role: "coach")
-      club = Club.create!(name: "Full", sport: "volleyball")
-      team = club.teams.create!(name: "T", sport: "volleyball", slug: "t-full")
-      match = team.matches.create!(opponent_name: "X", scheduled_at: 1.hour.from_now)
-      StreamSession.create!(
-        match: match, user: user, platform: "matchlivetv", status: "live", stream_node: home
-      )
-
-      expect { described_class.allocate! }.to raise_error(Streams::NodeRegistry::NoCapacityError)
-    end
-  end
-end

backend/spec/services/streams/youtube_relay_spec.rb

@@ -21,46 +21,4 @@ RSpec.describe Streams::YoutubeRelay do
       expect(cmd).not_to include("-b:a")
     end
   end
-
-  describe "multi-host sticky stop/capacity" do
-    let(:redis) { Redis.new(url: ENV.fetch("REDIS_URL", "redis://redis:6379/0")) }
-    let(:session_id) { SecureRandom.uuid }
-
-    before do
-      allow(described_class).to receive(:worker?).and_return(true)
-      allow(described_class).to receive(:worker_id).and_return("worker-a")
-      allow(described_class).to receive(:max_concurrent).and_return(1)
-      redis.flushdb
-    end
-
-    def session_double
-      instance_double(
-        StreamSession,
-        id: session_id,
-        platform: "youtube",
-        terminal?: false,
-        stream_key: "yt-key",
-        status: "live"
-      )
-    end
-
-    it "does not stop ffmpeg owned by another worker" do
-      redis.set(format(Streams::YoutubeRelay::OWNER_KEY, session_id), "worker-b", ex: 3600)
-      redis.set(format(Streams::YoutubeRelay::REDIS_KEY, session_id), "12345", ex: 3600)
-
-      expect(described_class.stop_on_worker!(session_double)).to eq(:wrong_host)
-      expect(redis.get(format(Streams::YoutubeRelay::OWNER_KEY, session_id))).to eq("worker-b")
-    end
-
-    it "requeues ensure when at capacity" do
-      other_id = SecureRandom.uuid
-      redis.sadd(format(Streams::YoutubeRelay::OWNED_SET, "worker-a"), other_id)
-      allow(described_class).to receive(:intake_available?).and_return(true)
-      expect(YoutubeRelayEnsureJob).to receive(:set).with(hash_including(wait: 5.seconds, queue: :youtube_relay)).and_return(
-        double(perform_later: true)
-      )
-
-      expect(described_class.ensure_on_worker!(session_double)).to eq(:at_capacity)
-    end
-  end
 end

docs/ARCHITECTURE.md

@@ -2,8 +2,8 @@
 
 Documento di riferimento per l'intero sistema: rete, container Docker, flussi video, replay, monitoraggio ops e rilasci.
 
-**Ultimo aggiornamento:** 2026-08-09  
+**Ultimo aggiornamento:** 2026-07-29  
-**Produzione:** `eminux@192.168.1.146` → `/opt/matchlivetv` (Proxmox; control plane attuale per autoscale)
+**Produzione:** `eminux@192.168.1.146` → `/opt/matchlivetv`
 
 ---
 
@@ -397,8 +397,7 @@ cd infra && cp .env.example .env && docker compose up -d --build
 | Documento | Contenuto |
 |-----------|-----------|
 | [`infrastructure/SERVER_DEPLOYMENT.md`](infrastructure/SERVER_DEPLOYMENT.md) | Bootstrap server, NPM, cron, backup |
-| [`infrastructure/STREAMING_AUTOSCALE.md`](infrastructure/STREAMING_AUTOSCALE.md) | **Design attuale:** Proxmox prod + Hetzner Cloud warm spare (MediaMTX+ffmpeg), lab, DNS, disco; Auction in futuro |
+| [`infrastructure/HETZNER_CLOUD_RELAY_OVERFLOW.md`](infrastructure/HETZNER_CLOUD_RELAY_OVERFLOW.md) | Piano overflow relay YouTube su Hetzner Cloud (picchi) |
-| [`infrastructure/HETZNER_CLOUD_RELAY_OVERFLOW.md`](infrastructure/HETZNER_CLOUD_RELAY_OVERFLOW.md) | Piano storico overflow-only relay YouTube (superseded dal doc sopra) |
 | [`ANDROID_APP_LINKS.md`](ANDROID_APP_LINKS.md) | Digital Asset Links / deep link Play (`assetlinks.json`) |
 | [`LIVE_STREAMING.md`](LIVE_STREAMING.md) | MediaMTX, pausa, HLS, ruolo ffmpeg |
 | [`REPLAY_MODULE.md`](REPLAY_MODULE.md) | Garage, retention, YouTube VOD |
@@ -421,4 +420,3 @@ cd infra && cp .env.example .env && docker compose up -d --build
 | 2026-06 | Cleanup path MediaMTX orfani (`Mediamtx::CleanupOrphanPaths`); delete path sempre a fine diretta |
 | 2026-07 | Rimosso overlay server (`OverlayRelay`); tabellone bruciato in app; HLS su path camera (non `*_air`); `YoutubeRelay` = copy video + AAC |
 | 2026-08 | `YoutubeRelay` = remux copy video+audio (niente ricodifica AAC); profilo app/slate AAC 48k mono |
-| 2026-08 | Design autoscale: Proxmox prod + Hetzner Cloud warm spare (MediaMTX+ffmpeg), lab locale, secondo dominio DNS, Garage ora / B2 dopo; Auction rimandato (`STREAMING_AUTOSCALE.md`) |