studio-engine 0.37.0 → 0.39.0

data/app/services/studio/email_image.rb

@@ -1,329 +1,68 @@
 module Studio
-  # The transactional-email registry, and the banner image each registered email
-  # ships with.
+  # DEPRECATED NAME — this is Studio::EmailCatalog now. Every method here just
+  # forwards; there is no behavior in this file.
   #
-  # A registered email is MOSTLY SYMBOLIC of a workflow — a key, a human label,
-  # a line of description. The only real asset is its banner image, which is why
-  # the registry lives here rather than in a model. The branded mailer resolves
-  # the live banner with .url; /admin/emails lists the registry and writes an
-  # override with .store.
+  # The METHOD surface is kept complete, for two reasons:
   #
-  # ## Two layers: inherited default, app-owned override
+  #   1. Engine 0.33 shipped this module as the registry's public name, so any
+  #      app already on 0.33 is calling it.
+  #   2. consumer-ci.yml runs each consumer's DEFAULT BRANCH suite against an
+  #      engine PR, and mcritchie-studio's test/integration/studio_email_image_test.rb
+  #      on `main` calls .url, .store and .record directly. Dropping any of them
+  #      reddens that lane from the moment the PR opens, and nothing inside the
+  #      engine PR can reach the consumer's main to fix it.
   #
-  #   .resolved_url(key) => app's own ImageCache row (its S3 bucket)  # app-owned
-  #                      -> the engine's default gem asset            # inherited
-  #                      -> nil                                       # no image
+  # ONE thing did not survive: the `VARIANTS` CONSTANT. It was a frozen literal
+  # hash, and the registry it stood for is now built at runtime, so a constant
+  # cannot express it. The `variants` METHOD returns the same key => label shape
+  # and is the supported replacement. Checked before dropping it: no consumer's
+  # `main` names the constant — only .url, .store and .record — so consumer CI
+  # stays green. A host that did reference it gets a NameError, not a silent
+  # wrong answer.
   #
-  # `.url(key)` stays the PRE-REGISTRY contract — this app's own image or nil —
-  # so every caller written before the registry keeps its behavior until its app
-  # adopts. See the note on #url; getting this wrong swaps a host's committed
-  # artwork for the engine placeholder in live email.
+  # Delete it once no consumer's main names it — the same staged retirement
+  # /admin/email_images is on.
   #
-  # Defaults RIDE THE GEM (app/assets/images/emails/*), so a brand-new app with
-  # an empty bucket sends good-looking email on day one and needs no cross-app S3
-  # permission. Uploading on an app's /admin/emails writes to THAT app's bucket
-  # and THAT app's ImageCache row — which is exactly "the asset now belongs to
-  # this app". Every app has its own bucket and its own image_caches table, so an
-  # override never leaks between apps.
-  #
-  # ## Registering
-  #
-  # The engine pre-registers the two every Studio app sends (STANDARD below), so
-  # hosts inherit them without declaring anything. A host adds its own workflows
-  # from an initializer, mirroring Studio::ModelPage.register:
-  #
-  #   # config/initializers/studio_emails.rb
-  #   Rails.application.config.to_prepare do
-  #     Studio::EmailImage.register("winnings", label: "Contest winnings",
-  #                                 description: "Sent when a player wins a contest.")
-  #   end
-  #
-  # Re-registering a key updates it in place and keeps its position, so a host
-  # can relabel an inherited email without reordering the page.
+  # Deliberately explicit rather than method_missing: a typo should still raise
+  # NoMethodError here, and the delegated surface should be readable as a list.
   module EmailImage
