plutonium 0.68.0 → 0.69.0

data/lib/plutonium/interaction/async/run.rb

@@ -27,6 +27,15 @@ module Plutonium
         IN_PROGRESS_STATES = %w[pending running].freeze
         FAILURE_POLICIES = %i[halt continue transactional].freeze
 
+        # Tags the errors_log entries a pre_check rejection writes, which is what
+        # #outcome reads "rejected" from. A key in the existing JSON rather than a
+        # column: older entries simply lack it.
+        PRE_CHECK_STAGE = "pre_check"
+
+        # Raised by #reject called anywhere but inside pre_check, where nothing
+        # would collect the rejection.
+        class RejectOutsidePreCheckError < StandardError; end
+
         # Routes, paths and helpers are all derived from model_name, and the
         # default would spell the gem's own namespace out in every URL
         # (/admin/plutonium/interaction/runs) and every helper
@@ -65,6 +74,7 @@ module Plutonium
 
         scope :in_progress, -> { where(state: IN_PROGRESS_STATES) }
         scope :for_target, ->(klass) { where(target_type: klass.to_s) }
+        scope :finished_since, ->(time) { where.not(state: IN_PROGRESS_STATES).where(finished_at: time..) }
 
         # In progress with no recorded activity since +before+ — see
         # Async::ReapJob. +last_activity_at+ is nil until a job actually claims
@@ -130,9 +140,17 @@ module Plutonium
         #
         # @return [String]
         def outcome
+          return "rejected" if rejected?
+
           (state == "completed" && errors_log.any?) ? "completed_with_errors" : state
         end
 
+        # Failed because its pre_check refused the input, as opposed to failing
+        # while doing the work. Nothing was processed. state stays "failed", so
+        # every reader keyed on state (ReapJob, in_progress, the banner) is
+        # unaffected.
+        def rejected? = state == "failed" && errors_log.any? { |entry| entry["stage"] == PRE_CHECK_STAGE }
+
         # @return [Integer] recorded target failures, run-level entries included
         def error_count = errors_log.size
 
@@ -153,23 +171,42 @@ module Plutonium
 
         # Runs have no name or title, so Labeling would fall back to
         # "Async run #12" — true but silent about the only thing that
-        # distinguishes one row from the next.
-        #
-        # Demodulized: a host's run class is as likely to be
-        # Billing::ReissueInvoicesRun as a top-level one, and the namespace adds
-        # nothing to a label that already sits under the run's own breadcrumb.
-        #
-        # Except when demodulizing is what throws the name away. A run declared
-        # by Dispatchable#async is Blogging::ArchivePosts::Run, and every
-        # one of them would render "Run #12" — the failure mode this method
-        # exists to avoid, reintroduced for the shape most authors will write.
-        # For those, the enclosing segment IS the name, so it is folded back in.
+        # distinguishes one row from the next. The dispatching interaction's
+        # label is that thing: "Import Posts #12".
         #
         # @return [String]
         def to_label
-          parts = self.class.name.split("::")
-          name = (parts.last == "Run" && parts.size > 1) ? "#{parts[-2]}Run" : parts.last
-          I18n.t("plutonium.async.run.label", name: name.titleize, id: to_param)
+          I18n.t("plutonium.async.run.label", name: interaction_label, id: to_param)
+        end
+
+        # The interaction's label (its `presents label:`), or a name derived from
+        # the run class for a run with no interaction behind it.
+        #
+        # @return [String]
+        def interaction_label
+          interaction_class&.label || run_class_label
+        end
+
+        # The interaction this run belongs to. A run declared by
+        # Dispatchable#async is <Interaction>::Run, so it is the enclosing class.
+        # nil for a standalone run class, which may be shared by several
+        # interactions and so belongs to none of them.
+        #
+        # @return [Class, nil]
+        def interaction_class
+          parent = self.class.module_parent
+          parent if parent < Plutonium::Interaction::Base
+        end
+
+        # The index's progress cell: "1 / 4", or nil for opaque work. Two
+        # counter columns showed opaque work as "0" done of nothing, which reads
+        # as a run that did nothing rather than one with no count to report.
+        #
+        # @return [String, nil]
+        def progress
+          return nil if progress_total.nil?
+
+          I18n.t("plutonium.async.run.progress", done: progress_done, total: progress_total)
         end
 
         # nil means INDETERMINATE, not zero: opaque work has no denominator, and
