Aggiunge il mute del microfono in diretta per evitare claim YouTube sulla musica in palestra.

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

backend/app/channels/session_channel.rb

@@ -55,6 +55,10 @@ class SessionChannel < ApplicationCable::Channel
       Sessions::Pause.new(session).call
     when "resume_stream"
       Sessions::Resume.new(session).call
+    when "mute_audio"
+      Sessions::SetAudioMute.new(session, muted: true).call
+    when "unmute_audio"
+      Sessions::SetAudioMute.new(session, muted: false).call
     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

@@ -34,6 +34,12 @@ module Api
         render json: session_json(@session)
       end
 
+      def audio_mute
+        muted = params.key?(:muted) ? params[:muted] : true
+        Sessions::SetAudioMute.new(@session, muted: muted).call
+        render json: session_json(@session)
+      end
+
       def score
         Scoring::SyncState.new(session: @session, payload: score_sync_params).call
         render json: session_json(@session, detail: true)
@@ -180,7 +186,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,
@@ -190,7 +195,8 @@ module Api
           quality_preset: session.quality_preset,
           target_bitrate: session.target_bitrate,
           started_at: session.started_at,
-          disconnection_count: session.disconnection_count
+          disconnection_count: session.disconnection_count,
+          audio_muted: session.audio_muted
         }
         if detail
           data[:score] = session.score_state&.as_cable_payload

backend/app/controllers/public/pages_controller.rb

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

backend/app/controllers/public/regia_controller.rb

@@ -7,7 +7,7 @@ module Public
     layout "regia"
 
     protect_from_forgery with: :null_session
-    skip_before_action :verify_authenticity_token, only: %i[score pause resume stop]
+    skip_before_action :verify_authenticity_token, only: %i[score pause resume stop audio_mute]
 
     before_action :set_session_from_token
 
@@ -61,6 +61,12 @@ module Public
       render json: status_payload
     end
 
+    def audio_mute
+      muted = params.key?(:muted) ? params[:muted] : !@session.audio_muted
+      Sessions::SetAudioMute.new(@session, muted: muted).call
+      render json: status_payload
+    end
+
     private
 
     def set_session_from_token
@@ -78,6 +84,7 @@ module Public
       {
         status: @session.status,
         paused: @session.paused?,
+        audio_muted: @session.audio_muted,
         stream_closed: closed,
         live: !closed && (@session.live? || @session.paused? || publisher_online),
         on_air: playable || (!closed && @session.status.in?(%w[connecting live reconnecting paused])),

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

@@ -44,9 +44,12 @@ module Public
         partialsPrefix: t("regia.board.partials_prefix"),
         resumed: t("regia.js.resumed"),
         pausedCover: t("regia.js.paused_cover"),
+        muted: t("regia.js.muted"),
+        unmuted: t("regia.js.unmuted"),
         closed: t("regia.js.closed"),
         resumeError: t("regia.js.resume_error"),
         pauseError: t("regia.js.pause_error"),
+        muteError: t("regia.js.mute_error"),
         closeError: t("regia.js.close_error"),
         closeConfirm: t("regia.js.close_confirm"),
         linkUnavailable: t("regia.js.link_unavailable"),
@@ -58,6 +61,8 @@ module Public
         streamEnded: t("regia.preview_ended"),
         resumeLabel: t("regia.resume"),
         pauseLabel: t("regia.pause"),
+        muteLabel: t("regia.mute"),
+        unmuteLabel: t("regia.unmute"),
         endedBadge: t("regia.status.ended"),
         pausedBadge: t("regia.status.paused"),
         liveBadge: t("regia.status.live"),

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, attempts = 0)
+  def perform(session_id)
     session = StreamSession.find_by(id: session_id)
     return unless session
 
-    unless Streams::YoutubeRelay.worker?
-      # Solo i worker relay processano questa coda in modo utile.
-      return
-    end
-
-    result = Streams::YoutubeRelay.stop_on_worker!(session)
-    return unless result == :wrong_host
-    return if attempts >= 30
-
-    self.class.set(wait: 2.seconds).perform_later(session_id, attempts + 1)
+    Streams::YoutubeRelay.stop_on_worker!(session) if Streams::YoutubeRelay.worker?
   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_event.rb

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

backend/app/models/stream_node.rb

@@ -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
@@ -75,7 +74,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 +90,8 @@ class StreamSession < ApplicationRecord
   end
 
   def hls_playback_url
-    "#{hls_base_url.chomp('/')}/#{effective_hls_path_name}/index.m3u8"
-  end
-
-  def rtmp_base_url
-    stream_node&.rtmp_base_url.presence || MatchLiveTv.mediamtx_rtmp_url
-  end
-
-  def hls_base_url
-    stream_node&.hls_base_url.presence || MatchLiveTv.hls_public_url
-  end
-
-  def mediamtx_api_base_url
-    stream_node&.api_base_url.presence || MatchLiveTv.mediamtx_api_url
-  end
-
-  def mediamtx_internal_rtmp_url
-    stream_node&.internal_rtmp_url.presence ||
-      ENV.fetch("MEDIAMTX_INTERNAL_RTMP_URL", "rtmp://mediamtx:1935")
-  end
-
-  def mediamtx_internal_hls_url
-    stream_node&.internal_hls_url.presence ||
-      ENV.fetch("MEDIAMTX_HLS_URL", "http://mediamtx:8888")
+    base = MatchLiveTv.hls_public_url.chomp("/")
+    "#{base}/#{effective_hls_path_name}/index.m3u8"
   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
-    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
+      info["online"] == true && info.dig("source", "type") == "rtmpConn"
     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)
-      h264_video?(info)
-    end
+      return false unless active_path?(info)
+      # Slate alwaysAvailable ha H264 ma non è il telefono.
+      return false unless info.dig("source", "type") == "rtmpConn"
 
-    def rtmp_source?(type)
-      type.to_s.match?(/\Artmps?Conn\z/)
+      h264_video?(info)
     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_stream_overflow
+        check_rails_latency
       ]
       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)
-        log_event(
-          session,
-          "pairing",
-          {
-            created: true,
-            platform: session.platform,
-            stream_node: session.stream_node&.slug
-          }
-        )
+        mtx = Mediamtx::Client.new
+        mtx.create_path(session)
+        log_event(session, "pairing", { created: true, platform: session.platform })
       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,11 @@ 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)
+        Mediamtx::Client.new.set_path_recording(@session, enabled: false)
       rescue Mediamtx::Client::Error => e
         Rails.logger.warn("[Sessions::Pause] disable recording: #{e.message}")
       end
-      Mediamtx::Client.for_session(@session).set_always_available(@session, enabled: true)
+      Mediamtx::Client.new.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/set_audio_mute.rb

