studio-engine 0.82.0 → 0.82.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: baeae6743d5d1c8b5f2157367e1ca7df20e40318cfbeed9961360df5cd3a86b8
-  data.tar.gz: 965e67b42b3e04a07b4607dee0994b5b69c8f76dccb648ae4947e26c5d43c5e1
+  metadata.gz: ad8be51b6366f71e083ae5bb7ce69e83e08330b826f6acb6027692e0857f9b9a
+  data.tar.gz: 216b21e17a79e2f635bfbdbb3996607cfa767ca1e06cac11e63b337c9864771a
 SHA512:
-  metadata.gz: 881ca49a5a383eceae0cebc3a8fd4ecfe1ddafdefe4591e4afed541c205b74346d2b590c54dc1635d7c3c2e96b61714a9304de2ce9886016a1c765a440b2eda9
-  data.tar.gz: 1df9079552520f39f9659ce644044342253eed53853fe1145fe0e0ed35c5dd5517d21312557de8ac55494c91acb68912d9b8fa7981275ed3b309e271fb662868
+  metadata.gz: 06e416fbb35ec33fdaa8c0cceb76d994196dcb6898992cc31d1135f67f3e0804dab3c0e7eb4230bfe162a78adc348423d17e9cc7d484556b04eac0b46f18a7c7
+  data.tar.gz: 63334a9f39dde930606ebf7b23943287ff4d94bce68afcd4718c30cfc8838c1b52cef6f2f791474ec744db3ebfb66a6ef14cc5eebd1aa4894adbf651385666b4

data/CHANGELOG.md

@@ -4,6 +4,43 @@ The format is [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). This pro
 
 ## Unreleased
 
+## 0.82.1 — 2026-09-30
+
+### Fixed
+
+- **Link previews now reach iMessage from a Rails 8 app.** Rails 8's
+  `allow_browser versions: :modern` answered iMessage's fetcher, which sends a
+  Safari 9.0.1 User-Agent, with a `406`, so no preview was drawn. This was live on
+  mcritchie.studio and cyvasse.xyz. `include Studio::LinkPreviewBots` now exempts a
+  preview fetcher's GET or HEAD from every `allow_browser` guard on the controller,
+  with no app code. It overrides the private method Rails' guard calls, so it
+  covers a guard declared anywhere in the controller chain. A POST, an old browser
+  that is not a fetcher, and every person are still checked. An app that already
+  wrote `allow_browser ..., unless: :link_preview_bot_request?` (the hub, cyvasse)
+  keeps working and can drop the `unless:`.
+- **A failed slim render is logged to `ErrorLog`.** `Studio::LinkPreviewBots` now
+  captures it with `ErrorLog.capture!` instead of a log line, and still serves the
+  fetcher the full page.
+- **`rails g studio:site_identity` indents the include it writes** into
+  `ApplicationController`. It landed at column 0 in cyvasse.
+
+### Added
+
+- **`og:image:width`, `og:image:height` and `og:image:alt`.** The size tags appear
+  when the image's size is known without a fetch: an analyzed Active Storage blob
+  (the operator's image or a page's attachment) or the static fallback file, whose
+  PNG, JPEG, GIF or WebP header is read. The alt is the page's new
+  `link_preview image_alt:`, else the card's title; `twitter:image:alt` matches.
+  The site identity cache key moves to `v2`, so the sizes appear without waiting
+  out the old entry.
+- **`config.link_preview_base_url`** pins the canonical base for previews. When
+  set, `og:url` is that base plus the path with no query string, and relative
+  images are made absolute on it, so a `herokuapp.com` host or a `?utm_` link does
+  not split one page's share count. The default, `nil`, keeps the request's URL.
+- [`docs/LINK_PREVIEW.md`](docs/LINK_PREVIEW.md) gains *The allow_browser 406
+  trap*, with a curl check that uses the iMessage User-Agent, and notes Applebot's
+  slim page as a known trade-off.
+
 ## 0.82.0 — 2026-09-30
 
 ### Added

data/app/controllers/concerns/studio/link_preview_bots.rb

@@ -27,6 +27,14 @@ module Studio
   #
   # People, in-app browsers and unknown agents are never matched and always get
   # the full page. The allow-list is Studio::LinkPreview::BOT_TOKENS.