@@ -222,6 +259,53 @@ module Plutonium
           )
         end
 
+        # Fails the run with its pre_check's rejections, in ONE write, for the
+        # reason record_target_failures! gives: a crash between two writes must
+        # not leave a failed run without its reasons, or reasons on a run still
+        # marked running. Entries carry the run-level nil target_id, so progress
+        # and handled_target_ids are untouched: nothing was processed.
+        #
+        # @param messages [Array<String>] the rejections that were stored
+        # @param overflow [Integer] how many more were rejected past max_rejections
+        def reject_run!(messages, overflow: 0)
+          entries = messages.map { |message| pre_check_entry(message) }
+          entries << pre_check_entry(I18n.t("plutonium.async.executor.rejections_truncated", count: overflow)) if overflow.positive?
+
+          now = Time.current
+          update!(errors_log: errors_log + entries, state: "failed", finished_at: now, last_activity_at: now)
+        end
+
+        # Runs the block with #reject live, and closes it again afterwards.
+        # Called by Async::Executor around pre_check.
+        #
+        # @return [Array(Array<String>, Integer)] the stored messages, and how
+        #   many more were rejected past max_rejections
+        def collect_rejections
+          @rejections = []
+          @rejection_count = 0
+          yield
+          [@rejections, @rejection_count - @rejections.size]
+        ensure
+          @rejections = @rejection_count = nil
+        end
+
+        # Records one problem with the run's input and returns, so a check can
+        # report every bad row in one pass. Only live inside pre_check: a
+        # rejection from perform would be collected by nothing.
+        #
+        # Counts past max_rejections but stores no more than that, so memory
+        # stays bounded and the "and N more" count is exact.
+        #
+        # @param message [String]
+        # @return [void]
+        def reject(message)
+          raise RejectOutsidePreCheckError, I18n.t("plutonium.async.run.reject_outside_pre_check", run_class: self.class) if @rejections.nil?
+
+          @rejection_count += 1
+          @rejections << message.to_s if @rejections.size < Plutonium.configuration.async_interactions.max_rejections
+          nil
+        end
+
         # Target ids not yet dispositioned — what a resumed run still has to
         # do. See {#record_target_failures!} and Async::Executor#advance!, which
         # are what populate handled_target_ids.
@@ -232,6 +316,16 @@ module Plutonium
           target_ids.reject { |id| handled.include?(id.to_s) }
         end
 
+        # Whether an earlier pass got as far as applying a target, which it can
+        # only have done after its pre_check passed. A handled id with no
+        # errors_log entry was applied; failures (unresolved or raised) all carry one.
+        #
+        # @return [Boolean]
+        def any_target_applied?
+          failed = errors_log.filter_map { |entry| entry["target_id"]&.to_s }.to_set
+          handled_target_ids.any? { |id| !failed.include?(id.to_s) }
+        end
+
         # The interaction's validated inputs, with the types dispatch put in.
         #
         # The column is JSON, so Dispatchable#dispatch_options writes it through
@@ -377,8 +471,28 @@ module Plutonium
             "#perform_on(record) for work over targets, or #perform for opaque work"
         end
 
+        # Checks the run's input before any work, and refuses it with #reject.
+        # Optional: the default checks nothing. Override it as
+        # +pre_check(records)+ in a run with +perform_on+ (it receives the
+        # resolved, authorized records), or +pre_check+ for opaque work.
+        # See Async::Executor#pre_check_passed?.
+        def pre_check(*) = nil
+
         private
 
+        def pre_check_entry(message) = {"target_id" => nil, "message" => message, "stage" => PRE_CHECK_STAGE}
+
+        # For a standalone run class, passed as `async Billing::ReissueInvoicesRun`,
+        # which has no interaction around it to take a label from. Demodulized,
+        # since the namespace adds nothing under the run's own breadcrumb. A
+        # <Something>::Run that is not inside an interaction keeps the enclosing
+        # segment, or every one of them would read "Run".
+        def run_class_label
+          parts = self.class.name.split("::")
+          name = (parts.last == "Run" && parts.size > 1) ? "#{parts[-2]}Run" : parts.last
+          name.titleize
+        end
+
         # Not swallowed: after_commit runs synchronously, so re-raising here
         # still surfaces to the dispatching request rather than leaving a
         # permanently invisible, un-enqueued ghost.

