jumbotron 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31fa4d11ab93d13b5e6db4ab799f05f69b6153067ceb0894677e07bd785c27a3
-  data.tar.gz: 2f660fdbdf85bb67f9212c6c8c55b6bc9f49a2699c643070a5496946d8894259
+  metadata.gz: 59e55efb1ece4d237011869ce7416fd4cda99a2e95feb914c21e93a3f23aecaa
+  data.tar.gz: 2199925a6f4a46d2db581c63e2a5eb55b81a26483195a396a4b7c111ae41bee1
 SHA512:
-  metadata.gz: ee10748cd68f85baa4c3774ef6f7fbcd4c6376f76927a442a8e4ce1b4e28e34c56f7c6355af29545ba1306f7367e37499a56dbdb00f990e413aea020cf37079e
-  data.tar.gz: 30e89a701a8dc935ac6d0d4aeffc61d982b6a800d97f86ac43035a23d4ac480bd60485c6c8e96093eaef022b128693ccf0b663b63716dab53385bce0e79ea174
+  metadata.gz: ae7c4b2c06eed8291bafcb279940f0ca45ad5b33a62cc5970a5c1d353eae0c4d8bde4173e62811d13dade3038107940a828f37b2b3e1c1d6a7f2c118f62d5447
+  data.tar.gz: 8ecd32a04d755e5eb0422fccbb98b10beead9f3b88de8f8e885f2b8e4f458af6a672d1bdf9a63040b88e352186cea328565263dff18d001298b1a0cf97389748

data/app/adapters/jumbotron/adapters/espn/nfl.rb

@@ -66,6 +66,21 @@ module Jumbotron
                  INTERRUPTED_LIFECYCLES.include?(game.lifecycle)
                }
 
+        # Bounded post-final scoreboard re-observation when post-game record is still
+        # missing (Strategy B). Stops after window or once post_game is persisted.
+        policy :post_final_record,
+               type: :post_final_game_update,
+               cadence: Cadence.new(every: 15, unit: :minute),
+               eligible: lambda { |game, now:|
+                 return false unless game.lifecycle == "completed"
+                 return false if game.changed_at.nil? || game.changed_at < now - 6.hours
+
+                 participants = game.game_participants
+                 return false if participants.empty?
+
+                 participants.any? { |participant| participant.record_summary_post_game.blank? }
+               }
+
         policy :far_future_lines,
                type: :future_line_update,
                cadence: Cadence.new(every: 1, unit: :week),

data/app/adapters/jumbotron/adapters/espn/nfl_helpers/scoreboard.rb

@@ -80,11 +80,14 @@ module Jumbotron
             raise TransformError, "venue id required" if venue.id.blank?
             raise TransformError, "venue name required" if venue.full_name.blank?
 
+            address = venue.respond_to?(:address) ? venue.address : nil
             Canonical::VenueInput.new(
               provider_identities: [
                 Canonical::ProviderIdentityRef.new(provider: "espn", namespace: "venue", id: venue.id.to_s)
               ],
-              name: venue.full_name.to_s
+              name: venue.full_name.to_s,
+              city: address&.city.presence,
+              region: address&.state.presence
             )
           end
           private_class_method :transform_venue
@@ -103,13 +106,23 @@ module Jumbotron
                 Canonical::ProviderIdentityRef.new(provider: "espn", namespace: "team", id: team.id.to_s)
               ],
               team_name: name.to_s,
+              team_nickname: TeamNickname.resolve(team),
+              team_abbreviation: team.abbreviation.presence,
               role: competitor.home_away.to_s,
               score: coerce_score(competitor.score),
-              result: coerce_result(competitor.winner, lifecycle)
+              result: coerce_result(competitor.winner, lifecycle),
+              record_summary: total_record_summary(competitor)
             )
           end
           private_class_method :transform_participant
 
+          def self.total_record_summary(competitor)
+            records = competitor.respond_to?(:records) ? Array(competitor.records) : []
+            total = records.find { |record| record.type.to_s == "total" }
+            total&.summary.presence
+          end
+          private_class_method :total_record_summary
+
           def self.coerce_score(raw)
             return nil if raw.nil? || raw == ""
 