-    PURPOSE = "email_banner".freeze
-
-    # A registered email. `default_asset` is a logical asset path inside the gem
-    # (resolved through the host's asset pipeline); nil means the email has no
-    # inherited artwork and renders bannerless until someone uploads one.
-    Entry = Struct.new(:key, :label, :description, :default_asset, keyword_init: true) do
-      def to_s = key
-    end
-
-    # The emails EVERY Studio app sends. Pre-registered, so a host inherits both
-    # without declaring anything.
-    STANDARD = [
-      {
-        key: "magic_link",
-        label: "Magic-link sign-in",
-        description: "Passwordless sign-in link. Sent whenever someone asks to sign in by email.",
-        default_asset: "emails/magic-link.png"
-      },
-      {
-        key: "email_change_confirmation",
-        label: "Email change confirmation",
-        description: "Confirms a new address before the change takes effect.",
-        default_asset: "emails/email-change-confirmation.png"
-      }
-    ].freeze
-
-    # Banners render full-bleed at 600px in a 600px card. 1200x600 is the
-    # right cut: 2:1, retina-sharp at render width, and small enough to stay
-    # out of an inbox clipping limit.
-    ASPECT_RATIO = 2.0
-    MAX_WIDTH = 1200
+    PURPOSE = EmailCatalog::PURPOSE
+    ASPECT_RATIO = EmailCatalog::ASPECT_RATIO
+    MAX_WIDTH = EmailCatalog::MAX_WIDTH
 
     module_function
 