data/lib/plutonium/interaction/async/run_definition.rb

@@ -25,19 +25,20 @@ module Plutonium
         # neither a type to infer nor a badge to infer one from (`state` is a
         # plain string column with an inclusion validation, not a Rails enum).
         #
-        # `running` and `completed_with_errors` are coloured explicitly: neither
-        # is in the badge component's semantic table, and its fallback is a
+        # `running`, `completed_with_errors` and `rejected` are coloured explicitly:
+        # none is in the badge component's semantic table, and its fallback is a
         # stable-but-meaningless colour.
         field :outcome, as: :string
         display :outcome, as: :badge,
-          colors: {running: :info, completed_with_errors: :warning}
+          colors: {running: :info, completed_with_errors: :warning, rejected: :warning}
         # Declared for the table too: the index is where an operator scans for the
         # run that did not do what it was asked, and a bare
         # "completed_with_errors" string is the one place that reads worse than
         # the badge.
         column :outcome, as: :badge,
-          colors: {running: :info, completed_with_errors: :warning}
+          colors: {running: :info, completed_with_errors: :warning, rejected: :warning}
 
+        field :interaction_label, label: t("plutonium.async.run.interaction")
         field :target_label, label: t("plutonium.async.run.target_type")
 
         # The details tab, with the live panel above the fields.

data/lib/plutonium/interaction/async/run_policy.rb

@@ -63,22 +63,22 @@ module Plutonium
         # unreadably.
         def permitted_attributes_for_read
           %i[
-            type outcome progress_done progress_total
+            interaction_label outcome progress
             target_label initiator started_at finished_at created_at
           ]
         end
 
-        # The show page drops the progress COUNTERS, for the reason errors_log
+        # The show page drops the progress cell, for the reason errors_log
         # is absent above: the panel already renders them, as "5 of 5 targets
         # (100%)" over a bar. Two renderings of one number is the same report
         # twice — and they disagree, because only the panel is inside the polled
         # frame. A page that says "Completed" and "0 done" at once is worse than
         # either alone.
         #
-        # The INDEX keeps them. There is no progress bar in a table row, so the
-        # counters are the only progress it can show.
+        # The INDEX keeps it. There is no progress bar in a table row, so the
+        # cell is the only progress it can show.
         def permitted_attributes_for_show
-          permitted_attributes_for_read - %i[progress_done progress_total]
+          permitted_attributes_for_read - %i[progress]
         end
       end
     end

data/lib/plutonium/interaction/response/redirect.rb

@@ -24,10 +24,13 @@ module Plutonium
             # appending the options hash raises ArgumentError rather than
             # producing a formatted URL. A caller handing over a complete URL has
             # already decided what it points at.
+            #
+            # Also skipped for a turbo-stream request: it is answered below with a
+            # visit, and a visit wants the page, not a .turbo_stream URL.
             fully_formed_url = redirect_args.size == 1 && redirect_args.first.is_a?(String)
 
             url_options = redirect_args.last.is_a?(Hash) ? redirect_args.last : {}
-            if !fully_formed_url && !url_options.key?(:format) && request.format.symbol != :html
+            if !fully_formed_url && !url_options.key?(:format) && !request.format.symbol.in?(%i[html turbo_stream])
               url_options = url_options.merge(format: request.format.symbol)
               redirect_args = [*redirect_args[0...-1], url_options] if redirect_args.last.is_a?(Hash)
               redirect_args = [*redirect_args, url_options] unless redirect_args.last.is_a?(Hash)
@@ -36,14 +39,23 @@ module Plutonium
             url = fully_formed_url ? redirect_args.first : url_for(*redirect_args)
 
             respond_to do |format|
+              # Answered with a stream action wherever the form lives, the way
+              # every other Plutonium success path answers a turbo-stream post.
+              # A plain redirect_to here is followed by fetch and its page
+              # rendered into whatever frame submitted the form.
+              #
+              # turbo_stream_redirect is a client-side visit, so it skips the
+              # open-redirect check redirect_to applies. It is applied here the
+              # same way, with redirect_to's own default for allow_other_host:
+              # resolved up front from raise_on_open_redirects before Rails 8.1,
+              # left nil from 8.1 on, where the check resolves it and nil also
+              # drives action_on_open_redirect (:log / :notify).
               format.turbo_stream do