data/app/adapters/jumbotron/adapters/espn/nfl_helpers/team_nickname.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Espn
+      module NflHelpers
+        # Maps ESPN team identity fields into canonical nickname without parsing display_name.
+        # Precedence: nickname → name → short_display_name (provider fields only).
+        module TeamNickname
+          def self.resolve(team)
+            return nil if team.nil?
+
+            team.nickname.presence || team.name.presence || team.short_display_name.presence
+          end
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/espn/nfl_helpers/teams.rb

@@ -24,7 +24,9 @@ module Jumbotron
               provider_identities: [
                 Canonical::ProviderIdentityRef.new(provider: "espn", namespace: "team", id: team.id.to_s)
               ],
-              name: name.to_s
+              name: name.to_s,
+              nickname: TeamNickname.resolve(team),
+              abbreviation: team.abbreviation.presence
             )
           end
           private_class_method :transform_team

data/app/deserializers/jumbotron/deserializers/clients/espn/competitor.rb

@@ -13,6 +13,7 @@ module Jumbotron
             field :winner, type: Support.types.boolean, nullable: true
             field :order, type: Support.types.integer, nullable: true
             field :team, type: Team::Result, required: true
+            field :records, type: Support.types.array(CompetitorRecord::Result), nullable: true
           end
 
           def self.call(payload)
@@ -25,10 +26,22 @@ module Jumbotron
               score: coerce_score(Support.payload.fetch(payload, "score")),
               winner: Support.payload.fetch(payload, "winner"),
               order: Support.payload.fetch(payload, "order"),
-              team: Support.nest("team", Support.payload.fetch(payload, "team")) { |raw| Team.call(raw) }
+              team: Support.nest("team", Support.payload.fetch(payload, "team")) { |raw| Team.call(raw) },
+              records: map_records(Support.payload.fetch(payload, "records"))
             )
           end
 
+          def self.map_records(raw)
+            return nil if raw.equal?(Support.missing) || raw.nil?
+
+            Array(raw).each_with_index.map do |item, index|
+              CompetitorRecord.call(item)
+            rescue CommandTower::Clients::Errors::DeserializationError => e
+              raise CommandTower::Deserializers::Clients::Errors.prefix(e, "records[#{index}]")
+            end
+          end
+          private_class_method :map_records
+
           def self.coerce_id(raw)
             return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
 

data/app/deserializers/jumbotron/deserializers/clients/espn/competitor_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class CompetitorRecord
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :type, type: Support.types.string, required: true
+            field :summary, type: Support.types.string, required: true
+            field :name, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "competitor.record")
+
+            Result.build!(
+              type: Support.payload.fetch(payload, "type"),
+              summary: Support.payload.fetch(payload, "summary"),
+              name: Support.payload.fetch(payload, "name")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/team.rb

@@ -12,6 +12,7 @@ module Jumbotron
             field :display_name, type: Support.types.string, required: true
             field :short_display_name, type: Support.types.string, nullable: true
             field :name, type: Support.types.string, nullable: true
+            field :nickname, type: Support.types.string, nullable: true
             field :location, type: Support.types.string, nullable: true
           end
 
@@ -25,6 +26,7 @@ module Jumbotron
               display_name: Support.payload.fetch(payload, "displayName"),
               short_display_name: Support.payload.fetch(payload, "shortDisplayName"),
               name: Support.payload.fetch(payload, "name"),
+              nickname: Support.payload.fetch(payload, "nickname"),
               location: Support.payload.fetch(payload, "location")
             )
           end

data/app/deserializers/jumbotron/deserializers/clients/espn/venue.rb

@@ -9,6 +9,7 @@ module Jumbotron
             field :id, type: Support.types.string, required: true
             field :full_name, type: Support.types.string, required: true
             field :indoor, type: Support.types.boolean, nullable: true
+            field :address, type: VenueAddress::Result, nullable: true
           end
 
           def self.call(payload)