-    # --- Registry ----------------------------------------------------------
-
-    # Register (or update) an email workflow. Returns the key.
-    def register(key, label: nil, description: nil, default_asset: nil)
-      key = key.to_s
-      existing = registry[key]
-      registry[key] = Entry.new(
-        key: key,
-        label: label || existing&.label || key.humanize,
-        description: description || existing&.description,
-        default_asset: default_asset.nil? ? existing&.default_asset : default_asset.presence
-      )
-      key
-    end
-
-    # Every registered email, in display order: the standard two first, then the
-    # host's own in declaration order.
-    def entries
-      registry.values
-    end
-
-    def entry(key)
-      registry[key.to_s]
-    end
-
-    def keys
-      registry.keys
-    end
-
-    def known?(key)
-      registry.key?(key.to_s)
-    end
-    def registered?(key) = known?(key)
-
-    def label(key)
-      entry(key)&.label || key.to_s.humanize
-    end
-
-    # Legacy shape — key => label. Kept because it is the API the pre-registry
-    # admin page and any host that read VARIANTS were written against.
-    def variants
-      registry.transform_values(&:label)
-    end
-
-    # Drops host registrations back to the standard two. For tests and for
-    # to_prepare re-registration.
-    def reset!
-      @registry = nil
-      registry
-      nil
-    end
-
-    def registry
-      @registry ||= STANDARD.each_with_object({}) do |attrs, out|
-        out[attrs[:key]] = Entry.new(**attrs)
-      end
-    end
-
-    # --- Resolution --------------------------------------------------------
-
-    # Where the live banner for this email comes from:
-    #   :app     — this app uploaded its own (ImageCache row in its bucket)
-    #   :default — the inherited engine default (gem asset)
-    #   :none    — no image at all; the email sends bannerless
-    def source(key)
-      return :app if record(key)
-      return :default if default_asset_path(key)
-
-      :none
-    end
-
-    def app_owned?(key) = source(key) == :app
-
-    # THIS APP'S OWN image only — nil when nothing has been uploaded here.
-    #
-    # This is the PRE-REGISTRY contract, kept EXACTLY: `url` has always meant
-    # "the admin-managed override, or nil", and callers were written to fall back
-    # themselves. turf-monster's mailer is the live example:
-    #
-    #   @banner_url = Studio::EmailImage.url(:magic_link) || email_banner_url("magic-link-banner.jpg")
-    #
-    # Making `url` resolve to the engine default would make that `||` dead code
-    # and silently replace turf-monster's own branded 1200x600 banner with the
-    # engine's PLACEHOLDER in real sign-in email. A method whose signature is
-    # unchanged but whose return value flips from nil to a value is not additive.
-    # So the new two-layer resolution lives in resolved_url, and every existing
-    # caller keeps the behavior it was written against until its app adopts.
-    def url(key)
-      record(key)&.url
-    end
-
-    # What ACTUALLY SHIPS on this email — the two-layer resolution. Absolute, so
-    # it resolves from an inbox. App-owned override first, then the inherited
-    # engine default, then nil (the mailer renders bannerless).
-    #
-    # This is what a mailer should call once its app has adopted the registry.
-    # The engine's own UserMailer already does, which is what gives an app with
-    # an empty bucket branded email on day one.
-    def resolved_url(key)
-      url(key) || default_url(key)
-    end
-
-    # What the ADMIN PAGE previews. Same two layers as resolved_url, but a
-    # default stays a root-relative asset path so it renders correctly on
-    # whatever host and port this app is being viewed on (an absolute mailer
-    # asset_host is set for the inbox, not for a browser on localhost:3042).
-    def preview_url(key)
-      url(key) || default_asset_path(key)
-    end
-
-    # The ImageCache row holding this app's override, or nil (nothing uploaded /
-    # table not installed yet). Nil-safe so the mailer renders before any upload.
-    def record(key)
-      return nil unless table_ready?
-
-      ::ImageCache.find_by(owner: nil, purpose: PURPOSE, variant: key.to_s)
-    end
-
-    # Root-relative path to the inherited default asset, or nil when the email
-    # has no default registered or the host's pipeline cannot resolve it.
-    def default_asset_path(key)
-      asset = entry(key)&.default_asset
-      return nil if asset.nil? || asset.empty?
-
-      path = ActionController::Base.helpers.asset_path(asset)
-      path.presence
-    rescue StandardError
-      nil
-    end
-
-    # Absolute URL to the inherited default asset — what a mailer needs. Uses
-    # action_mailer.asset_host (set per env), falling back to the mailer's
-    # default_url_options host. Returns the bare path if neither is configured,
-    # which still renders in the local inbox preview.
-    def default_url(key)
-      path = default_asset_path(key)
-      return nil if path.nil?
-      return path if path.start_with?("http")
-
-      host = mailer_asset_host
-      host ? "#{host}#{path}" : path
-    end
-
-    # --- Upload ------------------------------------------------------------
-
-    # Whether THIS app can accept an upload. False when the host never set
-    # Studio.s3_bucket_prefix — /admin/emails then shows inherited defaults
-    # read-only rather than 500ing on the first upload.
-    def uploads_available?
-      Studio::S3.configured? && table_ready?
-    end
-
-    # Upload bytes to this app's bucket + upsert its ImageCache row (replacing
-    # any prior object). Returns the ::ImageCache. Raises on failure after
-    # cleaning up the new object.
-    def store(key, io:, content_type: nil)
-      s3_key = "email_banners/#{key}-#{SecureRandom.hex(4)}#{ext_for(content_type)}"
-      Studio::S3.upload(key: s3_key, body: io.read, content_type: content_type,
-                        cache_control: "public, max-age=300")
-      record = ::ImageCache.find_or_initialize_by(owner: nil, purpose: PURPOSE, variant: key.to_s)
-      previous = record.s3_key
-      record.update!(s3_key: s3_key)
-      delete_object(previous) if previous.present? && previous != s3_key
-      record
-    rescue StandardError
-      delete_object(s3_key)
-      raise
-    end
-
-    # Drop this app's override and fall back to the inherited default. Returns
-    # true when a row was removed.
-    def revert(key)
-      row = record(key)
-      return false if row.nil?
-
-      previous = row.s3_key
-      row.destroy!
-      delete_object(previous) if previous.present?
-      true
-    end
-
-    # --- Internals ---------------------------------------------------------
-
-    # Reference ImageCache directly so Zeitwerk autoloads it — defined?() does NOT
-    # trigger autoload, so it would read "undefined" for a not-yet-loaded const.
-    def table_ready?
-      ::ImageCache.table_exists?
-    rescue NameError, ActiveRecord::ActiveRecordError
-      false
-    end
-
-    # The origin an email's banner URL hangs off. action_mailer.asset_host when
-    # the host sets one (turf-monster does, per env); otherwise built from the
-    # mailer's default_url_options.
-    #
-    # That fallback has to reconstruct a real origin, not just the hostname.
-    # default_url_options is routinely {host: "localhost", port: 3001} — taking
-    # :host alone and prefixing "https://" yields https://localhost, which is the
-    # wrong scheme AND the wrong port, and the banner comes back
-    # ERR_CONNECTION_REFUSED. Caught by opening the preview page on a worktree
-    # stack; every dev/QA preview took that path.
-    def mailer_asset_host
-      configured = Rails.application.config.action_mailer.asset_host.presence
-      return configured if configured
-
-      options = ActionMailer::Base.default_url_options || {}
-      host = options[:host].presence
-      return nil if host.nil?
-      return host if host.start_with?("http")
-
-      "#{mailer_protocol(options, host)}://#{host}#{mailer_port_suffix(options)}"
-    rescue StandardError
-      nil
-    end
-
-    # Honor an explicit :protocol. Otherwise https — EXCEPT on loopback, which is
-    # a dev stack with no TLS. Defaulting the other way would downgrade every
-    # production app that sets only {host: "mcritchie.studio"}.
-    def mailer_protocol(options, host)
-      explicit = options[:protocol].presence
-      return explicit.to_s.sub(%r{://\z}, "") if explicit
-
-      LOOPBACK_HOSTS.include?(host.downcase) ? "http" : "https"
-    end
-
-    # Ports are part of the origin, and omitting one sends the reader to :443.
-    # The scheme defaults are left off so a normal URL stays normal.
-    def mailer_port_suffix(options)
-      port = options[:port]
-      return "" if port.blank? || [80, 443].include?(port.to_i)
-
-      ":#{port}"
-    end
-
-    LOOPBACK_HOSTS = %w[localhost 127.0.0.1 0.0.0.0 ::1].freeze
-
-    def ext_for(content_type)
-      case content_type.to_s
-      when %r{png}    then ".png"
-      when %r{jpe?g}  then ".jpg"
-      when %r{webp}   then ".webp"
-      else ".png"
-      end
-    end
-
-    def delete_object(key)
-      Studio::S3.delete(key: key)
-    rescue StandardError
-      nil
-    end
+    # Registry
+    def register(...)   = EmailCatalog.register(...)
+    def entries         = EmailCatalog.entries
+    def entry(key)      = EmailCatalog.entry(key)
+    def keys            = EmailCatalog.keys
+    def known?(key)     = EmailCatalog.known?(key)
+    def registered?(key) = EmailCatalog.registered?(key)
+    def label(key)      = EmailCatalog.label(key)
+    def variants        = EmailCatalog.variants
+    def reset!          = EmailCatalog.reset!
+
+    # Image resolution. `url` is the pre-registry contract — this app's own
+    # image or nil — and must stay that way; see the note on EmailCatalog#url.
+    def url(key)          = EmailCatalog.url(key)
+    def resolved_url(key) = EmailCatalog.resolved_url(key)
+    def preview_url(key)  = EmailCatalog.preview_url(key)
+    def source(key)       = EmailCatalog.source(key)
+    def app_owned?(key)   = EmailCatalog.app_owned?(key)
+    def record(key)       = EmailCatalog.record(key)
+    def default_url(key)  = EmailCatalog.default_url(key)
+    def default_asset_path(key) = EmailCatalog.default_asset_path(key)
+
+    # Writes
+    def store(key, io:, content_type: nil) = EmailCatalog.store(key, io: io, content_type: content_type)
+    def revert(key)        = EmailCatalog.revert(key)
+    def uploads_available? = EmailCatalog.uploads_available?
+    def table_ready?       = EmailCatalog.table_ready?
+
+    # Origin resolution. Delegated because 0.34's suite asserted these directly.
+    def mailer_asset_host = EmailCatalog.mailer_asset_host
+    def mailer_protocol(options, host) = EmailCatalog.mailer_protocol(options, host)
+    def mailer_port_suffix(options)    = EmailCatalog.mailer_port_suffix(options)
   end
 end

data/app/views/layouts/_navbar.html.erb

@@ -38,13 +38,15 @@
 %>
 
 <header x-data="{ scrolled: false }" <%= '@scroll.window="scrolled = scrolled ? (window.scrollY > 5) : (window.scrollY > 60)"'.html_safe unless is_preview %>
-        <%# top offsets by whatever studio/banners/_stack rendered above us. The
-            stack publishes --studio-bars-h on :root; with no stack the fallback
-            0px makes this identical to the old `top-0`, so an app that has not
-            adopted the stack is unaffected. The navbar never learns WHICH bars
-            rendered — only how tall they are. %>
-        style="<%= "top:var(--studio-bars-h, 0px);" unless is_preview %>"
-        class="<%= is_preview ? 'bg-page' : "#{'vt-pinned-header ' if pin_header}sticky z-50 bg-page transition-shadow duration-300" %>"
+        <%# top-0, a STATIC value, and never a custom property. Any bars render as
+            this header's sibling in normal flow (studio/banners/_stack), so they
+            already occupy their own height above it and there is nothing to
+            offset by. An offset read from a runtime-published property is what
+            made this header jump: it painted at a server estimate, moved when the
+            measurement landed, moved again on a webfont swap, and drew twice
+            during a view transition composited at two different tops. Only CSS
+            can set this top now, so none of that is reachable. %>
+        class="<%= is_preview ? 'bg-page' : "#{'vt-pinned-header ' if pin_header}sticky top-0 z-50 bg-page transition-shadow duration-300" %>"
         :class="scrolled && 'shadow-lg border-b border-subtle is-scrolled'">
   <style>
     .user-nav-col { width: 14rem; }

data/app/views/layouts/branded_mailer.html.erb

@@ -1,6 +1,6 @@
 <%#
   Shared branded transactional email shell. A full-bleed banner (set @banner_url,
-  e.g. from Studio::EmailImage.url(:magic_link)) sits flush at the top and sets
+  e.g. from Studio::EmailCatalog.resolved_url(:magic_link)) sits flush at the top and sets
   the 600px width; each email view supplies the body via yield. Bannerless is
   fine — the card still renders. Lifted from turf-monster so every Studio app
   shares one branded look. An app can override by defining its own

data/app/views/studio/banners/_app_banner.html.erb

@@ -24,9 +24,12 @@
     }
   }
 