-                if helpers.current_turbo_frame == Plutonium::REMOTE_MODAL_FRAME
-                  render turbo_stream: [
-                    helpers.turbo_stream_redirect(url)
-                  ]
-                else
-                  redirect_to(url, **redirect_options)
+                allow_other_host = redirect_options.fetch(:allow_other_host) do
+                  _allow_other_host if ActionPack.gem_version < Gem::Version.new("8.1")
                 end
+                _enforce_open_redirect_protection(url, allow_other_host:)
+                render turbo_stream: helpers.turbo_stream_redirect(url)
               end
 
               format.any { redirect_to(url, **redirect_options) }

data/lib/plutonium/ui/breadcrumbs.rb

@@ -48,10 +48,24 @@ module Plutonium
       def breadcrumb_items
         @breadcrumb_items ||= [].tap do |items|
           collect_parent_breadcrumbs(items) if current_parent.present?
-          collect_resource_breadcrumbs(items) if resource_record?
+          if resource_record?
+            collect_resource_breadcrumbs(items)
+          elsif collection_page?
+            collect_resource_index_breadcrumb(items)
+          end
         end
       end
 
+      # A page that hangs off the resource list without being about one record:
+      # a resource action (import), a wizard launched from the index, or a
+      # custom collection route (calendar). It has no record to name, but the
+      # list it came from is still a level up. The index itself is excluded
+      # because its page title already says where you are, and a singular
+      # resource has no index to point back to.
+      def collection_page?
+        action_name != "index" && !singular_resource_context?
+      end
+
       # The segments eligible to be folded into the overflow menu. The last one
       # is never foldable — it is the deepest thing the trail knows about, which
       # is the record on new/edit pages but the resource index on show pages,
@@ -151,21 +165,25 @@ module Plutonium
       end
 
       def collect_plural_resource_breadcrumbs(items)
+        collect_resource_index_breadcrumb(items)
+
+        # Record itself (for non-singular routes only)
+        return unless resource_record!.persisted? && action_name != "show"
+
+        items << segment(display_name_of(resource_record!), resource_url_for(resource_record!))
+      end
+
+      def collect_resource_index_breadcrumb(items)
         # No `parent:` here on purpose: Resource::Controller#resource_url_args_for
         # already defaults it to `current_parent` (and supplies
-        # `current_nested_association` with it), so both links nest themselves
+        # `current_nested_association` with it), so the link nests itself
         # when the request arrived through a nesting. Passing it explicitly reads
-        # like it changes something; it doesn't. The parent segments above pass
+        # like it changes something; it doesn't. The parent segments pass
         # `parent: nil` precisely to opt OUT of that default.
         items << segment(
           nestable_resource_name_plural(resource_class),
           resource_url_for(resource_class)
         )
-
-        # Record itself (for non-singular routes only)
-        return unless resource_record!.persisted? && action_name != "show"
-
-        items << segment(display_name_of(resource_record!), resource_url_for(resource_record!))
       end
 
       # Stands in for whatever the controller folded away, the way GitHub

data/lib/plutonium/ui/interaction/async/run_progress.rb

@@ -43,6 +43,8 @@ module Plutonium
             "running" => "info",
             "completed" => "success",
             "completed_with_errors" => "warning",
+            # The input was refused, nothing broke: see Run#rejected?.
+            "rejected" => "warning",
             "failed" => "danger"
           }.freeze
 
@@ -83,7 +85,9 @@ module Plutonium
             div(class: "pu-card pu-run-progress", **poll_attributes) do
               div(class: "pu-card-body space-y-4") do
                 render_status
-                render_progress
+                # A rejected run never started: an empty progress line beside
+                # "Nothing was processed" would say the same thing twice.
+                run.rejected? ? render_rejected : render_progress
                 render_failures if run.errors_log.any?
               end
             end
@@ -123,15 +127,24 @@ module Plutonium
               # The count rides alongside the badge rather than only in the list
               # below: a partially-applied :continue run ends as "completed", and
               # the one thing a reader must not be able to miss is that it did not
-              # do everything it was asked to.
+              # do everything it was asked to. Muted, because the alert below
+              # carries the colour (danger or warning) for what the problems mean.
               if run.error_count.positive?