@@ -17,10 +18,18 @@ module Jumbotron
             Result.build!(
               id: coerce_id(Support.payload.fetch(payload, "id")),
               full_name: Support.payload.fetch(payload, "fullName"),
-              indoor: Support.payload.fetch(payload, "indoor")
+              indoor: Support.payload.fetch(payload, "indoor"),
+              address: map_address(Support.payload.fetch(payload, "address"))
             )
           end
 
+          def self.map_address(raw)
+            return nil if raw.equal?(Support.missing) || raw.nil?
+
+            VenueAddress.call(raw)
+          end
+          private_class_method :map_address
+
           def self.coerce_id(raw)
             return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
 

data/app/deserializers/jumbotron/deserializers/clients/espn/venue_address.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class VenueAddress
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :city, type: Support.types.string, nullable: true
+            field :state, type: Support.types.string, nullable: true
+            field :country, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "venue.address")
+
+            Result.build!(
+              city: Support.payload.fetch(payload, "city"),
+              state: Support.payload.fetch(payload, "state"),
+              country: Support.payload.fetch(payload, "country")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/jumbotron/canonical.rb

@@ -4,17 +4,41 @@ module Jumbotron
   module Canonical
     ProviderIdentityRef = Data.define(:provider, :namespace, :id)
 
-    TeamInput = Data.define(:provider_identities, :name)
+    TeamInput = Data.define(:provider_identities, :name, :nickname, :abbreviation) do
+      def initialize(provider_identities:, name:, nickname: nil, abbreviation: nil)
+        super
+      end
+    end
 
-    VenueInput = Data.define(:provider_identities, :name)
+    VenueInput = Data.define(:provider_identities, :name, :city, :region) do
+      def initialize(provider_identities:, name:, city: nil, region: nil)
+        super
+      end
+    end
 
     ParticipantInput = Data.define(
       :provider_identities,
       :team_name,
       :role,
       :score,
-      :result
-    )
+      :result,
+      :team_nickname,
+      :team_abbreviation,
+      :record_summary
+    ) do
+      def initialize(
+        provider_identities:,
+        team_name:,
+        role:,
+        score:,
+        result:,
+        team_nickname: nil,
+        team_abbreviation: nil,
+        record_summary: nil
+      )
+        super
+      end
+    end
 
     ScheduleGroupInput = Data.define(:kind, :number, :name)
 

data/app/models/jumbotron/public.rb

@@ -19,9 +19,21 @@ module Jumbotron
       :season_phase,
       :kind
     )
-    Team = Data.define(:id, :name, :key)
-    Venue = Data.define(:id, :name)
-    Participant = Data.define(:role, :score, :result, :team)
+    Team = Data.define(:id, :name, :nickname, :key, :abbreviation) do
+      def initialize(id:, name:, key:, nickname: nil, abbreviation: nil)
+        super(id:, name:, nickname:, key:, abbreviation:)
+      end
+    end
+    Venue = Data.define(:id, :name, :city, :region) do
+      def initialize(id:, name:, city: nil, region: nil)
+        super
+      end
+    end
+    Participant = Data.define(:role, :score, :result, :team, :record) do
+      def initialize(role:, score:, result:, team:, record: nil)
+        super
+      end
+    end
     GameSegment = Data.define(:kind, :number)
     # Clock label text. Name is canonical/public contract, not Kernel#display.
     GameClock = Data.define(:mode, :seconds, :display) # rubocop:disable Lint/DataDefineOverride

data/app/services/jumbotron/services/adapters/resolve_game_update_policy.rb

@@ -8,6 +8,7 @@ module Jumbotron
           future_game_update
           live_game_update
           interrupted_game_update
+          post_final_game_update
         ].freeze
 
         validate :adapter_id, required: true

data/app/services/jumbotron/services/adapters/select_eligible_games.rb

@@ -20,7 +20,7 @@ module Jumbotron
           end
 
           games = Game.where(league_id: league.id)
-                      .includes(:season, :season_phase, :schedule_group)
+                      .includes(:season, :season_phase, :schedule_group, :game_participants)
                       .select { |game| policy.eligible?(game, now: now) }
 
           context.league = league