+  #
+  # ALLOW_BROWSER: Rails 8's `allow_browser versions: :modern` (in every new
+  # app's ApplicationController) answers Apple's LinkPresentation — which sends a
+  # Safari 9.0.1 User-Agent — with a 406, so no iMessage preview. Including this
+  # concern exempts preview fetchers from every allow_browser guard on the
+  # controller, GET and HEAD only, with no app code. An app that already wrote
+  # `allow_browser ..., unless: :link_preview_bot_request?` keeps working: its
+  # guard never runs for a fetcher, so this override is never reached.
   module LinkPreviewBots
     extend ActiveSupport::Concern
 
@@ -47,6 +55,24 @@ module Studio
 
     private
 
+    # Rails' allow_browser macro installs
+    # `before_action -> { allow_browser(versions:, block:) }`, which dispatches to
+    # the PRIVATE instance method ActionController::AllowBrowser#allow_browser (the
+    # same in Rails 7.2.3 and 8.1.4). This concern is included below
+    # ActionController::Base, so it sits above that module in the ancestor chain and
+    # this method answers first: a preview fetcher's GET/HEAD skips the browser
+    # check, everything else goes to Rails. Overriding the method rather than
+    # skipping the callback covers every allow_browser declaration (this
+    # controller, a parent or a subclass, before or after the include), and a
+    # lambda callback cannot be named to skip_before_action anyway. The integration
+    # suite pins the method, so a Rails rename fails loudly
+    # (test/integration/link_preview_test.rb).
+    def allow_browser(*args, **kwargs, &block)
+      return if link_preview_bot_request?
+
+      super
+    end
+
     def serve_link_preview_slim_document
       return unless link_preview_bot_request?
       return unless response.status == 200
@@ -55,13 +81,30 @@ module Studio
       body = response.body
       return unless body.is_a?(String) && !body.empty?
 
-      response.body = Studio::LinkPreview.slim_document(body, url: request.original_url)
+      response.body = Studio::LinkPreview.slim_document(body, url: studio_link_preview_page_url)
       response.headers[SLIM_HEADER] = "slim"
       # A shared cache must never hand the slim page to a person.
       response.headers["Vary"] = [response.headers["Vary"], "User-Agent"].compact.join(", ")
     rescue StandardError => e
       # The full page is still a valid (if large) answer; never 500 a fetcher.
-      Rails.logger&.warn("[studio.link_preview] slim render skipped: #{e.class}: #{e.message}")
+      # The failure goes to ErrorLog (and Sentry, when the host loads it) so it
+      # is triaged rather than lost in a log line; never re-raised, because the
+      # response is already rendered and the fetcher must still get the page.
+      studio_link_preview_capture(e)
+    end
+
+    def studio_link_preview_capture(error)
+      ErrorLog.capture!(error)
+    rescue StandardError, NameError => capture_error
+      Rails.logger&.warn("[studio.link_preview] slim render skipped: #{error.class}: #{error.message} " \
+                         "(ErrorLog unavailable: #{capture_error.class})")
+    end
+
+    # The page's canonical URL for the slim card's link: Studio.link_preview_base_url
+    # plus the path when the app pins one, else the URL as requested.
+    def studio_link_preview_page_url
+      Studio::LinkPreview.page_url(base_url: Studio.link_preview_base_url,
+                                   request_url: request.original_url, path: request.path)
     end
   end
 end

data/app/controllers/studio/site_identities_controller.rb

@@ -27,7 +27,7 @@ module Studio
       @uploads_available = @installed && @setting.respond_to?(:image)
       @default_image_url = default_image_url
       @static_image_url = static_image_url
-      @domain = request.host
+      @domain = preview_domain
     end
 
     def update
@@ -95,13 +95,25 @@ module Studio
     # The uploaded image as the card shows it: the same URL the head emits.
     def default_image_url
       stored = Studio::SiteIdentity.stored
-      Studio::LinkPreview.absolute_url(stored[:image_url] || stored[:image_path], base_url: request.base_url)
+      Studio::LinkPreview.absolute_url(stored[:image_url] || stored[:image_path], base_url: preview_base_url)
     rescue StandardError
       nil
     end
 