@@ -0,0 +1,28 @@
+module Sessions
+  # Silenzia o riattiva il microfono della camera in onda.
+  # Lo stream continua a inviare AAC silenzioso (YouTube/MediaMTX richiedono la traccia audio).
+  class SetAudioMute
+    def initialize(session, muted:)
+      @session = session
+      @muted = ActiveModel::Type::Boolean.new.cast(muted)
+    end
+
+    def call
+      return @session if @session.audio_muted == @muted
+
+      @session.update!(audio_muted: @muted)
+      action = @muted ? "mute_audio" : "unmute_audio"
+      event_type = @muted ? "audio_muted" : "audio_unmuted"
+      log_event(event_type)
+      SessionChannel.broadcast_message(@session, { type: "command", action: action, muted: @muted })
+      SessionChannel.broadcast_message(@session, { type: "stream_event", event: "audio_muted", muted: @muted })
+      @session
+    end
+
+    private
+
+    def log_event(type)
+      @session.stream_events.create!(event_type: type, occurred_at: Time.current, metadata: { muted: @muted })
+    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,66 +0,0 @@
-# frozen_string_literal: true
-
-module Streams
-  # Assegna un StreamNode a una nuova sessione.
-  # Preferisce home finché ha slot; poi least-loaded tra i nodi overflow 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!
-
-        # Overflow: riempi prima home; i nodi cloud/lab sono solo quando home è pieno
-        # (altrimenti lo warm spare ruberebbe tutte le sessioni).
-        home = StreamNode.find_by(slug: HOME_SLUG)
-        return home if home&.allocatable?
-
-        node = StreamNode.ready
-          .where.not(slug: HOME_SLUG)
-          .to_a
-          .select(&:allocatable?)
-          .min_by { |n| [n.active_publishers, 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_local_ownership(session.id)
-        end
+        clear_pid(session.id) if pid.present? && !process_alive?(pid.to_i)
 
-        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
+        return if running?(session.id)
 
         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?
-          clear_local_ownership(session.id)
-          return :noop
-        end
+        return false if pid.blank?
 
         terminate_pid(pid)
-        clear_local_ownership(session.id)
-        Rails.logger.info("[YoutubeRelay] stopped pid=#{pid} session=#{session.id} worker=#{worker_id}")
-        :stopped
-      end
-
-      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
+        clear_pid(session.id)
+        redis.del(format(OWNER_KEY, session.id))
+        Rails.logger.info("[YoutubeRelay] stopped pid=#{pid} session=#{session.id}")
+        true
       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)
-        Rails.logger.info("[YoutubeRelay] started pid=#{pid} session=#{session.id} intake=#{intake_source.join(":")} worker=#{worker_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(":")}")
         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/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/show.html.erb

@@ -15,6 +15,7 @@
      data-score-url="<%= j public_regia_score_path(params[:token]) %>"
      data-pause-url="<%= j public_regia_pause_path(params[:token]) %>"
      data-resume-url="<%= j public_regia_resume_path(params[:token]) %>"
+     data-audio-mute-url="<%= j public_regia_audio_mute_path(params[:token]) %>"
      data-stop-url="<%= j public_regia_stop_path(params[:token]) %>"
      data-cable-url="<%= j "/cable?regia_token=#{params[:token]}" %>"
      data-hls-url="<%= j @session.hls_playback_url %>"
@@ -26,7 +27,8 @@
      data-live-share-title="<%= j @live_share_title %>"
      data-points-target="<%= @match.effective_board_type.in?(%w[volley racket]) ? Scoring::Rules.from_match(@match).points_target(@score.current_set) : 0 %>"
      data-stream-closed="<%= @stream_closed %>"
-     data-initial-paused="<%= @session.paused? %>">
+     data-initial-paused="<%= @session.paused? %>"
+     data-initial-audio-muted="<%= @session.audio_muted %>">
 
   <header class="regia-header">
     <h1><%= @team.name %> vs <%= @match.opponent_name %></h1>
@@ -77,6 +79,7 @@
 
   <% unless @stream_closed %>
     <button type="button" class="regia-btn regia-btn--outline" id="btn-pause"><%= @session.paused? ? t("regia.resume") : t("regia.pause") %></button>
+    <button type="button" class="regia-btn regia-btn--outline<%= @session.audio_muted ? ' is-muted' : '' %>" id="btn-audio-mute"><%= @session.audio_muted ? t("regia.unmute") : t("regia.mute") %></button>
     <button type="button" class="regia-btn regia-btn--danger" id="btn-stop"><%= t("regia.stop") %></button>
   <% end %>
 </div>
@@ -94,4 +97,4 @@
   </div>
 </div>
 
-<script src="/regia.js?v=8"></script>
+<script src="/regia.js?v=9"></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/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

@@ -441,6 +441,8 @@ de:
     preview_waiting: Vorschau wartet auf Signal…
     pause: Pausieren
     resume: Livestream fortsetzen
+    mute: Audio stummschalten
+    unmute: Audio einschalten
     stop: Livestream beenden
     modal:
       set_won_title: Satz gewonnen
@@ -476,9 +478,12 @@ de:
       unknown_period: "—"
       resumed: Übertragung fortgesetzt
       paused_cover: "Übertragung pausiert — Deckbild auf Sendung"
+      muted: "Audio stumm — YouTube empfängt das Mikrofon nicht"
+      unmuted: "Mikrofon-Audio wieder aktiv"
       closed: Übertragung beendet
       resume_error: Fehler beim Fortsetzen der Übertragung
       pause_error: Fehler beim Pausieren der Übertragung
+      mute_error: Fehler beim Stummschalten
       close_error: Fehler beim Beenden
       close_confirm: Übertragung endgültig beenden?
       link_unavailable: Link nicht verfügbar

backend/config/locales/app.en.yml

@@ -436,6 +436,8 @@ en:
     preview_waiting: Waiting for signal…
     pause: Pause stream
     resume: Resume stream
+    mute: Mute audio
+    unmute: Unmute audio
     stop: End stream
     modal:
       set_won_title: Set won
@@ -471,9 +473,12 @@ en:
       unknown_period: "—"
       resumed: Stream resumed
       paused_cover: "Stream paused — cover on air"
+      muted: "Audio muted — YouTube is not receiving the microphone"
+      unmuted: "Microphone audio restored"
       closed: Stream closed
       resume_error: Error resuming the stream
       pause_error: Error pausing the stream
+      mute_error: Error muting audio
       close_error: Error closing
       close_confirm: Permanently close the live stream?
       link_unavailable: Link not available

backend/config/locales/app.es.yml

@@ -441,6 +441,8 @@ es:
     preview_waiting: Vista previa a la espera de señal…
     pause: Pausar directo
     resume: Reanudar directo
+    mute: Silenciar audio
+    unmute: Reactivar audio
     stop: Finalizar directo
     modal:
       set_won_title: Set ganado
@@ -476,9 +478,12 @@ es:
       unknown_period: "—"
       resumed: Retransmisión reanudada
       paused_cover: "Retransmisión en pausa — cortinilla al aire"
+      muted: "Audio silenciado — YouTube no recibe el micrófono"
+      unmuted: "Audio del micrófono reactivado"
       closed: Retransmisión finalizada
       resume_error: Error al reanudar la retransmisión
       pause_error: Error al pausar la retransmisión
+      mute_error: Error al silenciar el audio
       close_error: Error al cerrar
       close_confirm: "¿Cerrar definitivamente la retransmisión?"
       link_unavailable: Enlace no disponible

backend/config/locales/app.fr.yml

@@ -441,6 +441,8 @@ fr:
     preview_waiting: Aperçu en attente du signal…
     pause: Mettre en pause
     resume: Reprendre le direct
+    mute: Couper l'audio
+    unmute: Réactiver l'audio
     stop: Terminer le direct
     modal:
       set_won_title: Set gagné
@@ -476,9 +478,12 @@ fr:
       unknown_period: "—"
       resumed: Direct repris
       paused_cover: "Direct en pause — habillage à l'antenne"
+      muted: "Audio coupé — YouTube ne reçoit pas le micro"
+      unmuted: "Audio du micro rétabli"
       closed: Direct terminé
       resume_error: Erreur lors de la reprise du direct
       pause_error: Erreur lors de la mise en pause du direct
+      mute_error: Erreur lors de la coupure audio
       close_error: Erreur de clôture
       close_confirm: Clôturer définitivement le direct ?
       link_unavailable: Lien non disponible

backend/config/locales/app.it.yml

@@ -436,6 +436,8 @@ it:
     preview_waiting: Anteprima in attesa del segnale…
     pause: Metti in pausa
     resume: Riprendi diretta
+    mute: Silenzia audio
+    unmute: Riattiva audio
     stop: Chiudi diretta
     modal:
       set_won_title: Set vinto
@@ -471,9 +473,12 @@ it:
       unknown_period: "—"
       resumed: Diretta ripresa
       paused_cover: "Diretta in pausa — copertina in onda"
+      muted: "Audio silenziato — YouTube non riceve il microfono"
+      unmuted: "Audio microfono riattivato"
       closed: Diretta chiusa
       resume_error: Errore ripresa diretta
       pause_error: Errore pausa diretta
+      mute_error: Errore silenziamento audio
       close_error: Errore chiusura
       close_confirm: Chiudere definitivamente la diretta?
       link_unavailable: Link non disponibile

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

@@ -47,6 +47,7 @@ Rails.application.routes.draw do
           patch :stop
           patch :pause
           patch :resume
+          patch :audio_mute
           patch :score
           post :score_action
           get :events
@@ -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
 
@@ -151,6 +143,7 @@ Rails.application.routes.draw do
   patch "regia/:token/score", to: "public/regia#score", as: :public_regia_score
   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/audio_mute", to: "public/regia#audio_mute", as: :public_regia_audio_mute
   post "regia/:token/stop", to: "public/regia#stop", as: :public_regia_stop
 
   root to: "public/pages#home"
@@ -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/20260812220000_add_audio_muted_to_stream_sessions.rb

@@ -0,0 +1,5 @@
+class AddAudioMutedToStreamSessions < ActiveRecord::Migration[7.2]
+  def change
+    add_column :stream_sessions, :audio_muted, :boolean, default: false, null: false
+  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_12_220000) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "pgcrypto"
   enable_extension "plpgsql"