data/app/services/jumbotron/services/canonical/upsert_game_participant.rb

@@ -13,7 +13,9 @@ module Jumbotron
           team_result = UpsertTeam.call(
             team_input: Jumbotron::Canonical::TeamInput.new(
               provider_identities: participant_input.provider_identities,
-              name: participant_input.team_name
+              name: participant_input.team_name,
+              nickname: participant_input.team_nickname,
+              abbreviation: participant_input.team_abbreviation
             ),
             observed_at: observed_at,
             change_set: change_set
@@ -45,16 +47,18 @@ module Jumbotron
         end
 
         def create_new!(team)
-          gp = game.game_participants.create!(
+          attrs = {
             team: team,
             role: participant_input.role,
             score: participant_input.score,
             result: participant_input.result,
             observed_at: observed_at,
             changed_at: observed_at
-          )
+          }.merge(initial_record_attrs)
+          gp = game.game_participants.create!(attrs)
           change_set.record(subject: gp, attribute: "role", previous: nil, new_value: gp.role)
           change_set.record(subject: gp, attribute: "score", previous: nil, new_value: gp.score)
+          record_create_history!(gp)
           gp
         end
 
@@ -77,11 +81,96 @@ module Jumbotron
             participant.public_send("#{key}=", value)
             material = true
           end
+          material |= apply_record_snapshots!(participant)
           participant.observed_at = observed_at
           participant.changed_at = observed_at if material
           participant.save!
           participant
         end
+
+        def initial_record_attrs
+          summary = participant_input.record_summary
+          return {} if summary.blank?
+
+          attrs = {
+            record_summary_current: summary,
+            record_observed_at: observed_at
+          }
+          if game.lifecycle == "completed"
+            attrs[:record_summary_post_game] = summary
+          elsif game.lifecycle != "cancelled"
+            attrs[:record_summary_entering] = summary
+          end
+          attrs
+        end
+
+        def record_create_history!(participant)
+          %i[
+            record_summary_entering
+            record_summary_current
+            record_summary_post_game
+          ].each do |attr|
+            value = participant.public_send(attr)
+            next if value.blank?
+
+            change_set.record(subject: participant, attribute: attr.to_s, previous: nil, new_value: value)
+          end
+        end
+
+        def apply_record_snapshots!(participant)
+          summary = participant_input.record_summary
+          return false if summary.blank?
+
+          material = false
+          if participant.record_summary_current != summary
+            change_set.record(
+              subject: participant,
+              attribute: "record_summary_current",
+              previous: participant.record_summary_current,
+              new_value: summary
+            )
+            participant.record_summary_current = summary
+            material = true
+          end
+          participant.record_observed_at = observed_at
+
+          if game.lifecycle == "completed"
+            material |= apply_post_game_record!(participant, summary)
+          elsif game.lifecycle != "cancelled"
+            material |= assign_entering_record!(participant, summary)
+          end
+          material
+        end
+
+        def assign_entering_record!(participant, summary) # rubocop:disable Naming/PredicateMethod
+          return false if participant.record_summary_entering == summary
+
+          change_set.record(
+            subject: participant,
+            attribute: "record_summary_entering",
+            previous: participant.record_summary_entering,
+            new_value: summary
+          )
+          participant.record_summary_entering = summary
+          true
+        end
+
+        # Authoritative post-game only: never invent W–L; if total still equals
+        # entering on a completed observation, leave post_game nil (Strategy B).
+        def apply_post_game_record!(participant, summary) # rubocop:disable Naming/PredicateMethod
+          entering = participant.record_summary_entering
+          return false if entering.present? && summary == entering
+          return false if participant.record_summary_post_game == summary
+
+          change_set.record(
+            subject: participant,
+            attribute: "record_summary_post_game",
+            previous: participant.record_summary_post_game,
+            new_value: summary
+          )
+          participant.record_summary_post_game = summary
+          true
+        end
       end
     end
   end

data/app/services/jumbotron/services/canonical/upsert_team.rb

@@ -57,6 +57,8 @@ module Jumbotron
             team.name = team_input.name
             team.changed_at = observed_at
           end
+          apply_nickname!(team)
+          apply_abbreviation!(team)
           # key is immutable after assignment — never regenerate from name or provider id
           team.observed_at = observed_at
           team.save!
@@ -66,15 +68,61 @@ module Jumbotron
         def create_new!
           team = Team.create!(
             name: team_input.name,
+            nickname: team_input.nickname,
+            abbreviation: team_input.abbreviation,
             key: allocate_key!(team_input.name),
             observed_at: observed_at,
             changed_at: observed_at
           )
           change_set.record(subject: team, attribute: "name", previous: nil, new_value: team.name)
           change_set.record(subject: team, attribute: "key", previous: nil, new_value: team.key)
+          if team.nickname.present?
+            change_set.record(
+              subject: team,
+              attribute: "nickname",
+              previous: nil,
+              new_value: team.nickname
+            )
+          end
+          if team.abbreviation.present?
+            change_set.record(
+              subject: team,
+              attribute: "abbreviation",
+              previous: nil,
+              new_value: team.abbreviation
+            )
+          end
           team
         end
 
+        def apply_nickname!(team)
+          return if team_input.nickname.nil?
+          return if team.nickname == team_input.nickname
+
+          change_set.record(
+            subject: team,
+            attribute: "nickname",
+            previous: team.nickname,
+            new_value: team_input.nickname
+          )
+          team.nickname = team_input.nickname
+          team.changed_at = observed_at
+        end
+
+        def apply_abbreviation!(team)
+          return if team_input.abbreviation.nil?
+          return if team.abbreviation == team_input.abbreviation
+
+          change_set.record(
+            subject: team,
+            attribute: "abbreviation",
+            previous: team.abbreviation,
+            new_value: team_input.abbreviation
+          )
+          team.abbreviation = team_input.abbreviation
+          team.changed_at = observed_at
+        end
+
         def allocate_key!(name)
           base = Jumbotron::TeamKey.normalize(name)
           return base unless Team.exists?(key: base)

data/app/services/jumbotron/services/canonical/upsert_venue.rb

@@ -52,6 +52,7 @@ module Jumbotron
 
         def update_existing!(venue_id)
           venue = Venue.lock.find(venue_id)
+          material = false
           if venue.name != venue_input.name
             change_set.record(
               subject: venue,
@@ -60,8 +61,10 @@ module Jumbotron
               new_value: venue_input.name
             )
             venue.name = venue_input.name
-            venue.changed_at = observed_at
+            material = true
           end
+          material |= apply_location!(venue)
+          venue.changed_at = observed_at if material
           venue.observed_at = observed_at
           venue.save!
           venue
@@ -70,13 +73,42 @@ module Jumbotron
         def create_new!
           venue = Venue.create!(
             name: venue_input.name,
+            city: venue_input.city,
+            region: venue_input.region,
             observed_at: observed_at,
             changed_at: observed_at
           )
           change_set.record(subject: venue, attribute: "name", previous: nil, new_value: venue.name)
+          if venue.city.present?
+            change_set.record(subject: venue, attribute: "city", previous: nil, new_value: venue.city)
+          end
+          if venue.region.present?
+            change_set.record(subject: venue, attribute: "region", previous: nil, new_value: venue.region)
+          end
           venue
         end
 
+        def apply_location!(venue)
+          material = false
+          {
+            city: venue_input.city,
+            region: venue_input.region
+          }.each do |key, value|
+            next if value.nil?
+            next if venue.public_send(key) == value
+
+            change_set.record(
+              subject: venue,
+              attribute: key.to_s,
+              previous: venue.public_send(key),
+              new_value: value
+            )
+            venue.public_send("#{key}=", value)
+            material = true
+          end
+          material
+        end
+
         def recover_after_race!
           ref = venue_input.provider_identities.first
           identity = ProviderIdentity.find_by!(

data/app/services/jumbotron/services/public/assemble_public_game.rb

@@ -61,7 +61,12 @@ module Jumbotron
         def build_venue(venue)
           return if venue.nil?
 
-          Jumbotron::Public::Venue.new(id: venue.id, name: venue.name)
+          Jumbotron::Public::Venue.new(
+            id: venue.id,
+            name: venue.name,
+            city: venue.city,
+            region: venue.region
+          )
         end
 
         def build_participant(participant)
@@ -69,14 +74,28 @@ module Jumbotron
             role: participant.role,
             score: participant.score,
             result: participant.result,
+            record: resolve_presentation_record(participant),
             team: Jumbotron::Public::Team.new(
               id: participant.team.id,
               name: participant.team.name,
-              key: participant.team.key
+              nickname: participant.team.nickname,
+              key: participant.team.key,
+              abbreviation: participant.team.abbreviation
             )
           )
         end
 
+        # Lifecycle-resolved game-time record for presentation. Never falls back to
+        # entering when completed post-game is missing.
+        def resolve_presentation_record(participant)
+          case game.lifecycle
+          when "scheduled", "in_progress", "postponed", "suspended"
+            participant.record_summary_entering
+          when "completed"
+            participant.record_summary_post_game
+          end
+        end
+
         def map_currents(lines)
           return [] unless Array(includes).include?(:current_lines)
 

data/db/migrate/20260828180001_add_nickname_to_jumbotron_teams.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddNicknameToJumbotronTeams < ActiveRecord::Migration[8.0]
+  def change
+    add_column :jumbotron_teams, :nickname, :string
+  end
+end

data/db/migrate/20260828220001_add_game_presentation_contract_fields.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class AddGamePresentationContractFields < ActiveRecord::Migration[8.0]
+  def change
+    change_table :jumbotron_game_participants, bulk: true do |t|
+      t.string :record_summary_entering
+      t.string :record_summary_current
+      t.string :record_summary_post_game
+      t.datetime :record_observed_at
+    end
+
+    change_table :jumbotron_venues, bulk: true do |t|
+      t.string :city
+      t.string :region
+    end
+
+    add_column :jumbotron_teams, :abbreviation, :string
+  end
+end

data/lib/jumbotron/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jumbotron
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jumbotron
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - matt-taylor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: command_tower
@@ -65,6 +65,7 @@ files:
 - app/adapters/jumbotron/adapters/espn/nfl_helpers/progress.rb
 - app/adapters/jumbotron/adapters/espn/nfl_helpers/scoreboard.rb
 - app/adapters/jumbotron/adapters/espn/nfl_helpers/season_phase.rb
+- app/adapters/jumbotron/adapters/espn/nfl_helpers/team_nickname.rb
 - app/adapters/jumbotron/adapters/espn/nfl_helpers/teams.rb
 - app/adapters/jumbotron/adapters/line_acquisition.rb
 - app/adapters/jumbotron/adapters/operation.rb
@@ -90,6 +91,7 @@ files:
 - app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/side_quote.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/team_odds.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/competitor.rb
+- app/deserializers/jumbotron/deserializers/clients/espn/competitor_record.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/event.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/scoreboard/get.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/season.rb
@@ -98,6 +100,7 @@ files:
 - app/deserializers/jumbotron/deserializers/clients/espn/team.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/teams/get.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/venue.rb
+- app/deserializers/jumbotron/deserializers/clients/espn/venue_address.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/week.rb
 - app/deserializers/jumbotron/deserializers/public/game.rb
 - app/deserializers/jumbotron/deserializers/public/game_ids.rb
@@ -206,6 +209,8 @@ files:
 - db/migrate/20260814000001_create_jumbotron_line_observations.rb
 - db/migrate/20260820000001_add_progress_to_jumbotron_games.rb
 - db/migrate/20260827150001_add_key_to_jumbotron_teams.rb
+- db/migrate/20260828180001_add_nickname_to_jumbotron_teams.rb
+- db/migrate/20260828220001_add_game_presentation_contract_fields.rb
 - docs/testing.md
 - docs/upgrades/0.1.2.md
 - docs/upgrades/0.1.3.md