studio-engine 0.122.0 → 0.124.0

data/lib/studio/marketing_kit.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+# THE MARKETING KIT (docs/SITE_FOOTER.md, "The marketing kit"): the public page
+# at /marketing-kit, with the app's logos, colours and typefaces for anyone to
+# use. Studio.marketing_kit declares it, as a Hash or a callable taking the view:
+#
+#   config.marketing_kit = {
+#     tagline:   "Everything, by example",
+#     logos:     [ { title: "Icon", light: { png: "/brand/icon-light.png", svg: "/brand/icon-light.svg" },
+#                                   dark:  { png: "/brand/icon-dark.png",  svg: "/brand/icon-dark.svg" } } ],
+#     palette:   [ { name: "Ink", hex: "#1A1535" } ],
+#     typefaces: [ { role: "Headings", family: "Montserrat", weight: 800, name: "Montserrat ExtraBold" } ]
+#   }
+#
+# Every key is optional. A missing `logos` derives from the app's brand artwork
+# (Studio.navbar_wordmark, the footer's lockup, Studio.theme_logos) and a missing
+# `palette` from the colours it paints (ThemeSetting, else Studio.theme_config),
+# so a new app has a working page with no setup. The engine knows no typeface or tagline, so those parts are
+# simply absent until declared.
+#
+# A FILE THAT IS NOT THERE IS NOT AN ERROR. Each file is looked for before it is
+# linked: a tone with no file has no tile and no link, and a logo with no file
+# has no card. So the page shows no broken image, and it does not raise.
+#
+# `light` means the artwork made for a light background; `dark`, for a dark one.
+module Studio
+  module MarketingKit
+    PATH = "/marketing-kit"
+    LABEL = "Marketing Kit"
+    CONTROLLER = "studio/marketing_kit"
+    ROUTE_NAME = :studio_marketing_kit
+
+    LIGHT_GROUND = "#FFFFFF"
+    FALLBACK_DARK_GROUND = "#111827"
+
+    HEX = /\A#(?:\h{3}|\h{4}|\h{6}|\h{8})\z/
+    # What may sit inside a style attribute: a family list, and a CSS weight.
+    FONT_FAMILY = /\A[\w\s"',.-]+\z/
+    FONT_WEIGHT = /\A(?:[1-9]00|normal|bold|lighter|bolder)\z/
+
+    DOWNLOAD_LABELS = { light: "Download Light", dark: "Download Dark" }.freeze
+    FORMATS = %i[png svg].freeze
+
+    module_function
+
+    def validate!(declared)
+      return if declared.nil? || declared == false || declared.is_a?(Hash) || declared.respond_to?(:call)
+
+      raise ArgumentError,
+            "Studio.marketing_kit must be nil (derive it), a Hash, or a callable receiving the view " \
+            "(got #{declared.class}). See docs/SITE_FOOTER.md."
+    end
+
+    # The kit the page prints.
+    #
+    #   logos:       Studio.theme_logos, for a kit that declares no `logos`
+    #   artwork:     brand artwork of one file per theme, [ title, { light:, dark: } ]
+    #                rows that come before them (the wordmark, the lockup)
+    #   theme:       the colours the app paints, for a kit that declares no `palette`
+    #   name:        the site's name, for a kit that declares none
+    #   dark_ground: the dark tile's background
+    #   locate:      a callable answering a file's URL, or nil when it is not there
+    def resolve(declared, view, logos: [], artwork: [], theme: {}, name: nil, dark_ground: nil,
+                locate: ->(file) { locate(file, view) })
+      raw = declared.respond_to?(:call) ? declared.call(view) : declared
+      validate!(raw)
+      facts = raw ? SiteFooter.symbolize(raw) : {}
+      ground = hex(dark_ground) || FALLBACK_DARK_GROUND
+
+      {
+        name: SiteFooter.text(facts[:name]) || SiteFooter.text(name),
+        tagline: SiteFooter.text(facts[:tagline]),
+        logos: logo_cards(facts.key?(:logos) ? facts[:logos] : derived_artwork(artwork) + derived_logos(logos), locate, ground),
+        palette: swatches(facts.key?(:palette) ? facts[:palette] : derived_palette(theme)),
+        typefaces: typefaces(facts[:typefaces])
+      }
+    end
+
+    # ---- logos ---------------------------------------------------------------
+
+    # One card per logo that has a file, each with one tile per tone that has one.
+    # Two theme entries for one file (a Navbar Logo that is also the Auth Logo)
+    # are one card.
+    def logo_cards(declared, locate, dark_ground)
+      Array(declared).filter_map do |row|
+        next unless row.respond_to?(:to_h) && !row.is_a?(Array)
+
+        logo = SiteFooter.symbolize(row)
+        tones = { light: LIGHT_GROUND, dark: dark_ground }.filter_map do |tone, ground|
+          tile(logo[:title], tone, ground, logo[tone], locate)
+        end
+        { title: SiteFooter.text(logo[:title]), tones: tones } unless tones.empty?
+      end.uniq { |card| card[:tones].map { |tone| tone[:href] } }
+    end
+
+    # A download is the PNG when there is one, else the SVG. The tile shows the
+    # SVG when there is one, since it stays sharp at any size.
+    def tile(title, tone, ground, files, locate)
+      found = formats(files).transform_values { |file| locate.call(file) }.compact
+      href = found[:png] || found[:svg]
+      return nil if href.nil?
+
+      { tone: tone, ground: ground, label: DOWNLOAD_LABELS.fetch(tone), href: href,
+        src: tile_src(found[:svg] || found[:png]),
+        alt: [SiteFooter.text(title), "for a #{tone} background"].compact.join(", ") }
+    end
+
+    # { png:, svg: }, or one path whose extension says which it is.
+    def formats(files)
+      return SiteFooter.symbolize(files).slice(*FORMATS) if files.is_a?(Hash)
+      return {} unless files.is_a?(String)
+
+      format = File.extname(files.split(/[?#]/).first.to_s).delete_prefix(".").downcase.to_sym
+      FORMATS.include?(format) ? { format => files } : {}
+    end
+
+    # ?kit keeps a tile's tone. A host may repaint its own logo by the image's
+    # exact src on a dark page (the hub's `.dark img[src="/brand/icon-light.svg"]`),
+    # which would turn the light tile's artwork into the dark one. The download
+    # keeps the plain URL.
+    def tile_src(url)
+      return url if url.match?(%r{\Ahttps?://}i)
+
+      "#{url}#{url.include?('?') ? '&' : '?'}kit"
+    end
+
+    # Artwork that already names its file per tone, as the wordmark and the
+    # lockup do. Each file may have its other format beside it.
+    def derived_artwork(rows)
+      Array(rows).filter_map do |title, files|
+        next unless files.respond_to?(:to_h) && !files.is_a?(Array)
+
+        tones = SiteFooter.symbolize(files).slice(:light, :dark).compact
+        { title: title }.merge(tones.transform_values { |file| both_formats(file.to_s.delete_suffix(File.extname(file.to_s))) })
+      end
+    end
+
+    # The logos Studio.theme_logos implies. It names one file per logo and says
+    # nothing about tone, so the rest is looked for beside it: the same stem as
+    # the other format, and a -light/-dark (or _light/_dark) sibling. A stem with
+    # no such hint is the light artwork.
+    def derived_logos(theme_logos)
+      entries = Array(theme_logos).map { |entry| entry.is_a?(Hash) ? SiteFooter.symbolize(entry) : { file: entry } }
+      entries.filter_map do |entry|
+        file = SiteFooter.text(entry[:file])
+        next if file.nil?
+
+        title = SiteFooter.text(entry[:title]) || humanize(file)
+        next if title.match?(/favicon/i)
+
+        { title: title }.merge(tone_candidates(file))
+      end
+    end
+
+    def tone_candidates(file)
+      stem = file.delete_suffix(File.extname(file))
+      base, separator, hint = stem.match(/\A(.+)([-_])(light|dark)\z/)&.captures
+
+      return { light: both_formats(stem), dark: both_formats("#{stem}-dark") } if hint.nil?
+
+      other = hint == "light" ? "dark" : "light"
+      { hint.to_sym => both_formats(stem), other.to_sym => both_formats("#{base}#{separator}#{other}") }
+    end
+
+    def both_formats(stem) = { png: "#{stem}.png", svg: "#{stem}.svg" }
+
+    def humanize(file)
+      File.basename(file, File.extname(file)).tr("-_", " ").split.map(&:capitalize).join(" ")
+    end
+
+    # ---- colours and type ----------------------------------------------------
+
+    def derived_palette(theme)
+      theme.to_h.map { |name, value| { name: name.to_s.capitalize, hex: value } }
+    end
+
+    # Only a real hex is printed: it goes into a style attribute and the clipboard.
+    def swatches(declared)
+      Array(declared).filter_map do |row|
+        next unless row.respond_to?(:to_h) && !row.is_a?(Array)
+
+        swatch = SiteFooter.symbolize(row)
+        value = hex(swatch[:hex])
+        { name: SiteFooter.text(swatch[:name]), hex: value } unless value.nil?
+      end
+    end
+
+    def hex(value)
+      string = value.to_s.strip
+      string.match?(HEX) ? string : nil
+    end
+
+    # A face with no family cannot be shown. A family or weight CSS would not
+    # read leaves the specimen in the page's own type, with its label intact.
+    def typefaces(declared)
+      Array(declared).filter_map do |row|
+        next unless row.respond_to?(:to_h) && !row.is_a?(Array)
+
+        face = SiteFooter.symbolize(row)
+        family = SiteFooter.text(face[:family])
+        next if family.nil?
+
+        { role: SiteFooter.text(face[:role]), family: (family if family.match?(FONT_FAMILY)),
+          weight: face[:weight].to_s[FONT_WEIGHT], name: SiteFooter.text(face[:name]) || family }
+      end
+    end
+
+    # ---- finding a file ------------------------------------------------------
+
+    # The URL of a file, or nil when it is not there. An http(s) URL is taken at
+    # its word, since looking would cost the page a network call. A path is
+    # looked for in public/; a bare name, then in the asset pipeline.
+    def locate(file, view = nil)
+      value = SiteFooter.text(file)
+      return nil if value.nil?
+      return value if value.match?(%r{\Ahttps?://[^\s]+\z}i)
+      return nil unless local?(value)
+
+      path = "/#{value.delete_prefix('/')}"
+      return path if public_file?(path)
+
+      value.start_with?("/") ? nil : pipeline_path(value, view)
+    rescue StandardError
+      nil
+    end
+
+    # No scheme, no host, no control character and no climbing out of public/.
+    def local?(value)
+      return false if value.match?(/[\x00-\x1f\x7f\s]/) || value.start_with?("//")
+      return false if value.match?(/\A[a-z][a-z0-9+.-]*:/i)
+
+      !value.split(/[?#]/).first.to_s.split("/").include?("..")
+    end
+
+    def public_file?(path)
+      !PublicFileVersion.version(path.split(/[?#]/).first).nil?
+    end
+
+    def pipeline_path(name, view)
+      return nil unless view.respond_to?(:asset_path) && in_pipeline?(name)
+
+      view.asset_path(name)
+    end
+
+    # Propshaft answers through its load path; Sprockets through its environment
+    # or, precompiled, its manifest. asset_path alone cannot say: a host may have
+    # it fall back to a plain path for a file that is not there.
+    def in_pipeline?(name)
+      return false unless defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+
+      app = ::Rails.application
+      assets = app.respond_to?(:assets) ? app.assets : nil
+      return !assets.load_path.find(name).nil? if assets.respond_to?(:load_path)
+      return !assets.find_asset(name).nil? if assets.respond_to?(:find_asset)
+
+      manifest = app.respond_to?(:assets_manifest) ? app.assets_manifest : nil
+      manifest.respond_to?(:assets) && manifest.assets.key?(name)
+    end
+
+    # ---- the route -----------------------------------------------------------
+
+    # True when the route set holds a GET of /marketing-kit that is not the
+    # engine's: the host's own page, which wins. Asked for every footer on a page
+    # that has no engine route, and by the engine route's constraint, so the
+    # answer is kept per route set until that set changes size.
+    def host_route?(routes)
+      table = routes.routes
+      known = host_route_memo[routes]
+      return known.last if known && known.first == table.size
+
+      answer = table.any? { |route| host_page_route?(route) }
+      host_route_memo[routes] = [table.size, answer]
+      answer
+    end
+
+    def host_route_memo
+      @host_route_memo ||= {}.compare_by_identity
+    end
+
+    def host_page_route?(route)
+      return false if route.defaults[:controller] == CONTROLLER
+      return false unless route.path.spec.to_s.delete_suffix("(.:format)") == PATH
+
+      verbs = route.verb.to_s
+      verbs.empty? || verbs.split("|").include?("GET")
+    end
+
+    # The engine's route gives way to a host route drawn AFTER Studio.routes.
+    # (One drawn before it wins by order, and then the engine draws nothing.)
+    class YieldToHostRoute
+      def initialize(routes) = @routes = routes
+      def matches?(_request) = !MarketingKit.host_route?(@routes)
+    end
+
+    # Where the footer links: the page's path, or nil when this app has no page.
+    def page_path(view, routes)
+      return nil if routes.nil?
+
+      SiteFooter.host_path(view, ROUTE_NAME, routes) || (PATH if host_route?(routes))
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/studio/site_footer.rb

@@ -31,8 +31,8 @@ module Studio
     DEFAULT_BOOKING_LABEL = "Schedule a call"
     DEFAULT_ZOOM = 15
 
-    # The engine's own booking page keeps the footer for a signed-in viewer.
-    OWN_CONTROLLERS = %w[studio/bookings].freeze
+    # The engine's own public pages keep the footer for a signed-in viewer.
+    OWN_CONTROLLERS = %w[studio/bookings studio/marketing_kit].freeze
 
     # The only schemes a footer href may carry. Anything else, notably
     # `javascript:` and `data:`, is never written into an href: the label is
@@ -124,7 +124,7 @@ module Studio
     # THE DEFAULT FOOTER'S FACTS: what an app that sets nothing gets. Only what
     # is known to be true of the host: a legal line linking the routes in
     # DEFAULT_LEGAL that the host really has. The name and the logo come from
-    # `resolve`'s own fallbacks. No address, no email, no tagline, no social row
+    # `resolve`'s own fallbacks, and so does the Marketing Kit link. No address, no email, no tagline, no social row
     # and no link columns: the engine cannot know them, and a guessed link is a
     # dead one.
     #
@@ -170,13 +170,17 @@ module Studio
     #   booking_path: the booking page's path (Studio.booking_path_for), or nil
     #   address:      Studio.site_footer_address: the address of facts that
     #                 carry none of their own
-    def resolve(declared, view, name: nil, logo: nil, booking_path: nil, address: nil)
+    #   chat:         the Chat entry's [label, path] (`chat_row`), or nil
+    #   marketing_kit: the kit page's path (Studio::MarketingKit.page_path), or nil
+    def resolve(declared, view, name: nil, logo: nil, booking_path: nil, address: nil, chat: nil, marketing_kit: nil)
       raw = declared.respond_to?(:call) ? declared.call(view) : declared
       return nil if raw.nil? || raw == false
 
       facts = symbolize(raw)
       site_name = text(facts[:name]) || text(name)
       booking = symbolize(facts[:booking] || {})
+      columns = with_chat(Array(facts[:columns]).filter_map { |row| column(row, booking_path) }, chat)
+      legal = Array(facts[:legal]).filter_map { |row| link(row, booking_path) }
 
       {
         name: site_name,
@@ -189,8 +193,9 @@ module Studio
         email: text(facts[:email]),
         address: address_for(facts, address),
         social: Array(facts[:social]).filter_map { |row| social(row) },
-        columns: Array(facts[:columns]).filter_map { |row| column(row, booking_path) },
-        legal: Array(facts[:legal]).filter_map { |row| link(row, booking_path) },
+        columns: columns,
+        legal: legal,
+        marketing_kit: marketing_kit_link(facts, marketing_kit, columns, legal),
         booking_label: text(booking[:label]) || DEFAULT_BOOKING_LABEL,
         booking_title: text(booking[:title])
       }
@@ -374,6 +379,60 @@ module Studio
       { heading: heading, links: links, width: column_width(options[:width]) }
     end
 
+    # The column the standard Chat entry joins, made if the app has none.
+    CONTACT_HEADING = "Contact"
+
+    # The Chat entry for this viewer as a [label, path] row, or nil: no path
+    # means the app has no chat, and `allowed` (a callable taking the viewer, nil
+    # when signed out) can hide it, e.g. admins only while testing. A hook that
+    # raises hides the entry and logs; the footer is on every page, and a link
+    # meant for a few must not show because its gate broke.
+    def chat_row(view, path:, label: nil, allowed: nil)
+      href = path.respond_to?(:call) ? path.call(view) : path
+      return nil if text(href).nil?
+      return nil unless chat_allowed?(view, allowed)
+
+      [text(label) || "Chat", href]
+    end
+
+    def chat_allowed?(view, allowed)
+      return true if allowed.nil?
+
+      user = view.respond_to?(:current_user) ? view.current_user : nil
+      (allowed.respond_to?(:call) ? allowed.call(user) : allowed) ? true : false
+    rescue StandardError => error
+      SiteFooter.reporter.call("[studio.site_footer] site_footer_chat_allowed raised #{error.class}: the Chat link is hidden")
+      false
+    end
+
+    # `columns` with the Chat entry last in the Contact column (any case), which
+    # is added at the end if there is none. A refused href adds nothing, and an
+    # app that already links the same path keeps its own row.
+    def with_chat(columns, chat)
+      row = chat && link(chat)
+      return columns if row.nil? || row[:href].nil?
+
+      at = columns.index { |column| column[:heading].to_s.casecmp?(CONTACT_HEADING) }
+      return columns + [{ heading: CONTACT_HEADING, links: [row], width: nil }] if at.nil?
+      return columns if columns[at][:links].any? { |known| known[:href] == row[:href] }
+
+      columns.each_with_index.map do |column, index|
+        index == at ? column.merge(links: column[:links] + [row]) : column
+      end
+    end
+
+    # THE MARKETING KIT LINK, in the brand block: every app with the page gets it
+    # without declaring it. An app that links the page itself keeps its own row
+    # and gets no second one, and `marketing_kit: false` in the facts shows none.
+    def marketing_kit_link(facts, path, columns, legal)
+      return nil if path.nil? || (facts.key?(:marketing_kit) && !facts[:marketing_kit])
+
+      declared = columns.flat_map { |column| column[:links] } + legal
+      return nil if declared.any? { |row| Studio::Booking.same_path?(row[:href], path) }
+
+      link([ Studio::MarketingKit::LABEL, path ])
+    end
+
     # A column's width hint, or nil for the default share. Anything that is not a
     # number between MIN_COLUMN_WIDTH and MAX_COLUMN_WIDTH is no hint.
     MIN_COLUMN_WIDTH = 0.5

data/lib/studio/ui_primitives.rb

@@ -10,8 +10,10 @@ module Studio
         align-items: center;
         justify-content: center;
         vertical-align: middle;
-        width: 1.5rem;
-        height: 1.25rem;
+        /* In em so a larger glyph fits: at text-lg on a 16px scale a fixed 1.25rem
+           box clipped 4px off a 24px emoji. The floor keeps the navbar size. */
+        width: max(1.5rem, 1.25em);
+        height: max(1.25rem, 1.25em);
         overflow: hidden;
       }
 

data/lib/studio/version.rb

@@ -1,3 +1,3 @@
 module Studio
-  VERSION = "0.122.0"
+  VERSION = "0.124.0"
 end

data/lib/studio.rb

@@ -34,6 +34,7 @@ require "studio/hold_button"
 require "studio/partial_block"
 require "studio/sidebar_sections"
 require "studio/site_footer"
+require "studio/marketing_kit"
 require "studio/booking"
 require "studio/navbar_links"
 require "studio/navbar_signed_out_cta"
@@ -159,6 +160,23 @@ module Studio
   # no-preview holds the old page until the fresh response arrives.
   mattr_accessor :smooth_load,          default: false
 
+  # ---- App-to-app page transitions -----------------------------------------
+  # One of :left, :right, :top, :bottom, or nil (the default: nothing changes).
+  # The way this app's pages move on every page change (docs/PAGE_TRANSITIONS.md).
+  # It is THE one switch: a set direction also turns smooth-load on, whatever
+  # Studio.smooth_load says, because the view transition is what it styles.
+  PAGE_TRANSITION_DIRECTIONS = %i[left right top bottom].freeze
+  mattr_reader :page_transition_direction, default: nil
+
+  def self.page_transition_direction=(value)
+    direction = value.presence&.to_sym
+    unless direction.nil? || PAGE_TRANSITION_DIRECTIONS.include?(direction)
+      raise ArgumentError, "Studio.page_transition_direction must be one of " \
+                           "#{PAGE_TRANSITION_DIRECTIONS.join(', ')} or nil (got #{value.inspect})"
+    end
+    @@page_transition_direction = direction
+  end
+
   # Minimum ms the nav spinner stays visible once shown (_head.html.erb).
   # Apps wrapping multi-second operations in the spinner (e.g. Solana RPC)
   # keep the high default to avoid flicker; smooth-load apps typically drop
@@ -1471,7 +1489,7 @@ module Studio
   mattr_accessor :agent_chat_souls,   default: []
   mattr_accessor :agent_chat_hub_url, default: "https://mcritchie.studio"
   # The app's bearer credential for the hub. Leave nil to read
-  # ENV["AGENT_CHAT_TOKEN"] (1Password apps.<slug>.agent-chat).
+  # ENV["AGENT_CHAT_TOKEN"] (1Password agent-chat.<slug>.applications).
   mattr_accessor :agent_chat_token,   default: nil
   # Which signed-in users the hub may know by email. An email the user only
   # CLAIMS (the profile page saves a new address and clears email_verified_at;
@@ -1486,6 +1504,50 @@ module Studio
     Array(agent_chat_souls).map { |soul| soul.to_s.strip }.reject(&:empty?).uniq
   end
 
+  # Who may use the chat at all: a callable taking the user, nil when signed out.
+  # The server's gate, not only the look: Studio::AgentChatsController answers a
+  # refused viewer 403 on both calls before any hub call, and the chat partial
+  # renders nothing for them. The footer's Chat link follows it too unless
+  # site_footer_chat_allowed is set, so one setting covers both. Default: everyone
+  # (a public chat). While testing:
+  #
+  #   config.agent_chat_allowed = ->(user) { user&.admin? }
+  mattr_accessor :agent_chat_allowed, default: ->(_user) { true }
+
+  # The one reading of Studio.agent_chat_allowed. A hook that raises answers false
+  # and logs: `user.admin?` on a signed-out visitor closes the chat, never opens it.
+  def self.agent_chat_allowed?(user)
+    hook = agent_chat_allowed
+    (hook.respond_to?(:call) ? hook.call(user) : hook) ? true : false
+  rescue StandardError => e
+    Rails.logger&.warn("[studio] agent_chat_allowed raised #{e.class}: treated as not allowed") if defined?(Rails.logger)
+    false
+  end
+
+  # Who may talk by voice (docs/AGENT_CHAT.md, "Talking by voice"): a callable
+  # taking the signed-in user. It decides who sees the chat's microphone, who
+  # may post a take to POST /voice/takes (each one is a paid vendor call), and
+  # whether the proxy forwards a message's `voice`. A signed-out visitor is
+  # never asked about: no user, no voice. While testing, an app narrows it:
+  #
+  #   config.voice_chat_allowed = ->(user) { user.admin? }
+  #
+  # A user Studio.agent_chat_allowed refuses may not talk either, whatever this says.
+  mattr_accessor :voice_chat_allowed, default: ->(user) { user.present? }
+
+  # The one reading of Studio.voice_chat_allowed. False for no user, and for a user
+  # the chat itself refuses, whatever the hook says. A hook that raises answers false and logs: the safe answer on a
+  # paid, sign-in-only control, and a page never falls over because of it.
+  def self.voice_chat_allowed?(user)
+    return false if user.nil? || !agent_chat_allowed?(user)
+
+    hook = voice_chat_allowed
+    (hook.respond_to?(:call) ? hook.call(user) : hook) ? true : false
+  rescue StandardError => e
+    Rails.logger&.warn("[studio] voice_chat_allowed raised #{e.class}: treated as not allowed") if defined?(Rails.logger)
+    false
+  end
+
   class S3ConfigError < StandardError; end
 
   # Whether to validate the host app's User model at boot. See docs/USER_CONTRACT.md.
@@ -1733,6 +1795,20 @@ module Studio
     SidebarSections.resolve(sidebar_sections, view)
   end
 
+  # The standard Chat entry in the footer's Contact column (docs/SITE_FOOTER.md,
+  # "The Chat link"). OFF until the app names a path: no path, no entry.
+  #
+  #   config.site_footer_chat_path = "/chat"       # or ->(view) { view.chat_path }
+  #   config.site_footer_chat_label = "Chat"       # the default
+  #   config.site_footer_chat_allowed = ->(user) { user&.admin? }  # default: Studio.agent_chat_allowed
+  #
+  # site_footer_chat_allowed takes the viewer, nil when signed out; a hook that
+  # raises hides the entry and logs (SiteFooter.chat_row). Unset, the link follows
+  # Studio.agent_chat_allowed, so the link shows to whom the chat answers.
+  mattr_accessor :site_footer_chat_path, default: nil
+  mattr_accessor :site_footer_chat_label, default: "Chat"
+  mattr_accessor :site_footer_chat_allowed, default: nil
+
   # The site footer's facts resolved for a view (lib/studio/site_footer.rb), or
   # nil when the app turned the footer off (or its own callable answered nil).
   # Unset, the facts are the default footer's. The name defaults to the site
@@ -1744,7 +1820,11 @@ module Studio
 
     declared = site_footer.nil? ? SiteFooter.default_facts(view, routes: host_route_set) : site_footer
     SiteFooter.resolve(declared, view, name: site_identity[:title], logo: logo_for("Footer Logo"),
-                                       booking_path: booking_path_for(view), address: site_footer_address)
+                                       booking_path: booking_path_for(view), address: site_footer_address,
+                                       chat: SiteFooter.chat_row(view, path: site_footer_chat_path,
+                                                                       label: site_footer_chat_label,
+                                                                       allowed: site_footer_chat_allowed.nil? ? agent_chat_allowed : site_footer_chat_allowed),
+                                       marketing_kit: MarketingKit.page_path(view, host_route_set))
   end
 
   # The host's route set, for the default footer's legal links. nil outside a
@@ -1755,6 +1835,65 @@ module Studio
     ::Rails.application.routes
   end
 
+  # The marketing kit: the public page at /marketing-kit (lib/studio/marketing_kit.rb,
+  # docs/SITE_FOOTER.md). A Hash, or a callable receiving the view. Unset, the logos
+  # and colours derive from the app's own brand artwork and the colours it paints,
+  # so a new app has a working page with no setup.
+  mattr_reader :marketing_kit, default: nil
+
+  def self.marketing_kit=(declared)
+    MarketingKit.validate!(declared)
+    @@marketing_kit = declared
+  end
+
+  # Whether Studio.routes draws /marketing-kit (Studio::MarketingKitController).
+  #
+  # ON BY DEFAULT: every app should have a kit. The helper is
+  # studio_marketing_kit_path, not marketing_kit_path, because the hub already
+  # owns that name, and a second claim on it raises `Invalid route name, already
+  # in use` and takes down the host's route set (see draw_admin_emails_routes).
+  # The PATH can be shared: a host's own /marketing-kit wins, whichever side of
+  # Studio.routes it is drawn on (Studio.marketing_kit_routes).
+  mattr_accessor :draw_marketing_kit_routes, default: true
+
+  # The kit for a view. `declared` lets a page render a kit other than the app's.
+  def self.marketing_kit_for(view, declared: marketing_kit)
+    colors = marketing_kit_colors
+    MarketingKit.resolve(declared, view, logos: theme_logos, theme: colors,
+                                         artwork: [["Navbar logo", navbar_wordmark], ["Footer logo", marketing_kit_lockup(view)]],
+                                         name: site_identity[:title], dark_ground: colors[:dark])
+  end
+
+  # What the app paints: an /admin/theme edit included, as studio_theme_css_tag
+  # reads it. An app with no database, or no table yet, paints its config.
+  def self.marketing_kit_colors
+    return theme_config unless active_record? && defined?(::ThemeSetting)
+
+    ::ThemeSetting.current.resolved_colors
+  rescue StandardError
+    theme_config
+  end
+
+  # The footer's lockup, already resolved for this request where the view is one.
+  def self.marketing_kit_lockup(view)
+    view.studio_site_footer_facts&.dig(:lockup) if view.respond_to?(:studio_site_footer_facts)
+  end
+
+  # Draws the page into `router`, unless the host's own /marketing-kit got there
+  # first: then this draws nothing, and the host's page is the only route. A host
+  # route drawn later is handled at request time, by the route's constraint.
+  #
+  # Studio.routes calls this. An app with no database cannot call Studio.routes
+  # (docs/SITE_FOOTER.md, "An app with no database") and calls this alone.
+  def self.marketing_kit_routes(router)
+    router.instance_exec do
+      next if MarketingKit.host_route?(@set)
+
+      get MarketingKit::PATH.delete_prefix("/"), to: "#{MarketingKit::CONTROLLER}#show", as: MarketingKit::ROUTE_NAME,
+          format: false, constraints: MarketingKit::YieldToHostRoute.new(@set)
+    end
+  end
+
   # Navbar links resolved for a view context (lib/studio/navbar_links.rb).
   def self.navbar_links_for(view)
     NavbarLinks.resolve(navbar_links, view)
@@ -2051,11 +2190,12 @@ module Studio
         get "schedule", to: "studio/bookings#show", as: :studio_booking
       end
 
-      # The living style guide. Canonical at /admin/style (StyleController#index);
-      # /admin/design_system redirects here but KEEPS its admin_design_system_path
-      # helper so a shipped host sidebar link on the old helper still resolves.
+      # The marketing kit (/marketing-kit): public, ON by default. A host's own
+      # page of the same path wins. See Studio.marketing_kit_routes.
+      Studio.marketing_kit_routes(self) if Studio.draw_marketing_kit_routes
+
+      # The living style guide (StyleController#index).
       get   "admin/style",            to: "style#index",               as: :admin_style
-      get   "admin/design_system",    to: redirect("/admin/style"),    as: :admin_design_system
 
       # The component gallery: Lookbook over the engine's ViewComponent previews.
       # The router refuses anyone but a signed-in admin, so a visitor and a