-                span(class: "text-xs font-medium text-[var(--pu-text-danger)]") do
+                span(class: "text-xs font-medium text-[var(--pu-text-muted)]") do
                   plain t("plutonium.async.progress.error_count", count: run.error_count)
                 end
               end
             end
           end
 
+          # In place of the progress line: "0 of 50 targets" reads as a run that
+          # died at its first target. A rejected run never started, and says so.
+          def render_rejected
+            div(class: "text-xs text-[var(--pu-text-muted)]") do
+              plain t("plutonium.async.progress.rejected")
+            end
+          end
+
           # NEVER rendered without {#render_status} above it. After a refused
           # partial batch (:halt / :transactional), progress_done counts targets
           # DISPOSITIONED, not applied — so a run that performed nothing at all can
@@ -201,19 +214,20 @@ module Plutonium
             ((Time.current - started) * 1000).to_i % SWEEP_DURATION_MS
           end
 
+          # The framework's inline alert, so the problems read like every other
+          # message Plutonium shows rather than as a panel of their own.
           def render_failures
-            div(class: "space-y-1") do
-              div(class: "text-[10px] font-semibold uppercase tracking-wider text-[var(--pu-text-muted)]") do
-                plain t("plutonium.async.progress.failures")
-              end
-              ul(class: "pu-run-progress-failures text-xs space-y-1") do
-                run.errors_log.each do |entry|
-                  li(class: "text-[var(--pu-text-danger)]") { plain failure_text(entry) }
-                end
+            div(class: "pu-alert pu-alert-#{failures_variant} pu-run-progress-failures", role: "alert") do
+              ul(class: "pu-alert-message") do
+                run.errors_log.each { |entry| li { plain failure_text(entry) } }
               end
             end
           end
 
+          # Danger only for a run that broke. Refused input (rejected) and partial
+          # application (completed_with_errors) are warnings, matching the badge.
+          def failures_variant = (run.outcome == "failed") ? "danger" : "warning"
+
           # A nil target_id is the RUN-LEVEL sentinel (see AsyncRun#record_target_failure!),
           # not a target whose id happens to be blank.
           def failure_text(entry)

data/lib/plutonium/ui/interaction/async/running_banner.rb

@@ -4,7 +4,9 @@ module Plutonium
   module UI
     module Interaction
       module Async
-        # Lists the runs currently working on THIS resource, above its collection.
+        # Lists the runs currently working on THIS resource, above its collection,
+        # followed by the viewer's own runs that finished within
+        # +recent_runs_window+ (see Page::Index#render_running_banner).
         #
         # == Why it exists
         #
@@ -16,8 +18,9 @@ module Plutonium
         #
         # +target_type+ is a real column rather than a key inside the +options+
         # JSON precisely so this predicate can be indexed — see the migration's own
-        # comment. An opaque run has no +target_type+ at all and therefore appears
-        # on no resource index: it belongs to no resource.
+        # comment. An opaque run dispatched from a resource still records that
+        # resource as its +target_type+, so it shows on that resource's index; one
+        # dispatched from nowhere has none and appears on no resource index.
         #
         # == Why it can render nothing
         #
@@ -51,13 +54,26 @@ module Plutonium
                 # own page renders the pair.
                 span(class: "font-medium text-[var(--pu-text)]") { plain run.to_label }
                 plain " "
-                span(class: "text-[var(--pu-text-muted)]") { plain(Plutonium::Translation.value_label(run.class, :state, run.state) || run.state.humanize) }
+                run.in_progress? ? render_state(run) : render_outcome(run)
               end
               a(href: resource_url_for(run), class: "pu-btn pu-btn-xs pu-btn-soft-primary shrink-0") do
-                plain t("plutonium.async.banner.view_progress")
+                plain t(run.in_progress? ? "plutonium.async.banner.view_progress" : "plutonium.async.banner.view_run")
               end
             end
           end
+
+          def render_state(run)
+            span(class: "text-[var(--pu-text-muted)]") { plain(Plutonium::Translation.value_label(run.class, :state, run.state) || run.state.humanize) }
+          end
+
+          # A finished run is listed for what it ended as, so outcome rather than
+          # state ("completed" hides a partial :continue run; "failed" hides a
+          # rejection), in the progress panel's colours.
+          def render_outcome(run)
+            span(class: "pu-badge pu-badge-#{RunProgress::BADGE_VARIANTS.fetch(run.outcome, "neutral")}") do
+              plain(Plutonium::Translation.value_label(run.class, :outcome, run.outcome) || run.outcome.humanize)
+            end
+          end
         end
       end
     end