-  # INTRINSIC height — content decides, and studio/banners/_stack MEASURES the
-  # result. An earlier cut declared a fixed height so the stack could compute its
-  # total server-side; that was rejected deliberately, because it cannot express
+  # INTRINSIC height — content decides, and the LAYOUT absorbs the result: the
+  # stack sits in normal flow, so a bar simply occupies the height it needs and
+  # nothing has to measure it. (It once did measure, publishing --studio-bars-h;
+  # that jumped, and 0.39.0 removed it.) An earlier cut declared a fixed height
+  # so the stack could compute its total server-side; that was rejected
+  # deliberately — and the reason still holds — because it cannot express
   # a bar that needs to be taller, or two bars stacked, without every consuming
   # app being reworked. The apps should respond to what the bar needs, not the
   # other way round.

data/app/views/studio/banners/_stack.html.erb

@@ -12,22 +12,31 @@
   0, 1 or 2, and growing. Nesting each new bar inside the navbar coupled two
   unrelated components and meant every new bar edited the navbar. Here the bars
   do not know the navbar exists, and the navbar does not know which bars
-  rendered — only how tall they are, via --studio-bars-h.
+  rendered — it simply starts below whatever space they take.
 
-  HOW THE HEIGHT IS KNOWN. The stack MEASURES itself and publishes the result, so
-  a bar that needs to be taller — or a second bar, or a third — just works, and no
-  consuming app is reworked to allow it. The apps respond to what the bars need.
+  HOW THE SPACE IS RESERVED. By the LAYOUT, and by nothing else. The stack sits
+  in normal flow directly above the navbar, so the bars occupy their own height
+  the way any block does, and the navbar — sticky at top:0 — starts underneath
+  them with no offset to compute. A taller bar, or a second, or a third, simply
+  takes more room and pushes the navbar down. Nothing measures, nothing
+  publishes, nothing repaints.
 