@@ -255,29 +255,6 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_09_120000) do
     t.index ["stream_session_id"], name: "index_stream_events_on_stream_session_id"
   end
 
-  create_table "stream_nodes", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
-    t.string "slug", null: false
-    t.string "hostname", null: false
-    t.string "role", default: "home", null: false
-    t.string "status", default: "ready", null: false
-    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", default: 6, null: false
-    t.integer "max_relays", default: 6, null: false
-    t.string "provider", default: "local", null: false
-    t.string "provider_instance_id"
-    t.datetime "last_health_at"
-    t.jsonb "metadata", default: {}, null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["role"], name: "index_stream_nodes_on_role"
-    t.index ["slug"], name: "index_stream_nodes_on_slug", unique: true
-    t.index ["status"], name: "index_stream_nodes_on_status"
-  end
-
   create_table "stream_sessions", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
     t.uuid "match_id", null: false
     t.uuid "user_id", null: false
@@ -303,12 +280,11 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_09_120000) do
     t.datetime "updated_at", null: false
     t.string "regia_token_digest"
     t.datetime "regia_token_expires_at"
-    t.uuid "stream_node_id"
+    t.boolean "audio_muted", default: false, 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
     t.index ["status"], name: "index_stream_sessions_on_status"
-    t.index ["stream_node_id"], name: "index_stream_sessions_on_stream_node_id"
     t.index ["user_id"], name: "index_stream_sessions_on_user_id"
   end
 
@@ -436,7 +412,6 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_09_120000) do
   add_foreign_key "score_states", "stream_sessions"
   add_foreign_key "stream_events", "stream_sessions"
   add_foreign_key "stream_sessions", "matches"
-  add_foreign_key "stream_sessions", "stream_nodes"
   add_foreign_key "stream_sessions", "users"
   add_foreign_key "subscriptions", "admin_accounts", column: "admin_comped_by_id"
   add_foreign_key "subscriptions", "clubs"

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

@@ -165,6 +165,10 @@
   width: 100%;
   margin-top: 8px;
 }
+.regia-btn--outline.is-muted {
+  border-color: var(--regia-yellow);
+  color: var(--regia-yellow);
+}
 .regia-btn--danger {
   background: transparent;
   border: 1px solid var(--regia-red);

backend/public/regia.js

@@ -25,9 +25,12 @@
     partialsPrefix: "Parziali:",
     resumed: "Diretta ripresa",
     pausedCover: "Diretta in pausa — copertina in onda",
+    muted: "Audio silenziato — YouTube non riceve il microfono",
+    unmuted: "Audio microfono riattivato",
     closed: "Diretta chiusa",
     resumeError: "Errore ripresa diretta",
     pauseError: "Errore pausa diretta",
+    muteError: "Errore silenziamento audio",
     closeError: "Errore chiusura",
     closeConfirm: "Chiudere definitivamente la diretta?",
     linkUnavailable: "Link non disponibile",
@@ -39,6 +42,8 @@
     streamEnded: "Diretta terminata",
     resumeLabel: "Riprendi diretta",
     pauseLabel: "Metti in pausa",
+    muteLabel: "Silenzia audio",
+    unmuteLabel: "Riattiva audio",
     endedBadge: "Terminata",
     pausedBadge: "In pausa",
     liveBadge: "In onda",
@@ -76,6 +81,7 @@
     scoreUrl: root.dataset.scoreUrl,
     pauseUrl: root.dataset.pauseUrl,
     resumeUrl: root.dataset.resumeUrl,
+    audioMuteUrl: root.dataset.audioMuteUrl,
     stopUrl: root.dataset.stopUrl,
     cableUrl: root.dataset.cableUrl,
     hlsUrl: root.dataset.hlsUrl,
@@ -103,6 +109,7 @@
     preview: document.getElementById("regia-preview"),
     previewPlaceholder: document.getElementById("regia-preview-placeholder"),
     btnPause: document.getElementById("btn-pause"),
+    btnAudioMute: document.getElementById("btn-audio-mute"),
     subtitle: document.getElementById("regia-subtitle")
   };
 
@@ -111,6 +118,7 @@
   let previewStarted = false;
   let wasPausedPreview = false;
   let streamPaused = root.dataset.initialPaused === "true";
+  let audioMuted = root.dataset.initialAudioMuted === "true";
 
   function hlsUrlFresh() {
     const sep = cfg.hlsUrl.includes("?") ? "&" : "?";
@@ -246,8 +254,18 @@
     els.btnPause.textContent = paused ? I18N.resumeLabel : I18N.pauseLabel;
   }
 
+  function syncMuteButton(data) {
+    if (!els.btnAudioMute) return;
+    if (typeof data.audio_muted === "boolean") {
+      audioMuted = data.audio_muted;
+    }
+    els.btnAudioMute.textContent = audioMuted ? I18N.unmuteLabel : I18N.muteLabel;
+    els.btnAudioMute.classList.toggle("is-muted", audioMuted);
+  }
+
   function setBadge(data) {
     syncPauseButton(data);
+    syncMuteButton(data);
     if (data.stream_closed) {
       els.badge.textContent = I18N.endedBadge;
       els.badge.className = "regia-badge regia-badge--ended";
@@ -458,6 +476,24 @@
     toast(wasPaused ? I18N.resumed : I18N.pausedCover);
   }
 
+  async function toggleMuteAudio() {
+    if (!cfg.audioMuteUrl) return;
+    const nextMuted = !audioMuted;
+    const res = await fetch(cfg.audioMuteUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({ muted: nextMuted })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error || I18N.muteError);
+    }
+    const data = await res.json();
+    applyScorePayload(data);
+    setBadge(data);
+    toast(audioMuted ? I18N.muted : I18N.unmuted);
+  }
+
   async function stopStream() {
     const ok = confirm(I18N.closeConfirm);
     if (!ok) return null;
@@ -471,6 +507,7 @@
   }
 
   els.btnPause?.addEventListener("click", () => togglePauseStream().catch((e) => toast(e.message)));