+    # The same base the head's tags are built on (Studio.link_preview_base_url,
+    # else this request's), so the card shows the domain and URL an unfurl does.
+    def preview_base_url
+      Studio::LinkPreview.base_url(pinned: Studio.link_preview_base_url, request_base_url: request.base_url)
+    end
+
+    def preview_domain
+      URI.parse(preview_base_url.to_s).host || request.host
+    rescue URI::InvalidURIError
+      request.host
+    end
+
     def static_image_url
-      Studio::LinkPreview.absolute_url(Studio::SiteIdentity.static_image, base_url: request.base_url)
+      Studio::LinkPreview.absolute_url(Studio::SiteIdentity.static_image, base_url: preview_base_url)
     end
   end
 end

data/app/helpers/studio/link_preview_helper.rb

@@ -10,7 +10,7 @@ module Studio
   # reason Studio::GeoHelper gives: every helper module is included into every
   # view, so an unprefixed name would collide with a host's own helper.
   module LinkPreviewHelper
-    OVERRIDE_KEYS = %i[image title description].freeze
+    OVERRIDE_KEYS = %i[image title description image_alt].freeze
 
     # THE PAGE OVERRIDE. Call it from any view (the layout renders later, so it
     # sees the call):
@@ -22,6 +22,8 @@ module Studio
     # attachment/blob (a user's avatar). An image that is nil, blank, or an
     # attachment with nothing attached falls back to the operator's default, so
     # a page can pass `image: user.avatar` without asking whether there is one.
+    # `image_alt:` is the image's text alternative (og:image:alt); without it the
+    # card's title stands in, which is what the picture illustrates.
     # Only the keys passed are set; a second call overrides just its own keys.
     # Returns nil, so `<%= link_preview ... %>` prints nothing either.
     def link_preview(**overrides)
@@ -33,8 +35,14 @@ module Studio
     end
 
     # The resolved preview for this page:
-    # { title:, description:, image:, image_source:, site_name:, url: }.
-    # `image` is absolute (or nil). Never raises: a preview must not 500 a page.
+    # { title:, description:, image:, image_source:, image_width:, image_height:,
+    #   image_alt:, site_name:, url: }.
+    # `image` is absolute (or nil). `image_width`/`image_height` are the
+    # winning image's pixel size when it is KNOWN — an attachment whose blob has
+    # been analyzed, or the static fallback file — and nil otherwise; a URL handed
+    # in as a string is never fetched to measure it. `url` is the page's og:url
+    # (Studio.link_preview_base_url plus the path when the app pins one).
+    # Never raises: a preview must not 500 a page.
     #
     # Rungs, most specific first: the page's `link_preview`, then the page's
     # own content_for(:title) / content_for(:meta_description) /
@@ -43,21 +51,27 @@ module Studio
     def studio_link_preview
       overrides = @studio_link_preview_overrides || {}
       stored = studio_site_identity_stored
+      override_image = studio_link_preview_image_location(overrides[:image])
 
       preview = Studio::LinkPreview.resolve(
         site_name: Studio.app_name,
         titles: [overrides[:title], studio_link_preview_content(:title), stored[:title], Studio.site_title],
         descriptions: [overrides[:description], studio_link_preview_content(:meta_description),
                        stored[:description], Studio.site_description],
-        page_images: [studio_link_preview_image_location(overrides[:image]), studio_link_preview_content(:og_image)],
+        page_images: [override_image, studio_link_preview_content(:og_image)],
         default_image: stored[:image_url] || stored[:image_path],
         static_image: Studio::SiteIdentity.static_image
       )
 
+      width, height = studio_link_preview_image_size(preview[:image_source], overrides[:image], override_image, stored)
+
       preview.merge(
         image: Studio::LinkPreview.absolute_url(preview[:image], base_url: studio_request_base_url) || preview[:image],
+        image_width: width,
+        image_height: height,
+        image_alt: (overrides[:image_alt].to_s.strip.presence || preview[:title] if preview[:image]),
         site_name: Studio.app_name.to_s,
-        url: (request.original_url if respond_to?(:request) && request)
+        url: studio_link_preview_page_url
       )
     end
 
@@ -106,8 +120,42 @@ module Studio
       value && CGI.unescapeHTML(value.to_str)
     end
 