-  A server-rendered estimate (count × --studio-bar-unit) paints first so the
-  common case has no flash, then a ResizeObserver replaces it with the truth on
-  the same frame. An earlier cut declared a fixed bar height to avoid the
-  observer; that was rejected because it could only ever express the standard
-  case, which is the case that needed no help.
+  This replaced a measured custom property (--studio-bars-h: a server-rendered
+  estimate of count times a fixed unit, overwritten by a ResizeObserver reading
+  the real height). It worked, and it JUMPED: the header painted at the estimate
+  and moved when the measurement landed, then moved again whenever a webfont
+  changed the bar's real height — and during a view transition the outgoing and
+  incoming headers composited at two different tops, so the navbar visibly drew
+  twice. A position that only CSS can set cannot do any of that.
 
-  The property is published on :root from an inline <style>, deliberately. A
-  custom property set on this element would be invisible to the navbar, because
-  custom properties inherit DOWN, not ACROSS to siblings — and putting it on
-  <body> would need every host to change its layout.
+  THE TRADE, recorded so it is a decision and not a regression: the bars scroll
+  away with the page instead of pinning. Only the navbar stays. Two pinned
+  siblings of unknown height cannot stack in CSS alone — one has to measure the
+  other — so pinning the bars is what cost the offset variable. The navbar keeps
+  its pin; the bars are ambient labels, seen on every page load because a Turbo
+  visit lands at the top. An overlay that must clear the chrome should position
+  off --nav-bottom (published in layouts/studio/_head), which already reports the
+  header's live bottom edge and accounts for chrome above it.
 
   Locals (all optional):
     preview      — true inside a navbar-preview render; renders nothing, so a