+  els.btnAudioMute?.addEventListener("click", () => toggleMuteAudio().catch((e) => toast(e.message)));
   document.getElementById("btn-stop")?.addEventListener("click", () => stopStream().catch((e) => toast(e.message)));
 
   async function shareLink(url, title, text) {

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/api/v1/stream_sessions_audio_mute_spec.rb

@@ -0,0 +1,37 @@
+require "rails_helper"
+
+RSpec.describe "Api::V1 stream session audio mute", type: :request do
+  let!(:user) { User.create!(email: "mute-api@test.it", name: "U", password: "Password123", role: "coach") }
+  let!(:club) { Club.create!(name: "C", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff") }
+  let!(:owner) { club.club_memberships.create!(user: user, role: "owner") }
+  let!(:team) { club.teams.create!(name: "T", sport: "volleyball") }
+  let!(:match) { team.matches.create!(opponent_name: "Opp", sport: "volleyball") }
+  let!(:session) { StreamSession.create!(match: match, user: user, platform: "youtube", status: "live") }
+
+  def auth_headers
+    post "/api/v1/auth/login", params: { email: user.email, password: "Password123" }
+    token = response.parsed_body["access_token"]
+    { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" }
+  end
+
+  it "include audio_muted nello show della sessione" do
+    get "/api/v1/sessions/#{session.id}", headers: auth_headers
+    expect(response).to have_http_status(:ok)
+    expect(response.parsed_body["audio_muted"]).to eq(false)
+  end
+
+  it "silenzia e riattiva l'audio via PATCH" do
+    patch "/api/v1/sessions/#{session.id}/audio_mute",
+          params: { muted: true }.to_json,
+          headers: auth_headers
+    expect(response).to have_http_status(:ok)
+    expect(response.parsed_body["audio_muted"]).to eq(true)
+    expect(session.reload.audio_muted).to eq(true)
+
+    patch "/api/v1/sessions/#{session.id}/audio_mute",
+          params: { muted: false }.to_json,
+          headers: auth_headers
+    expect(response).to have_http_status(:ok)
+    expect(response.parsed_body["audio_muted"]).to eq(false)
+  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") }
@@ -148,6 +148,29 @@ RSpec.describe "Public regia", type: :request do
     expect(session.reload.status).to eq("connecting")
   end
 
+  it "silenzia e riattiva l'audio della diretta" do
+    token = Sessions::RegiaAccess.new(session).issue_token!
+    expect(session.audio_muted).to eq(false)
+
+    post public_regia_audio_mute_path(token), params: { muted: true }, as: :json
+    expect(response).to have_http_status(:ok)
+    expect(response.parsed_body["audio_muted"]).to eq(true)
+    expect(session.reload.audio_muted).to eq(true)
+
+    post public_regia_audio_mute_path(token), params: { muted: false }, as: :json
+    expect(response).to have_http_status(:ok)
+    expect(response.parsed_body["audio_muted"]).to eq(false)
+    expect(session.reload.audio_muted).to eq(false)
+  end
+
+  it "mostra il pulsante mute sulla pagina regia" do
+    token = Sessions::RegiaAccess.new(session).issue_token!
+    get public_regia_path(token)
+    expect(response).to have_http_status(:ok)
+    expect(response.body).to include("Silenzia audio")
+    expect(response.body).to include("btn-audio-mute")
+  end
+
   it "emette token valido anche oltre le 8 ore dalla partenza" do
     session.update!(started_at: 9.hours.ago)
     token = Sessions::RegiaAccess.new(session).issue_token!

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/set_audio_mute_spec.rb

@@ -0,0 +1,27 @@
+require "rails_helper"
+
+RSpec.describe Sessions::SetAudioMute do
+  let!(:user) { User.create!(email: "mute@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) { StreamSession.create!(match: match, user: user, platform: "matchlivetv", status: "live") }
+
+  it "attiva il mute e persiste lo stato" do
+    described_class.new(session, muted: true).call
+    expect(session.reload.audio_muted).to eq(true)
+    expect(session.stream_events.order(:occurred_at).last.event_type).to eq("audio_muted")
+  end
+
+  it "disattiva il mute" do
+    session.update!(audio_muted: true)
+    described_class.new(session, muted: false).call
+    expect(session.reload.audio_muted).to eq(false)
+    expect(session.stream_events.order(:occurred_at).last.event_type).to eq("audio_unmuted")
+  end
+
+  it "è idempotente se lo stato è già quello richiesto" do
+    described_class.new(session, muted: false).call
+    expect(session.stream_events.count).to eq(0)
+  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,133 +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 "prefers home while it still has free slots even if cloud is idle" do
-    with_env(home_env) do
-      home = described_class.ensure_home_from_env!
-      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
-      )
-
-      expect(described_class.allocate!).to eq(home)
-    end
-  end
-
-  it "allocates the least loaded cloud node when home is full" 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
-      )
-      cloud_busy = StreamNode.create!(
-        slug: "ingest-02",
-        hostname: "ingest-02.mltv-stream.net",
-        role: "cloud",
-        status: "ready",
-        provider: "hetzner",
-        rtmp_base_url: "rtmp://ingest-02.mltv-stream.net:1935",
-        hls_base_url: "https://ingest-02.mltv-stream.net/hls",
-        api_base_url: "http://10.0.0.3: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)
-      match2 = team.matches.create!(opponent_name: "Y", scheduled_at: 2.hours.from_now)
-
-      # Riempie home (max 2)
-      StreamSession.create!(match: match, user: user, platform: "matchlivetv", status: "live", stream_node: home)
-      StreamSession.create!(match: match2, user: user, platform: "matchlivetv", status: "live", stream_node: home)
-      # Un publisher già su ingest-02 → least-loaded = ingest-01
-      StreamSession.create!(
-        match: team.matches.create!(opponent_name: "Z", scheduled_at: 3.hours.from_now),
-        user: user, platform: "matchlivetv", status: "live", stream_node: cloud_busy
-      )
-
-      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  
-**Produzione:** `eminux@192.168.1.146` → `/opt/matchlivetv` (Proxmox; control plane attuale per autoscale)
+**Ultimo aggiornamento:** 2026-07-29  
+**Produzione:** `eminux@192.168.1.146` → `/opt/matchlivetv`
 
 ---
 
@@ -397,10 +397,10 @@ 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 storico overflow-only relay YouTube (superseded dal doc sopra) |
+| [`infrastructure/HETZNER_CLOUD_RELAY_OVERFLOW.md`](infrastructure/HETZNER_CLOUD_RELAY_OVERFLOW.md) | Piano overflow relay YouTube su Hetzner Cloud (picchi) |
 | [`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 |
+| [`LIVE_STREAMING.md`](LIVE_STREAMING.md) | MediaMTX, pausa, mute audio, HLS, ruolo ffmpeg |
+| [`IOS_STREAM_AUDIO_MUTE.md`](IOS_STREAM_AUDIO_MUTE.md) | Mute microfono iOS (allineamento Mac) |
 | [`REPLAY_MODULE.md`](REPLAY_MODULE.md) | Garage, retention, YouTube VOD |
 | [`OPS_MONITORING.md`](OPS_MONITORING.md) | ntfy, variabili ops, troubleshooting |
 | [`TABELLONI_E_OVERLAY.md`](TABELLONI_E_OVERLAY.md) | Tabelloni e overlay (app nativa) |
@@ -417,8 +417,7 @@ cd infra && cp .env.example .env && docker compose up -d --build
 | 2026-06 | Replay: redirect 302 a `/media/` → Garage (fuori da Puma) |
 | 2026-06 | HLS live: edge → MediaMTX (fuori da Puma) |
 | 2026-06 | Ops: check `http_rails` + `http_public` separati, latenza p95 `UpLatencyTracker` |
-| 2026-06 | `RAILS_MAX_THREADS=5`; relay YouTube da MediaMTX (non via Puma) |
+| 2026-08 | Mute microfono in diretta (`audio_muted`) per evitare claim YouTube sulla musica in palestra |
 | 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`) |

docs/IOS_ANDROID_I18N_GAP.md

@@ -2,10 +2,12 @@
 
 Documento operativo per continuare su **Mac** lo sviluppo iOS e rilasciare un’app **allineata ad Android**.
 
-**Aggiornato:** 8 agosto 2026  
+**Aggiornato:** 12 agosto 2026  
 **Riferimento Android (produzione / telefono / Play):** `2.0.10-native` (`versionCode` **31**), API `https://www.matchlivetv.it`  
 **Stato iOS attuale:** marketing `2.0.10`, build `31` — i18n **allineato** (Login, hub, sheet/dialog, wizard, broadcast, account/forgot)
 
+**Nuovo (branch `feature/stream-audio-mute`):** mute microfono in diretta. Codice iOS già nel branch; verifica su Mac in [`IOS_STREAM_AUDIO_MUTE.md`](IOS_STREAM_AUDIO_MUTE.md).
+
 Obiettivo iOS: **stessa copertura lingua** di Android (Login, hub, sheet/dialog, wizard, broadcast, account) + bump versione, **senza** i bug di sessione/crash già risolti su Android.
 
 ---

docs/IOS_STREAM_AUDIO_MUTE.md

@@ -0,0 +1,149 @@
+# iOS — mute audio in diretta (allineamento da Mac)
+
+Documento operativo per **Cursor su Mac**: verificare e, se serve, ritoccare l’app iOS dopo il ramo `feature/stream-audio-mute`.
+
+**Aggiornato:** 2026-08-12  
+**Branch:** `feature/stream-audio-mute` (parte da `main`)  
+**Android di riferimento:** mute microfono in overlay + sync regia  
+**API produzione:** `https://www.matchlivetv.it`
+
+Il codice iOS è **già nel branch** (engine, overlay, API, Cable, L10n). Su Mac va **compilato, testato su device** e, se HaishinKit 2.2.5 rifiuta un parametro, adattato come sotto.
+
+---
+
+## Perché esiste
+
+In palestra la musica di sottofondo finisce nel microfono del telefono. Il relay YouTube fa `-c:a copy`, quindi YouTube sente quella musica e può reclamare il copyright.
+
+Il mute **non ferma** lo stream: continua video + overlay + AAC, ma i sample audio sono silenzio.
+
+---
+
+## Contratto API / Cable (già in backend)
+
+| Pezzo | Dettaglio |
+|-------|-----------|
+| Campo sessione | `audio_muted` (boolean, default `false`) in JSON sessione e `GET/POST /regia/:token/status.json` |
+| REST app | `PATCH /api/v1/sessions/:id/audio_mute` body `{ "muted": true \| false }` |
+| REST regia | `POST /regia/:token/audio_mute` body `{ "muted": true \| false }` (senza body: toggle) |
+| Cable command | `{ "type": "command", "action": "mute_audio" \| "unmute_audio", "muted": true \| false }` |
+| Cable event | `{ "type": "stream_event", "event": "audio_muted", "muted": true \| false }` |
+
+Idempotente: se lo stato è già quello richiesto, il backend non reinvia eventi.
+
+---
+
+## File iOS già modificati
+
+```
+native/ios/MatchLiveTv/Streaming/BroadcastModels.swift          # BroadcastMetrics.audioMuted
+native/ios/MatchLiveTv/Streaming/LiveBroadcastEngine.swift      # setAudioMuted + AudioMixerSettings.isMuted
+native/ios/MatchLiveTv/Streaming/LiveBroadcastCoordinator.swift # setAudioMuted
+native/ios/MatchLiveTv/Domain/Models.swift                      # StreamSession.audioMuted + withAudioMuted
+native/ios/MatchLiveTv/Data/API/ApiDtos.swift                   # audioMuted + AudioMuteRequest
+native/ios/MatchLiveTv/Data/API/MatchLiveAPI.swift              # setAudioMute
+native/ios/MatchLiveTv/Data/Repository/SessionRepository.swift
+native/ios/MatchLiveTv/Data/Cable/SessionCableService.swift     # onAudioMute + AudioMuteCommandLogic
+native/ios/MatchLiveTv/UI/Broadcast/BroadcastControlsOverlay.swift
+native/ios/MatchLiveTv/UI/Broadcast/BroadcastScreen.swift
+native/ios/MatchLiveTv/Core/AppLanguage.swift                   # IT/EN/FR/DE/ES
+native/ios/MatchLiveTvTests/LiveBroadcastCoordinatorTests.swift
+```
+
+---
+
+## Engine HaishinKit 2.2.5 (punto da verificare su Mac)
+
+Implementazione attesa in `LiveBroadcastEngine`:
+
+```swift
+func setAudioMuted(_ muted: Bool) async {
+    audioMuted = muted
+    await applyAudioMute()
+    metrics.audioMuted = muted
+    emitMetrics()
+}
+
+private func applyAudioMute() async {
+    guard pipelineConfigured else { return }
+    var settings = await mixer.audioMixerSettings
+    settings.isMuted = audioMuted
+    var track = settings.tracks[0] ?? AudioMixerTrackSettings(downmix: true, channelMap: [0])
+    track.isMuted = audioMuted
+    settings.tracks[0] = track
+    try? await mixer.setAudioMixerSettings(settings)
+}
+```
+
+In `configurePipeline` i settings iniziali passano `isMuted: audioMuted` sia sul mixer sia sulla track 0.
+
+**Se il build fallisce:**
+
+1. `AudioMixerSettings` potrebbe non avere `isMuted` nel memberwise usato oggi — in quel caso muta solo `settings.tracks[0].isMuted`.
+2. `setAudioMixerSettings` è `async throws` nel codice attuale; se la signature è sync, togli `try await`.
+3. Non staccare il microfono (`attachAudio(nil)`): YouTube/MediaMTX vogliono AAC continuo. Mute = silenzio, non assenza di traccia.
+
+Dopo `prepareBroadcast` / `resumeBroadcast` la schermata richiama `setAudioMuted(session.audioMuted)` per riallineare lo stato persistito.
+
+---
+
+## UI overlay
+
+Toolbar destra (come Android), sotto pausa:
+
+| Stato | SF Symbol | Chiave L10n |
+|-------|-----------|-------------|
+| Audio on | `speaker.wave.2.fill` | `broadcast.mute.cd` |
+| Audio off | `speaker.slash.fill` | `broadcast.unmute.cd` |
+
+Bottone `highlighted` quando mutato (stesso verde della pausa). Pannello telemetria: riga `broadcast.audio.muted.label` se mutato.
+
+---
+
+## Chiavi L10n (già aggiunte, 5 lingue)
+
+| Android | iOS |
+|---------|-----|
+| `broadcast_mute_cd` | `broadcast.mute.cd` |
+| `broadcast_unmute_cd` | `broadcast.unmute.cd` |
+| `broadcast_audio_muted_label` | `broadcast.audio.muted.label` |
+| `broadcast_snackbar_muted` | `broadcast.snackbar.muted` |
+| `broadcast_snackbar_unmuted` | `broadcast.snackbar.unmuted` |
+| `broadcast_snackbar_muted_remote` | `broadcast.snackbar.muted.remote` |
+| `broadcast_snackbar_unmuted_remote` | `broadcast.snackbar.unmuted.remote` |
+| `broadcast_snackbar_mute_error` | `broadcast.snackbar.mute.error` |
+
+---
+
+## Test su Mac (acceptance)
+
+1. `cd native/ios && python3 generate_xcodeproj.py`
+2. Build simulatore / device.
+3. Avvia una diretta (anche verso ambiente di staging).
+4. Overlay: tap mute → icona speaker.slash, snackbar «Audio silenziato», telemetria «Audio off».
+5. Apri la **regia** sullo stesso match → il pulsante deve dire «Riattiva audio».
+6. Dalla regia riattiva → il telefono mostra speaker.wave e snackbar «dalla regia».
+7. Mute, metti in **pausa**, riprendi: l’audio resta mutato (stato persistito).
+8. YouTube / player HLS: video continua, audio silenzioso (non assente).
+9. Unit test: `LiveBroadcastCoordinatorTests.testAudioMuteCommandFromCable`.
+
+```bash
+cd native/ios
+python3 generate_xcodeproj.py
+xcodebuild -project MatchLiveTv.xcodeproj -scheme MatchLiveTv \
+  -destination 'generic/platform=iOS Simulator' \
+  -derivedDataPath build/DerivedData \
+  ONLY_ACTIVE_ARCH=YES ARCHS=arm64 EXCLUDED_ARCHS=x86_64 \
+  build
+```
+
+---
+
+## Criterio “fatto”
+
+- [ ] Build iOS senza errori HaishinKit
+- [ ] Mute/unmute locale in overlay
+- [ ] Sync bidirezionale con la regia via Cable + REST
+- [ ] Mute sopravvive a pausa/ripresa
+- [ ] AAC silenzioso in onda (niente drop della traccia audio)
+- [ ] Stringhe IT/EN/FR/DE/ES visibili in overlay

docs/LIVE_STREAMING.md

@@ -1,6 +1,6 @@
 # Diretta live — architettura MediaMTX
 
-**Ultimo aggiornamento:** 2026-07-29
+**Ultimo aggiornamento:** 2026-08-12
 
 ## Idea
 
@@ -106,6 +106,19 @@ L’app mobile persiste il punteggio con `PATCH /api/v1/sessions/:id/score` (o `
 
 `GET /live/:id/status.json` resta per messaggi sotto il player e recovery HLS; `Cache-Control: no-store`.
 
+### Mute audio (copyright palestra / YouTube)
+
+Se in palestra c’è musica di sottofondo, YouTube può reclamare il copyright sul flusso inoltrato (`-c:a copy`). L’operatore può **silenziare il microfono** senza interrompere video, overlay, HLS o relay:
+
+1. Lo stato `audio_muted` è persistito su `stream_sessions` (default `false`).
+2. API `PATCH /api/v1/sessions/:id/audio_mute` `{ "muted": true|false }` e `POST /regia/:token/audio_mute`.
+3. Action Cable: `{ type: "command", action: "mute_audio"|"unmute_audio" }` e `{ type: "stream_event", event: "audio_muted", muted: true|false }`.
+4. L’app **non toglie la traccia AAC**: azzera i sample PCM (silenzio). YouTube e MediaMTX continuano a ricevere audio 48 kHz mono.
+
+Pulsante mute: overlay diretta (Android/iOS, accanto a pausa) e pagina regia.
+
+Dettaglio implementazione iOS: [`IOS_STREAM_AUDIO_MUTE.md`](IOS_STREAM_AUDIO_MUTE.md).
+
 ## Rigenerare la slate
 
 ```bash

docs/infrastructure/HETZNER_CLOUD_RELAY_OVERFLOW.md

@@ -1,12 +1,10 @@
 # Piano: overflow relay YouTube su Hetzner Cloud
 
-> **Superseded (2026-08-09):** il design corrente è [`STREAMING_AUTOSCALE.md`](STREAMING_AUTOSCALE.md) (Auction + Proxmox, scale di MediaMTX **e** ffmpeg, warm spare, secondo dominio DNS, Garage ora / B2 dopo). Questo file resta come riferimento storico sul solo overflow dei relay.
-
-**Stato:** piano / design storico — non implementato come doc standalone  
-**Ultimo aggiornamento:** 2026-07-29 (header superseded 2026-08-09)  
+**Stato:** piano / design — non implementato  
+**Ultimo aggiornamento:** 2026-07-29  
 **Contesto:** produzione attuale su host dedicato (es. Proxmox/Hetzner) con MediaMTX + Sidekiq sullo stesso box; obiettivo >10 live YouTube contemporanee senza abbandonare il middle-tier.
 
-Documenti correlati: [`STREAMING_AUTOSCALE.md`](STREAMING_AUTOSCALE.md), [`LIVE_STREAMING.md`](../LIVE_STREAMING.md), [`ARCHITECTURE.md`](../ARCHITECTURE.md), [`OPS_MONITORING.md`](../OPS_MONITORING.md).
+Documenti correlati: [`LIVE_STREAMING.md`](../LIVE_STREAMING.md), [`ARCHITECTURE.md`](../ARCHITECTURE.md), [`OPS_MONITORING.md`](../OPS_MONITORING.md).
 
 ---
 

docs/infrastructure/STREAMING_AUTOSCALE.md

@@ -1,372 +0,0 @@
-# Autoscale streaming — Proxmox attuale + Hetzner Cloud
-
-**Stato:** fasi 0–4 implementate sul branch — **solo test lab; nessun deploy produzione**  
-**Branch:** `feature/streaming-autoscale-hetzner`  
-**Ultimo aggiornamento:** 2026-08-09 (Fase 4 hardening + runbook)  
-
-**Sostituisce / estende:** il piano overflow-only [`HETZNER_CLOUD_RELAY_OVERFLOW.md`](HETZNER_CLOUD_RELAY_OVERFLOW.md). Questo documento copre **MediaMTX + ffmpeg**, warm spare, DNS, storage, disco e lab sul Proxmox di produzione.
-
-Documenti correlati: [`ARCHITECTURE.md`](../ARCHITECTURE.md), [`LIVE_STREAMING.md`](../LIVE_STREAMING.md), [`REPLAY_MODULE.md`](../REPLAY_MODULE.md), [`OPS_MONITORING.md`](../OPS_MONITORING.md).
-
----
-
-## 1. Obiettivo
-
-Scalare molte dirette contemporanee (sito e/o YouTube) senza saturare un unico box:
-
-- **Control plane (ora):** Proxmox **già in produzione** (`192.168.1.146` / `/opt/matchlivetv`) — sito, API, DB, Redis, Garage, MediaMTX/ffmpeg “home”.
-- **Data plane elastico:** **Hetzner Cloud** — nodi `MediaMTX + ffmpeg` con warm spare (+1).
-- **DNS ingest:** secondo dominio su **Hetzner DNS** (API).
-- **Lab:** stesso Proxmox, con `ProxmoxLabProvider`, prima di affidarsi al Cloud in produzione.
-- **Futuro (non bloccante):** migrazione control plane su **Hetzner Auction + Proxmox** (vSwitch nativo, hardware dedicato).
-
----
-
-## 2. Decisioni chiuse
-
-| # | Decisione | Scelta |
-|---|----------|--------|
-| D1 | Host primario **ora** | **Proxmox già usato in produzione** (non attendere Auction) |
-| D1b | Host primario **futuro** | Hetzner Server Auction + Proxmox (quando si migra) |
-| D2 | Overflow / warm spare | **Hetzner Cloud** (attivato per questo progetto) |
-| D3 | Unità di scala | Nodo **stream** = MediaMTX + worker `youtube_relay` (ffmpeg remux copy) |
-| D4 | Warm pool | Almeno **1 spare ready** quando il carico si avvicina al cap |
-| D5 | DNS ingest | Dominio **`mltv-stream.net`** (registrar Aruba, NS → Hetzner DNS). `matchlivetv.it` resta su Aruba intatto |
-| D6 | Aruba | Nessuna delega NS; niente Floating IP prenotate |
-| D7a | Rete **ora** (casa/Proxmox ↔ Cloud) | **WireGuard** (o Tailscale) privato: Redis, DB, API MediaMTX home. Non esporre Redis/Postgres su WAN |
-| D7b | Rete **futuro** (Auction ↔ Cloud) | vSwitch Robot + Cloud Network (stessa location) |
-| D8 | Object storage | **Garage resta**. **B2** = migrazione pronta quando misurato |
-| D9 | Staging | Segmenti su disco VM `stream-*` in live; upload Garage a fine sessione |
-| D10 | Prodotto | Consigliare **YouTube** per alleggerire storage/egress replay |
-| D11 | Disco | Separazione volumi + **monitoraggio attivo** obbligatorio (§6) |
-| D12 | Lab prima del Cloud prod | `ProxmoxLabProvider` + DNS lab sullo stesso Proxmox; poi `HetznerCloudProvider` |
-
----
-
-## 3. Topologia — fase attuale (Proxmox prod + Cloud)
-
-```text
-Internet
-   │  HTTPS :443 · RTMP :1935
-   ▼
-┌──────────────────────────────────────────────────────────┐
-│  Proxmox produzione (attuale)                            │
-│  eminux@192.168.1.146 · /opt/matchlivetv                 │
-│                                                          │
-│  edge · rails · sidekiq-core · postgres · redis          │
-│  garage · stream-home (MediaMTX + youtube_relay)         │
-│  autoscaler (Rails/Sidekiq)                              │
-│                                                          │
-│  Lab (opz.): clone VM stream-* via ProxmoxLabProvider    │
-└────────────────────────┬─────────────────────────────────┘
-                         │  WireGuard / tunnel privato
-                         ▼
-┌──────────────────────────────────────────────────────────┐
-│  Hetzner Cloud — pool stream nodes                       │
-│  stream-01 … stream-N   MediaMTX + ffmpeg                │
-│  + 1 spare ready (warm)                                  │
-└────────────────────────┬─────────────────────────────────┘
-                         │
-              Hetzner DNS (secondo dominio)
-              ingest-XX.<dominio> → IP pubblico nodo
-```
-
-**Futuro Auction:** stesso schema, tunnel sostituito da vSwitch; control plane migrato sul bare metal Hetzner.
-
-**Principio:** Rails solo controllo. Live sui MediaMTX del nodo assegnato. Replay su Garage (poi eventualmente B2).
-
----
-
-## 4. DNS (secondo dominio)
-
-RTMP **non** tollera round-robin su un unico hostname.
-
-1. Dominio **`mltv-stream.net`** registrato su Aruba; zona DNS su Hetzner Console (progetto `matchlivetv-stream`).
-2. NS Aruba del dominio → `hydrogen` / `oxygen` / `helium` Hetzner (delegazione OK).
-3. Autoscaler a VM ready → upsert `A` `ingest-03.mltv-stream.net` → health-check → nodo `ready`.
-4. API create/start sessione → URL del nodo assegnato:
-
-```text
-rtmp://ingest-03.mltv-stream.net:1935/live/match_<uuid>
-https://ingest-03.mltv-stream.net/hls/...   # o via edge matchlivetv.it che proxya il nodo
-```
-
-5. Scale-in: drain → delete DNS → destroy VM.
-
-Hostname pubblici dei nodi vivono sotto `*.mltv-stream.net`. In lab: `LabDnsProvider` (`/etc/hosts`, dnsmasq).
-
----
-
-## 5. Autoscaler e warm spare
-
-Ogni nodo: `max_publishers` / `max_relays` (es. 4).
-
-| Regola | Comportamento |
-|--------|----------------|
-| Scale-out | `free_slots` sotto soglia soft → crea 1 nodo |
-| Warm spare | Se `spare_ready < 1` vicino al carico → crea spare |
-| Scale-in | Idle da X min e non unica spare → destroy |
-| Floor | `stream-home` sul Proxmox sempre on |
-
-`CloudProvider`: `HetznerCloudProvider` (prod overflow) + `ProxmoxLabProvider` (test).  
-Code Sidekiq: coda `youtube_relay` isolata; sticky owner Redis.
-
----
-
-## 6. Disco Proxmox — requisito critico
-
-**Non** mettere OS, DB e video sullo stesso volume che può riempirsi al 100%.
-
-Vale **già** sul Proxmox di produzione (rinforzare ora), e di nuovo alla migrazione Auction.
-
-### 6.1 Layout volumi (target)
-
-| Volume / disco | Contenuto | Note |
-|----------------|-----------|------|
-| `os` | Proxmox / sistema host | Quasi statico |
-| `vm-system` / root stack | rails, edge, redis, … | Snapshot |
-| `vm-data-db` | Postgres | Separato; backup prioritari |
-| `vm-data-video` | Garage + staging MediaMTX | **Disco che può riempirsi** |
-| `backup` | Backup / PBS | **Mai** sullo stesso disco dei video |
-
-Regole: cap Garage/staging; se staging pieno → **rifiutare nuove sessioni**, non far cadere DB/API.
-
-### 6.2 Monitoraggio attivo (obbligatorio)
-
-| Metrica | Warn | Critical |
-|---------|------|----------|
-| Uso `%` volume video | ≥ 70% | ≥ 85% |
-| Spazio libero GB | sotto soglia | &lt; X GB |
-| Inode liberi | bassi | esaurimento |
-| Crescita GB/giorno Garage | anomalia | — |
-| Purge/retention falliti | — | immediato |
-| Staging per nodo `stream-*` | ≥ 70% | ≥ 85% + blocco live su quel nodo |
-
-Checklist:
-
-- [ ] Alert ntfy disco testati
-- [ ] Vista ops “disco video”
-- [ ] Test periodico “80% pieno”
-- [ ] Restore di prova Postgres
-
----
-
-## 7. Storage: Garage ora, B2 dopo
-
-| Ora | **Garage** |
-| Dopo | **Backblaze B2** quando metriche/€ lo giustificano |
-
-Client S3-ready; staging locale invariato. Spinta prodotto YouTube riduce pressione replay.
-
----
-
-## 8. Prodotto: YouTube consigliato
-
-Suggerire YouTube in app/dashboard quando ha senso → meno storage/egress MatchLiveTV; middle-tier (slate + relay) resta il valore. Live solo-sito restano supportate.
-
----
-
-## 9. Astrazioni codice
-
-```text
-CloudProvider
-  create_node / destroy_node / list_nodes / wait_until_running / public_ip
-  → HetznerCloudProvider | ProxmoxLabProvider
-
-DnsProvider
-  upsert_a / delete_a
-  → HetznerDnsProvider | LabDnsProvider
-
-StreamNodeRegistry
-  register / mark_ready / allocate_for_session / drain / release
-
-Autoscaler
-  reconcile!(metrics) → ensure spare / scale-in idle
-```
-
-Tag VM Cloud: `matchlivetv`, `role=stream-node`, `env=prod|lab`.
-
----
-
-## 10. Lab sul Proxmox attuale
-
-Prima (o in parallelo) al Cloud “vero”:
-
-1. Template VM `stream-node` su Proxmox.
-2. `CLOUD_PROVIDER=proxmox_lab` → clone/start/stop via API Proxmox.
-3. DNS lab (hosts/dnsmasq).
-4. Soft cap basso; N sessioni di test; verifica assignment, spare, scale-in, alert disco.
-5. Poi smoke su Hetzner Cloud (1 CX piccolo) + DNS reale.
-
-Cosa il lab **non** replica al 100%: tempi boot Hetzner, vSwitch, RTMP 4G multi-nodo (smoke WAN dopo).
-
----
-
-## 11. Fasi di implementazione
-
-| Fase | Cosa | Esito |
-|------|------|--------|
-| **L — Lab Proxmox** | `LocalLab` / `ProxmoxLab`, DNS lab, admin nodi | **implementata sul branch** |
-| **0 — Multi-nodo ready** | Registry + URL RTMP/HLS in API (`StreamNode`, `Streams::NodeRegistry`) | **implementata sul branch** |
-| **1 — Hetzner Cloud + DNS** | `HetznerCloudProvider` + `HetznerDnsProvider`, `mltv-stream.net`, cloud-init, WireGuard (§16) | **implementata sul branch** (WG ops manuale) |
-| **2 — Routing relay** | Coda `youtube_relay`, sticky owner, cap `RELAY_MAX_CONCURRENT` | **implementata sul branch** |
-| **3 — Autoscaler** | Soglie + warm spare (+1), kill-switch `STREAM_AUTOSCALE_ENABLED` | **implementata sul branch** |
-| **4 — Hardening** | Drain sicuro, budget, kill-switch Redis/admin, alert overflow, runbook | **implementata sul branch** (solo test lab — **non in prod**) |
-| **A — Auction (futuro)** | Migrazione control plane + vSwitch al posto di WireGuard | Hardware dedicato Hetzner |
-| **B2 (opz.)** | Switch object storage | Quando misurato |
-
-### Fase 0 — dettagli implementati
-
-- Tabella `stream_nodes` + `stream_sessions.stream_node_id`
-- `Streams::NodeRegistry.ensure_home_from_env!` / `allocate!` (least-loaded)
-- `Sessions::Create` assegna il nodo e crea il path MediaMTX sul client del nodo
-- URL RTMP/HLS/API/internal per sessione derivati dal nodo (fallback ENV se nodo assente)
-- API JSON espone `stream_node` (slug)
-- Dominio ingest pubblico futuro: `*.mltv-stream.net`
-
-### Fase L — dettagli implementati
-
-- `Streams::CloudProviders` (`local_lab`, `proxmox_lab`, stub `hetzner`)
-- `Streams::DnsProviders` (`lab` su Redis, stub `hetzner`)
-- `Streams::NodeProvisioner` (provision / drain / decommission)
-- Admin **Nodi stream** (`/admin/stream_nodes`): lista, provision lab, drain, delete
-- Rake: `streams:nodes:ensure_home`, `streams:nodes:provision_lab`, `streams:nodes:dns_lab_dump`
-- Default sicuro: `STREAM_CLOUD_PROVIDER=local_lab` (nessuna chiamata Proxmox finché non configuri token)
-
-### Fase 1 — dettagli implementati
-
-- `Streams::CloudProviders::Hetzner` (create/destroy server, wait running, labels)
-- `Streams::DnsProviders::Hetzner` (upsert/delete A su zona `mltv-stream.net`)
-- `NodeProvisioner#provision_cloud!` + bottone admin **Provisiona nodo Hetzner**
-- Cloud-init: `infra/stream-node/cloud-init.yaml` (`HCLOUD_USER_DATA_FILE`)
-- Decommission usa il provider del nodo (non solo ENV globale)
-- WireGuard: vedi §16
-
-### Fase 2 — dettagli implementati
-
-- Coda Sidekiq dedicata `youtube_relay` (priorità sopra `default`)
-- `YoutubeRelayEnsureJob` / `YoutubeRelayStopJob` solo su quella coda
-- Stop sticky: non cancella owner da Rails; lo stop gira sull’owner o requeue (`:wrong_host`)
-- Cap per worker: `RELAY_MAX_CONCURRENT` (default 4) + set Redis `youtube_relay:owned:HOSTNAME`
-- Ensure a capacità piena → requeue 5s invece di avviare un secondo ffmpeg locale
-
-### Fase 3 — dettagli implementati
-
-- `Streams::Autoscaler` + job chain `Streams::AutoscalerJob` (come health monitor)
-- Kill-switch: `STREAM_AUTOSCALE_ENABLED=1` per attivare
-- Scale-out se `free_slots ≤ STREAM_AUTOSCALE_SOFT_FREE_SLOTS`
-- Warm spare (+N) se carico/soglia e `spare_ready < WARM_SPARE`
-- Scale-in overflow idle da `IDLE_MINUTES` (non tocca home; rispetta warm spare)
-- Cap `STREAM_AUTOSCALE_MAX_NODES`; kind `lab|cloud`
-- Metriche in admin Nodi stream
-
-### Fase 4 — hardening (implementata sul branch)
-
-> **NON rilasciare in produzione** finché lab + smoke Cloud non sono verdi. Su questo branch restano `STREAM_AUTOSCALE_ENABLED=0` e `STREAM_AUTOSCALE_ALLOW_CLOUD=0`.
-
-- Scale-in **sicuro**: `drain!` → attesa sessioni zero → `decommission!`
-- Budget soft: `STREAM_AUTOSCALE_MONTHLY_BUDGET_EUR` + `STREAM_AUTOSCALE_NODE_EUR_PER_HOUR` (stima 24/7); scale-out bloccato se sforerebbe
-- Cloud autoscale solo con `STREAM_AUTOSCALE_ALLOW_CLOUD=1` **e** `HCLOUD_TOKEN`
-- Kill-switch runtime Redis `streams:autoscaler:kill_switch` (bottoni admin ON/OFF) oltre all’ENV
-- Health check `stream_overflow` → incidente Ops/ntfy su nodi idle orfani, over-budget, capacità al max
-- Admin: metriche budget + stato kill-switch
-
-#### Runbook operativo (lab / pre-prod)
-
-| Situazione | Azione |
-|------------|--------|
-| Dubbio / picco anomalo | Admin → **Kill-switch ON** (o `STREAM_AUTOSCALE_ENABLED=0`) |
-| Nodo spillato | Drain dal admin; dopo fine live → Destroy |
-| Budget alert Ops | Abbassa `MAX_NODES` / alza budget solo dopo review costi Hetzner |
-| Smoke Cloud | Provision **manuale** admin (kind cloud), non autoscaler; verifica WG + RTMP 1935 |
-| Scale-out lab OK | Solo dopo: considerare `ENABLED=1` + `KIND=lab` su staging/lab Proxmox |
-| Produzione overflow | Solo dopo checklist §12 punto 6 |
-
-Ordine di lavoro consigliato sul branch: **0 → L → 1 → 2 → 3 → 4**; **A** quando si decide di lasciare il Proxmox casa.
-
----
-
-## 12. Ordine operativo “ora” (senza Auction)
-
-1. Rinforzare dischi/alert sul Proxmox prod (§6).
-2. Secondo dominio + zona Hetzner DNS.
-3. Progetto Hetzner Cloud + immagine/snapshot `stream-node`.
-4. Tunnel WireGuard Proxmox ↔ Cloud (Redis/DB/API private).
-5. Implementare fasi 0 → L → 1… sul branch.
-6. Cutover overflow in produzione solo dopo lab + smoke Cloud verdi.
-
----
-
-## 13. Criteri di successo
-
-| Criterio | Misura |
-|----------|--------|
-| Lab | Scale-out/in e assignment verificati su Proxmox senza Hetzner |
-| Picco | N live oltre soft cap home con spare Cloud ready |
-| Continuità | Drop telefono → slate YT attiva |
-| Disco | Nessun outage DB/API per disco video; alert prima del critical |
-| DNS | Aruba intatto; ingest sul secondo dominio |
-| Futuro | Path chiaro verso Auction senza riscrivere autoscaler |
-
----
-
-## 14. Aperto / da calibrare
-
-| Voce | Note |
-|------|------|
-| Nome secondo dominio | **`mltv-stream.net`** (chiuso) |
-| Soft cap `stream-home` | es. 4 vs 6 |
-| Tipo VM Cloud | CPX vs CCX |
-| `OVERFLOW_MAX` / budget | — |
-| Spare di notte | 0 vs 1 |
-| Dettaglio WireGuard | subnet, peer, MTU |
-| Soglie GB disco | da size reale volume video |
-
----
-
-## 15. Riepilogo esecutivo
-
-**Ora:** restiamo sul Proxmox di produzione; attiviamo Hetzner Cloud (spare MediaMTX+ffmpeg) + Hetzner DNS (secondo dominio) + WireGuard. Testiamo prima in lab sullo stesso Proxmox. Garage resta; B2 dopo. YouTube consigliato in prodotto. Disco e alert sono vincolo non negoziabile.
-
-**Dopo:** eventuale Auction Hetzner sostituisce il control plane casa e WireGuard → vSwitch, senza cambiare il modello nodi/autoscaler.
-
----
-
-## 16. WireGuard (Proxmox casa ↔ Hetzner Cloud)
-
-Obiettivo: Rails/Sidekiq sull’host di produzione raggiungono `api_base_url` / `internal_rtmp_url` dei nodi Cloud (es. `http://10.0.0.9:9997`) **senza** esporre Redis/Postgres/MediaMTX API su Internet.
-
-### Setup consigliato (una tantum)
-
-1. Su Hetzner Console: crea **Network** privata (es. `10.0.0.0/16`) nella location `fsn1`, subnet `10.0.1.0/24` per i server Cloud.
-2. Imposta `HCLOUD_NETWORK_ID=<id>` così i nodi stream entrano nella network al create.
-3. Su Proxmox (VM o LXC gateway): installa WireGuard; peer verso una VM “gateway” Cloud **sempre on** (CX22 piccola) *oppure* peer site-to-site verso un server Cloud fisso.
-4. Alternativa più semplice per i primi test: **Tailscale** su Proxmox host + su ogni stream-node (cloud-init) — stesso effetto, meno ops.
-5. Firewall Hetzner Cloud:
-   - WAN: `1935/tcp` (RTMP), `443/tcp` o `8888` se HLS diretto
-   - Solo rete privata / WG: `9997` (MediaMTX API), niente Postgres/Redis sui nodi stream
-6. Verifica da Rails: `curl http://<private_ip>:9997/v3/paths/list`
-
-Finché WireGuard/Tailscale non è pronto, `api_base_url` punta comunque alla private IP (o pubblica se manca private_net): il path MediaMTX da Create fallirà dal control plane se non raggiungibile — provisionare nodi Cloud solo dopo connettività privata OK, oppure smoke con API su IP pubblico temporaneo + firewall allowlist IP casa.
-
-### ENV produzione (stream autoscale)
-
-```bash
-HCLOUD_TOKEN=...
-HCLOUD_LOCATION=nbg1
-HCLOUD_SERVER_TYPE=cpx12
-HCLOUD_IMAGE=debian-12
-HCLOUD_SSH_KEY=matchlivetv-stream-hetzner
-HCLOUD_NETWORK_ID=          # opzionale
-HCLOUD_USER_DATA_FILE=/opt/matchlivetv/infra/stream-node/cloud-init.yaml
-
-STREAM_DNS_ZONE=mltv-stream.net
-STREAM_DNS_TTL=60
-STREAM_CLOUD_DNS_SUFFIX=mltv-stream.net
-STREAM_CLOUD_MAX_PUBLISHERS=4
-STREAM_NODE_ENV=prod
-
-# Default lab sicuro; in prod per overflow usa hetzner esplicitamente dal bottone admin
-STREAM_CLOUD_PROVIDER=local_lab
-STREAM_DNS_PROVIDER=lab
-```