+    # The app's pinned canonical base (Studio.link_preview_base_url), else the
+    # request's. Every preview URL is built on it.
     def studio_request_base_url
-      respond_to?(:request) && request ? request.base_url : nil
+      Studio::LinkPreview.base_url(pinned: Studio.link_preview_base_url,
+                                   request_base_url: (request.base_url if studio_link_preview_request?))
+    end
+
+    def studio_link_preview_page_url
+      return nil unless studio_link_preview_request?
+
+      Studio::LinkPreview.page_url(base_url: Studio.link_preview_base_url,
+                                   request_url: request.original_url, path: request.path)
+    end
+
+    def studio_link_preview_request?
+      respond_to?(:request) && request ? true : false
+    end
+
+    # [width, height] of the image that won, when it is known without a fetch.
+    # The override rung counts only when the page handed in an ATTACHMENT (its
+    # blob's analyzed metadata); a URL string or a content_for(:og_image) is
+    # unmeasured, so its tags are left out rather than guessed.
+    def studio_link_preview_image_size(source, override, override_location, stored)
+      case source
+      when :page
+        return nil if override_location.nil? || override.is_a?(String) || override.is_a?(Symbol)
+
+        Studio::SiteIdentity.image_dimensions(override)
+      when :default
+        width, height = stored[:image_width], stored[:image_height]
+        width && height ? [width, height] : nil
+      when :static
+        Studio::SiteIdentity.static_image_dimensions
+      end
+    rescue StandardError
+      nil
     end
   end
 end

data/app/models/studio/site_identity.rb

@@ -33,7 +33,7 @@ module Studio
 
     # Read on EVERY page render (the head's tags), edited a few times a year. So
     # the stored values are cached, and busted on any write — see .stored.
-    CACHE_KEY_PREFIX = "studio/site_identity/v1"
+    CACHE_KEY_PREFIX = "studio/site_identity/v2" # v2: adds image_width/image_height
     CACHE_TTL = 1.hour
 
     TITLE_MAX = 200
@@ -194,12 +194,45 @@ module Studio
 
       def reset_static_image!
         @static_files = nil
+        @static_dimensions = nil
+      end
+
+      # [width, height] of the static fallback, read from the file's header, or
+      # nil when there is no local file (an absolute URL is never fetched) or its
+      # format is not one Studio::LinkPreview.image_dimensions reads. Memoized
+      # per path like static_image.
+      def static_image_dimensions
+        path = static_image
+        return nil if path.nil? || !path.start_with?("/") || path.start_with?("//")
+
+        @static_dimensions ||= Concurrent::Map.new
+        dims = @static_dimensions.compute_if_absent(path) do
+          Studio::LinkPreview.image_dimensions(Rails.public_path.join(path.delete_prefix("/"))) || false
+        end
+        dims || nil
+      end
+
+      # [width, height] from an attachment's or blob's ANALYZED metadata, or nil
+      # before Active Storage's analyze job has run (or for a non-image).
+      def image_dimensions(attachable)
+        return nil if attachable.nil?
+        return nil if attachable.respond_to?(:attached?) && !attachable.attached?
+
+        blob = attachable.respond_to?(:blob) ? attachable.blob : attachable
+        metadata = blob.respond_to?(:metadata) ? blob.metadata : nil
+        return nil unless metadata.is_a?(Hash)
+
+        width = metadata["width"] || metadata[:width]
+        height = metadata["height"] || metadata[:height]
+        width.is_a?(Integer) && height.is_a?(Integer) && width.positive? && height.positive? ? [width, height] : nil
+      rescue StandardError
+        nil
       end
 
       private
 
       def empty_stored
-        { title: nil, description: nil, image_url: nil, image_path: nil }
+        { title: nil, description: nil, image_url: nil, image_path: nil, image_width: nil, image_height: nil }
       end
 
       def compute_stored
@@ -207,11 +240,14 @@ module Studio
         return empty_stored if row.nil?
 
         location = row.respond_to?(:image) ? image_location(row.image) : nil
+        width, height = (image_dimensions(row.image) if location)
         {
           title: row.title.presence,
           description: row.description.presence,
           image_url: location&.dig(:url),
-          image_path: location&.dig(:path)
+          image_path: location&.dig(:path),
+          image_width: width,
+          image_height: height
         }
       end
     end