@@ -61,42 +70,17 @@
     end
   end
 
-  # count { } and not count(true): show_impersonation is a truthy USER, not the
-  # literal true, and count(true) compares with ==. That published a one-bar
-  # height for a two-bar stack — the navbar would have sat under a bar.
-  bar_count = [show_environment, show_impersonation].count { |bar| bar }
+  # No count is kept. The old code counted bars to compute an offset, and had to
+  # use count { } rather than count(true) because show_impersonation is a truthy
+  # USER object, not the literal true — a mistake that once published a one-bar
+  # height for a two-bar stack. Normal flow needs no count at all: whatever
+  # rendered takes the room it needs.
+  any_bar = show_environment || show_impersonation
 %>
-<% if bar_count.positive? %>
-  <%# First-paint estimate only — the observer below replaces it with the measured
-      height. Expressed against a token so an app that retunes the unit still gets
-      a sensible pre-measurement value. %>
-  <%= tag.style safe_join([":root{--studio-bars-h:calc(#{bar_count} * var(--studio-bar-unit, 47px))}"]) %>
-  <div class="studio-bar-stack sticky top-0 z-[60] w-full" data-studio-bar-stack><%= bars %></div>
-  <script>
-    // Publishes the stack's REAL height, so the navbar offsets by what the bars
-    // actually need. Idempotent and re-bound on Turbo navigation — a stale
-    // observer pointed at a detached node silently stops updating, and the
-    // navbar would then sit at yesterday's offset.
-    (function () {
-      var apply = function () {
-        var el = document.querySelector("[data-studio-bar-stack]");
-        if (!el) {
-          document.documentElement.style.removeProperty("--studio-bars-h");
-          return;
-        }
-        if (window.__studioBarObserver) window.__studioBarObserver.disconnect();
-        var publish = function () {
-          var h = Math.round(el.getBoundingClientRect().height);
-          if (h > 0) document.documentElement.style.setProperty("--studio-bars-h", h + "px");
-        };
-        publish();
-        if (window.ResizeObserver) {
-          window.__studioBarObserver = new ResizeObserver(publish);
-          window.__studioBarObserver.observe(el);
-        }
-      };
-      apply();
-      document.addEventListener("turbo:load", apply);
-    })();
-  </script>
+<% if any_bar %>
+  <%# Normal flow, deliberately. No sticky, no z-index, no measured offset: the
+      navbar is the only pinned chrome, so the bars simply take their own height
+      above it. Not sticky also keeps the paint order right — the pinned navbar
+      is positioned, so it draws over these bars as they scroll up behind it. %>
+  <div class="studio-bar-stack w-full" data-studio-bar-stack><%= bars %></div>
 <% end %>

data/app/views/studio/email_images/index.html.erb

@@ -37,8 +37,8 @@
           override, so it announced "No image yet" for an email that was visibly
           sending a banner from a committed repo asset. Even on its way out it
           should tell the truth about what ships. %>
-      <% current_url = Studio::EmailImage.preview_url(variant) %>
-      <% inherited = current_url.present? && Studio::EmailImage.source(variant) == :default %>
+      <% current_url = Studio::EmailCatalog.preview_url(variant) %>
+      <% inherited = current_url.present? && Studio::EmailCatalog.source(variant) == :default %>
       <section class="rounded-xl border border-subtle p-5">
         <h2 class="font-semibold mb-3"><%= label %></h2>
 

data/app/views/studio/emails/_row.html.erb

@@ -5,8 +5,8 @@
     the same unit turf-monster's og:image uploader uses, on the page-scoped
     `emailModals` store. %>
 <%
-  source     = Studio::EmailImage.source(entry.key)
-  banner_url = Studio::EmailImage.preview_url(entry.key)
+  source     = Studio::EmailCatalog.source(entry.key)
+  banner_url = Studio::EmailCatalog.preview_url(entry.key)
   form_id    = "email-banner-form-#{entry.key.dasherize}"
 
   # `badge` is a shape-only utility in engine.css — the state color comes from
@@ -59,7 +59,12 @@
   </td>
 
   <td class="px-4 py-4">
-    <p class="font-semibold text-heading"><%= entry.label %></p>
+    <%# The name is the link to the email's own page — banner + live preview. %>
+    <%= link_to entry.label, admin_email_path(entry.key),
+          class: "font-semibold text-heading hover:text-primary underline-offset-2 hover:underline" %>
+    <% if entry.marketing? %>
+      <span class="badge bg-primary/10 text-primary border-primary/30 ml-1.5 whitespace-nowrap">Marketing</span>
+    <% end %>
     <% if entry.description.present? %>
       <p class="text-sm text-body mt-0.5 max-w-md"><%= entry.description %></p>
     <% end %>

data/app/views/studio/emails/index.html.erb

@@ -20,9 +20,9 @@
      partial in this non-isolated engine. %>
 <% content_for(:title) { "Emails" } %>
 <%
-  aspect     = Studio::EmailImage::ASPECT_RATIO
-  max_width  = Studio::EmailImage::MAX_WIDTH
-  app_owned  = @entries.count { |entry| Studio::EmailImage.source(entry.key) == :app }
+  aspect     = Studio::EmailCatalog::ASPECT_RATIO
+  max_width  = Studio::EmailCatalog::MAX_WIDTH
+  app_owned  = @entries.count { |entry| Studio::EmailCatalog.source(entry.key) == :app }
 %>
 <div class="max-w-5xl mx-auto px-4 pb-16">
   <header class="space-y-2 pt-8 pb-6">
@@ -88,7 +88,7 @@
     Banners render full-bleed at 600px wide inside the email card. The crop is
     fixed at <%= aspect.to_i %>:1 and saved at up to <%= max_width %>px, which is
     retina-sharp in an inbox without tripping a clipping limit.
-    <% if @entries.any? { |entry| Studio::EmailImage.source(entry.key) == :none } %>
+    <% if @entries.any? { |entry| Studio::EmailCatalog.source(entry.key) == :none } %>
       An email with no image sends bannerless — the card still renders.
     <% end %>
   </p>