data/lib/plutonium/ui/layout/base.rb

@@ -244,15 +244,6 @@ module Plutonium
               "sha384-uqD/OYCNfagd1EgXMgl5QedTD5K+B3e9b8GYo/41t7+Serf7CBxvl+tU1gHd+qd1",
             crossorigin: "anonymous"
           )
-          # EasyMDE's toolbar uses Font Awesome 4 class names (renamed in 5+).
-          link(
-            rel: "stylesheet",
-            href:
-              "https://cdn.jsdelivr.net/npm/font-awesome@4.7.0/css/font-awesome.min.css",
-            integrity:
-              "sha384-wvfXpqpZZVQGK6TAh5PVlGOfQNHSoD2xbE+QkPxCAFlNEevoEH3Sl0sibVcOQVnN",
-            crossorigin: "anonymous"
-          )
         end
 
         def render_scripts

data/lib/plutonium/ui/page/index.rb

@@ -4,6 +4,11 @@ module Plutonium
   module UI
     module Page
       class Index < Base
+        # How many recently finished runs the running banner lists at most. It
+        # sits above the collection; a burst of dispatches must not push the
+        # collection off the screen. The run index has the rest.
+        RECENT_RUNS_LIMIT = 5
+
         # Cookie name carrying a per-resource view preference. Single
         # source of truth — Table::Resource, Grid::Resource, and the
         # Stimulus view-switcher controller all read from here. Underscored
@@ -101,12 +106,26 @@ module Plutonium
           # a URL for a route that doesn't exist here.
           return unless registered_resources.include?(Plutonium::Interaction::Async::Run)
 
-          runs = authorized_resource_scope(
-            Plutonium::Interaction::Async::Run,
-            relation: Plutonium::Interaction::Async::Run.for_target(resource_class).in_progress
+          run_class = Plutonium::Interaction::Async::Run
+          in_progress = authorized_resource_scope(
+            run_class, relation: run_class.for_target(resource_class).in_progress
+          ).to_a
+
+          # The current user's own runs that settled moments ago. A dispatch
+          # sends them back here, and a short run (or one its pre_check rejected)
+          # finishes before this page renders, so "in progress" alone would show
+          # them nothing. Only their own: someone else's finished run is not news.
+          recent = authorized_resource_scope(
+            run_class,
+            relation: run_class.for_target(resource_class)
+              .where(initiator: current_user)
+              .finished_since(Plutonium.configuration.async_interactions.recent_runs_window.ago)
+              .order(finished_at: :desc)
+              .limit(RECENT_RUNS_LIMIT)
           ).to_a
 
-          render Plutonium::UI::Interaction::Async::RunningBanner.new(runs: runs)
+          # uniq: a run that finishes between the two queries is in both.
+          render Plutonium::UI::Interaction::Async::RunningBanner.new(runs: (in_progress + recent).uniq)
         end
 
         def selected_view

data/lib/plutonium/version.rb

@@ -1,5 +1,5 @@
 module Plutonium
-  VERSION = "0.68.0"
+  VERSION = "0.69.0"
   NEXT_MAJOR_VERSION = VERSION.split(".").tap { |v|
     v[1] = v[1].to_i + 1
     v[2] = 0

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radioactive-labs/plutonium",
-  "version": "0.68.0",
+  "version": "0.69.0",
   "description": "Build production-ready Rails apps in minutes, not days. Convention-driven, fully customizable, AI-ready.",
   "type": "module",
   "main": "src/js/core.js",

data/src/css/components.css

@@ -1222,6 +1222,15 @@ html.pu-rail-pinned .icon-rail-pin-expand {
   margin-left: var(--pu-drag-marker-gap, 4px);
 }
 
+/* The failures on an async run's progress panel: an inline alert holding a
+   list, so it sits flush in the card and the list keeps its bullets. */
+.pu-run-progress-failures {
+  @apply mb-0 items-start;
+}
+.pu-run-progress-failures .pu-alert-message {
+  @apply ms-0 ps-4 list-disc space-y-1;
+}
+
 /* Indeterminate progress for an async run with no denominator (opaque work).
    A short segment sweeping the track: the motion is what says "alive", which a
    static bar at any width cannot, and a full-width bar would misread as done. */