data/app/views/layouts/studio/_link_preview_tags.html.erb

@@ -3,7 +3,8 @@
     Studio::LinkPreviewHelper#studio_link_preview: the page override, else the
     operator default from /admin/link_preview, else the static fallback.
     Lifted from turf-monster's layouts/_link_preview_meta. og:image is absolute
-    and permanent; the tag is omitted rather than emitted empty. %>
+    and permanent; the tag is omitted rather than emitted empty. og:image:width
+    and og:image:height appear only when the image's size is known. %>
 <meta property="og:site_name" content="<%= preview[:site_name] %>">
 <meta property="og:type" content="website">
 <meta property="og:title" content="<%= preview[:title] %>">
@@ -15,6 +16,13 @@
 <% end %>
 <% if preview[:image] %>
 <meta property="og:image" content="<%= preview[:image] %>">
+<% if preview[:image_width] && preview[:image_height] %>
+<meta property="og:image:width" content="<%= preview[:image_width] %>">
+<meta property="og:image:height" content="<%= preview[:image_height] %>">
+<% end %>
+<% if preview[:image_alt] %>
+<meta property="og:image:alt" content="<%= preview[:image_alt] %>">
+<% end %>
 <% end %>
 <meta name="twitter:card" content="<%= preview[:image] ? "summary_large_image" : "summary" %>">
 <meta name="twitter:title" content="<%= preview[:title] %>">
@@ -23,4 +31,7 @@
 <% end %>
 <% if preview[:image] %>
 <meta name="twitter:image" content="<%= preview[:image] %>">
+<% if preview[:image_alt] %>
+<meta name="twitter:image:alt" content="<%= preview[:image_alt] %>">
+<% end %>
 <% end %>

data/lib/generators/studio/site_identity/site_identity_generator.rb

@@ -82,9 +82,13 @@ module Studio
         return say_status(:skip, "#{CONTROLLER} not found", :yellow) unless File.exist?(path)
         return say_status(:identical, "#{CONTROLLER} (Studio::LinkPreviewBots)", :blue) if File.read(path).include?("Studio::LinkPreviewBots")
 
-        inject_into_class CONTROLLER, "ApplicationController", <<~RUBY
+        # inject_into_class inserts the text as given, right after the class
+        # line, so the body's two-space indent is written here (a bare heredoc
+        # landed at column 0 in cyvasse).
+        inject_into_class CONTROLLER, "ApplicationController", <<~RUBY.gsub(/^(?=.)/, "  ")
           # Preview fetchers (iMessage, Slack, Discord, X...) get a slim page under
-          # Apple's 1 MiB limit. studio-engine docs/LINK_PREVIEW.md.
+          # Apple's 1 MiB limit, and are exempt from allow_browser. studio-engine
+          # docs/LINK_PREVIEW.md.
           include Studio::LinkPreviewBots
         RUBY
       end

data/lib/studio/link_preview.rb

@@ -135,6 +135,97 @@ module Studio
       value
     end
 
+    # The base URL every preview URL is built on: the app's PINNED canonical
+    # base (Studio.link_preview_base_url) when it set one, else the request's.
+    # Trailing slash dropped, so a path joins cleanly. nil when neither exists.
+    def base_url(pinned:, request_base_url:)
+      pinned_value = pinned.to_s.strip.chomp("/")
+      return pinned_value unless pinned_value.empty?
+
+      request_value = request_base_url.to_s.strip.chomp("/")
+      request_value.empty? ? nil : request_value
+    end
+
+    # The page's og:url. With a pinned base it is that base plus the PATH: no
+    # herokuapp host, no ?utm_ query, so every share of a page counts as one URL.
+    # Without one it is the URL as requested, as it always was.
+    def page_url(base_url:, request_url:, path:)
+      pinned_value = base_url.to_s.strip.chomp("/")
+      return request_url.to_s.empty? ? nil : request_url.to_s if pinned_value.empty?
+
+      "#{pinned_value}#{path.to_s.empty? ? "/" : path}"
+    end
+
+    # [width, height] of a PNG, GIF, JPEG or WebP file, read from its header
+    # only, or nil when the file is missing, unreadable or another format. Lets
+    # the static fallback (public/og.png) emit og:image:width/height, which
+    # WhatsApp and others use to lay the card out before the image arrives.
+    def image_dimensions(path)
+      File.open(path.to_s, "rb") { |file| dimensions_from(file.read(64 * 1024).to_s.b) }
+    rescue SystemCallError, IOError
+      nil
+    end
+
+    def dimensions_from(bytes)
+      dims =
+        if bytes.start_with?("\x89PNG\r\n\x1A\n".b) && bytes.bytesize >= 24
+          bytes[16, 8].unpack("NN")
+        elsif bytes.start_with?("GIF8") && bytes.bytesize >= 10
+          bytes[6, 4].unpack("vv")
+        elsif bytes.start_with?("\xFF\xD8".b)
+          jpeg_dimensions(bytes)
+        elsif bytes.start_with?("RIFF") && bytes[8, 4] == "WEBP"
+          webp_dimensions(bytes)
+        end
+      dims && dims.all? { |n| n.is_a?(Integer) && n.positive? } ? dims : nil
+    end
+
+    # Walk the JPEG segments to the first start-of-frame marker.
+    JPEG_SOF_MARKERS = [0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF].freeze
+
+    def jpeg_dimensions(bytes)
+      offset = 2
+      while offset + 9 <= bytes.bytesize
+        return nil unless bytes.getbyte(offset) == 0xFF
+
+        marker = bytes.getbyte(offset + 1)
+        if marker == 0xFF # fill byte
+          offset += 1
+          next
+        end
+        length = bytes[offset + 2, 2].unpack1("n")
+        if JPEG_SOF_MARKERS.include?(marker)
+          height, width = bytes[offset + 5, 4].unpack("nn")
+          return [width, height]
+        end
+        return nil if length.nil? || length < 2
+
+        offset += 2 + length
+      end
+      nil
+    end
+
+    def webp_dimensions(bytes)
+      case bytes[12, 4]
+      when "VP8 "
+        return nil if bytes.bytesize < 30
+
+        width, height = bytes[26, 4].unpack("vv")
+        [width & 0x3FFF, height & 0x3FFF]
+      when "VP8L"
+        return nil if bytes.bytesize < 25
+
+        bits = bytes[21, 4].unpack1("V")
+        [(bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1]
+      when "VP8X"
+        return nil if bytes.bytesize < 30
+
+        w = bytes[24, 3].unpack("CCC")
+        h = bytes[27, 3].unpack("CCC")
+        [(w[0] | (w[1] << 8) | (w[2] << 16)) + 1, (h[0] | (h[1] << 8) | (h[2] << 16)) + 1]
+      end
+    end
+
     # The whole response a preview fetcher gets: the page's own identity tags,
     # lifted out of its <head>, and a one-card body. Built FROM the rendered
     # page, so the slim document cannot drift from what a person's page says.

data/lib/studio/version.rb

@@ -1,3 +1,3 @@
 module Studio
-  VERSION = "0.82.0"
+  VERSION = "0.82.1"
 end

data/lib/studio.rb

@@ -516,6 +516,17 @@ module Studio
   # trusted as given.
   mattr_accessor :link_preview_fallback_image, default: "/og.png"
 
+  # The app's CANONICAL base URL for previews, e.g. "https://cyvasse.xyz". When
+  # set, og:url is this base plus the page's path (no query string), and every
+  # relative preview image is made absolute on it — so a share through a
+  # herokuapp.com host or a ?utm_ link does not split one page into many URLs in
+  # an unfurler's share counts. nil (the default) uses the request's base URL,
+  # and og:url is the URL as requested. Set it in production only, or a local
+  # page's card points at production:
+  #
+  #   config.link_preview_base_url = "https://cyvasse.xyz" if Rails.env.production?
+  mattr_accessor :link_preview_base_url, default: nil
+
   # THE SITE IDENTITY'S DRAFTED DEFAULTS — this app's title and description as
   # written in code, under whatever the operator saves at /admin/link_preview.
   # The standing convention is that an agent drafts these when it sets an app up

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: studio-engine
 version: !ruby/object:Gem::Version
-  version: 0.82.0
+  version: 0.82.1
 platform: ruby
 authors:
 - Alex McRitchie
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails