plutonium 0.62.2 → 0.63.0

data/lib/plutonium/ui/grid/resource.rb

@@ -8,6 +8,8 @@ module Plutonium
       # panel, scopes pills, bulk actions, footer) so view-switching is
       # purely a render-shape change.
       class Resource < Plutonium::UI::Component::Base
+        include Plutonium::UI::Component::Positionable
+
         attr_reader :collection, :resource_fields, :resource_definition
 
         def initialize(collection, resource_fields:, resource_definition:)
@@ -42,7 +44,7 @@ module Plutonium
         def render_toolbar
           TableToolbar(
             query: current_query_object,
-            search_url: request.path,
+            search_url: current_query_object.request_path,
             search_value: params.dig(:q, :search) || params[:search],
             views: resource_definition.defined_index_views,
             current_view: :grid,
@@ -71,13 +73,53 @@ module Plutonium
         end
 
         def render_grid
-          div(class: grid_class) do
+          div(class: grid_class, data: grid_data) do
             collection.each do |record|
-              render Plutonium::UI::Grid::Card.new(record, resource_definition:, resource_fields:)
+              render Plutonium::UI::Grid::Card.new(
+                record,
+                resource_definition:,
+                resource_fields:,
+                drag_handle: drag_handle_for(record),
+                position_group: position_group_for(record)
+              )
             end
           end
         end
 
+        # The grid div is the tightest element containing every card and nothing
+        # else the drag cares about, so it is where the controller is scoped —
+        # exactly as Table::Base scopes it to the div wrapping <table>.
+        #
+        # Only wired when a drop can actually be honoured (see
+        # Positionable#position_drag_enabled?). Under any other sort the cards
+        # still render their grip, but as the disabled link back to position
+        # order, and no controller is present to drag against.
+        def grid_data
+          return {} unless position_drag_enabled?
+
+          {
+            controller: "positioned",
+            positioned_url_template_value: position_url_template,
+            # Cards flow left-to-right and wrap, so the vertical midpoint test a
+            # table uses would collapse a whole row of cards into one slot.
+            positioned_axis_value: "horizontal"
+          }
+        end
+
+        # The grip for `record`, or nil when this resource is not reorderable /
+        # this viewer may not reorder this record. `position_grip_sort_url` is
+        # memoized on the collection's sort, so the per-record cost here is just
+        # the policy check.
+        def drag_handle_for(record)
+          return nil unless position_config
+          return nil unless repositionable?(record)
+
+          Plutonium::UI::Table::Components::DragHandle.new(
+            sort_url: position_grip_sort_url,
+            variant: :card
+          )
+        end
+
         # Default responsive: 1 / 2 / 3 / 4 columns at sm/md/lg/xl. When
         # the definition pins a fixed `grid_columns N`, use that on lg+ so
         # mobile still gets sensible single-column.
@@ -92,7 +134,7 @@ module Plutonium
 
         def bulk_actions
           @bulk_actions ||= resource_definition.defined_actions
-            .select { |k, a| a.bulk_action? }
+            .select { |k, a| a.bulk_action? && !a.hidden? && a.condition_met?(view_context) }
             .values
         end
 
@@ -124,7 +166,7 @@ module Plutonium
             render Plutonium::UI::Table::Components::FilterForm.new(
               filter_form_values,
               query_object: current_query_object,
-              search_url: request.path,
+              search_url: current_query_object.request_path,
               search_value: params.dig(:q, :search) || params[:search]
             )
           end

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Interaction
+      module Async
+        # The progress panel on a run's show page — the page IS the progress page.
+        #
+        # == How it refreshes
+        #
+        # Polling, not ActionCable: a turbo-frame the browser re-fetches on a timer
+        # works on any deployment, including ones with no cable server, and a run's
+        # progress is a handful of numbers that nobody needs sub-second. The frame
+        # is driven by the +run-progress+ Stimulus controller, which lives INSIDE
+        # the frame — so when the run finishes, the refreshed markup no longer
+        # carries the controller and the timer stops of its own accord. A finished
+        # run is a static record; a poll that never stops is a background request
+        # per viewer, forever.
+        #
+        # The frame's +src+ is the run's own show URL. Turbo sends
+        # +Turbo-Frame: <id>+ with that request, so the response must be the PANEL
+        # ALONE — Plutonium's DynaFrameContent already wraps every response in a
+        # frame named by that header, and a second tag with the same id would nest
+        # the whole page inside its own progress frame (and again on the next
+        # poll). {Async::RunDefinition::ShowPage} short-circuits the page for exactly this
+        # request; this class drops its own frame tag to match.
+        class RunProgress < Plutonium::UI::Component::Base
+          include Phlex::Rails::Helpers::TurboFrameTag
+
+          # Slow enough to be cheap for a page left open on a wall display, fast
+          # enough that a short run does not look stuck.
+          POLL_INTERVAL_MS = 2_000
+
+          # Must match the animation in components.css. Ruby needs it because the
+          # poll restarts the animation and only the server knows how far into
+          # the sweep the bar should be — see #sweep_phase_ms.
+          SWEEP_DURATION_MS = 1_400
+
+          # Semantic colour per outcome. +completed_with_errors+ is deliberately
+          # NOT success: see Plutonium::Interaction::Async::Run#outcome.
+          BADGE_VARIANTS = {
+            "pending" => "warning",
+            "running" => "info",
+            "completed" => "success",
+            "completed_with_errors" => "warning",
+            "failed" => "danger"
+          }.freeze
+
+          # Public so the page can recognise a poll of THIS panel and answer with
+          # the panel alone.
+          def self.frame_id(run) = "pu_run_progress_#{run.id}"
+
+          def initialize(run)
+            @run = run
+          end
+
+          attr_reader :run
+
+          def view_template
+            return render_panel if answering_own_frame?
+
+            # `turbo-frame` defaults to `display: inline`, which swallows the
+            # margin `sections_wrapper` needs to separate it from the card below.
+            turbo_frame_tag(frame_id, class: "block") { render_panel }
+          end
+
+          private
+
+          def frame_id = self.class.frame_id(run)
+
+          # True when this render IS the response to the frame's own poll.
+          def answering_own_frame? = current_turbo_frame == frame_id
+
+          # Reload once, so the fields outside this frame stop disagreeing with it.
+          def finished_attributes
+            # The STRING, not true: Phlex renders a boolean attribute bare, and a
+            # valueless data attribute is exactly the shape Stimulus's Boolean
+            # coercion is least clear about.
+            {data: {controller: "run-progress", run_progress_finished_value: "true"}}
+          end
+
+          def render_panel
+            div(class: "pu-card pu-run-progress", **poll_attributes) do
+              div(class: "pu-card-body space-y-4") do
+                render_status
+                render_progress
+                render_failures if run.errors_log.any?
+              end
+            end
+          end
+
+          # Only an in-progress run carries the poll. Absent here, nothing on the
+          # page has a timer — which is how the refresh stops.
+          #
+          # Except on the LAST poll, which needs one more instruction. Only this
+          # panel lives in the polled frame; the fields beside it were rendered
+          # once, when the run was dispatched. So a run that finishes leaves the
+          # page showing two contradicting truths — a green "Completed, 5 of 5"
+          # above a list still reading "Running", "0 done", "finished at -" — and
+          # the stale half is the more detailed one. Telling the page to reload
+          # itself once is what lets those fields catch up.
+          #
+          # It cannot loop. The flag is emitted only while ANSWERING A POLL, and
+          # the reload it triggers is a full page render, where that is false.
+          def poll_attributes
+            return finished_attributes if !run.in_progress? && answering_own_frame?
+            return {} unless run.in_progress?
+
+            {
+              data: {
+                controller: "run-progress",
+                run_progress_url_value: resource_url_for(run),
+                run_progress_interval_value: POLL_INTERVAL_MS
+              }
+            }
+          end
+
+          def render_status
+            div(class: "flex items-center gap-2 flex-wrap") do
+              span(class: "pu-badge pu-badge-#{BADGE_VARIANTS.fetch(run.outcome, "neutral")}") do
+                plain run.outcome.humanize
+              end
+              # 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.
+              if run.error_count.positive?
+                span(class: "text-xs font-medium text-[var(--pu-text-danger)]") do
+                  plain "#{run.error_count} #{"error".pluralize(run.error_count)}"
+                end
+              end
+            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
+          # show progress_done > 0. Paired with the state that reads correctly;
+          # alone it reads as work done. See Async::Executor#refuse_partial_batch.
+          def render_progress
+            fraction = run.progress_fraction
+
+            # nil total is INDETERMINATE, not zero: opaque work has no denominator,
+            # and a 0% bar would claim nothing has happened rather than admitting
+            # the amount is unknown.
+            return render_indeterminate if fraction.nil?
+
+            percent = (fraction * 100).round
+            div(class: "space-y-1") do
+              div(class: "w-full h-2 rounded-full bg-[var(--pu-surface-alt)] overflow-hidden") do
+                div(class: "h-2 rounded-full bg-primary-600", style: "width: #{percent}%")
+              end
+              div(class: "text-xs text-[var(--pu-text-muted)]") do
+                plain "#{run.progress_done} of #{run.progress_total} targets (#{percent}%)"
+              end
+            end
+          end
+
+          # Opaque work still gets a BAR, just one that admits it cannot say how
+          # far along it is. "Working…" as bare text read as a stalled page —
+          # nothing on it moved, so nothing said the run was alive. The animation
+          # is the part that carries that, and it is the only difference from the
+          # determinate bar above: same height, same track, same radius.
+          #
+          # A settled run with no total gets no bar, because there is no motion
+          # left to convey.
+          def render_indeterminate
+            div(class: "space-y-1") do
+              if run.in_progress?
+                div(class: "w-full h-2 rounded-full bg-[var(--pu-surface-alt)] overflow-hidden") do
+                  div(
+                    class: "h-2 rounded-full bg-primary-600 pu-run-progress-indeterminate",
+                    style: "animation-delay: -#{sweep_phase_ms}ms"
+                  )
+                end
+              end
+              div(class: "text-xs text-[var(--pu-text-muted)]") do
+                plain(run.in_progress? ? "Working…" : "No progress total was recorded")
+              end
+            end
+          end
+
+          # How far into the sweep the bar should already be, as a NEGATIVE
+          # animation-delay.
+          #
+          # The poll re-renders this panel every POLL_INTERVAL_MS, and an element
+          # re-inserted into the DOM restarts its CSS animation from zero —
+          # marking it turbo-permanent does not help, because Turbo MOVES it and
+          # a move is a re-insertion. So a 1.4s sweep chopped every 2s snapped
+          # back to the left mid-pass, forever, making the one signal that says
+          # "this run is alive" look like a stutter.
+          #
+          # Restarting is therefore unavoidable; restarting at the WRONG PLACE is
+          # not. Anchoring the phase to the run's own clock means each restart
+          # picks up where the last render left off, and the sweep reads as
+          # continuous across every poll.
+          def sweep_phase_ms
+            started = run.started_at || run.created_at
+            return 0 unless started
+
+            ((Time.current - started) * 1000).to_i % SWEEP_DURATION_MS
+          end
+
+          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 "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
+              end
+            end
+          end
+
+          # 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)
+            target_id = entry["target_id"]
+            target_id.nil? ? entry["message"].to_s : "##{target_id}: #{entry["message"]}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Interaction
+      module Async
+        # Lists the runs currently working on THIS resource, above its collection.
+        #
+        # == Why it exists
+        #
+        # A dispatch redirects to the run's own page, but a user who navigates away
+        # has no way back short of knowing the URL. The index of the resource being
+        # worked on is where they will look, so that is where the run has to be.
+        #
+        # == Why it queries on target_type
+        #
+        # +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.
+        #
+        # == Why it can render nothing
+        #
+        # An always-present empty banner is chrome that teaches the user to ignore
+        # the area it occupies. When nothing is running there is nothing to say.
+        class RunningBanner < Plutonium::UI::Component::Base
+          def initialize(runs:)
+            @runs = runs
+          end
+
+          attr_reader :runs
+
+          def view_template
+            return if runs.empty?
+
+            div(class: "pu-running-banner mb-3 rounded-[var(--pu-radius-md)] border border-[var(--pu-border)] bg-[var(--pu-surface-alt)] p-3 space-y-2") do
+              runs.each { |run| render_run(run) }
+            end
+          end
+
+          private
+
+          def render_run(run)
+            div(class: "flex items-center justify-between gap-3 text-sm", data: {run_id: run.id}) do
+              div(class: "min-w-0") do
+                # The label carries the run's identity; the state carries what it
+                # is doing. Progress is deliberately NOT shown bare here: after a
+                # refused partial batch progress_done counts targets DISPOSITIONED
+                # rather than attempted, so a number without its state is
+                # misleading (see Async::Executor#refuse_partial_batch). The run's
+                # 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 run.state.humanize }
+              end
+              a(href: resource_url_for(run), class: "pu-btn pu-btn-xs pu-btn-soft-primary shrink-0") do
+                plain "View progress"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/kanban/card.rb

@@ -57,7 +57,8 @@ module Plutonium
             card_fields: @card_fields,
             # Escape the column's lazy turbo-frame: either "_top" (full page) or
             # the document-wide remote-modal frame, both of which resolve outside
-            # the kanban-col-<key> frame.
+            # the kanban-col-<key> frame. Grid::Card keys the metadata-rail hiding
+            # off this frame — the modal frame here means a kanban card's modal.
             show_turbo_frame: @show_turbo_frame
           )
         end

data/lib/plutonium/ui/kanban/column.rb

@@ -340,12 +340,7 @@ module Plutonium
               url = resource_url_for(resource_class, interaction: col_action.key, ids: ids, return_to: @board_url)
               label = col_action.label || col_action.key.to_s.humanize
 
-              link_to(
-                url,
-                class: "pu-btn pu-btn-ghost pu-btn-xs text-[var(--pu-text-muted)]",
-                title: label,
-                data: column_action_link_data(col_action, registered)
-              ) do
+              link_to(url, column_action_link_attributes(col_action, registered, label)) do
                 render col_action.icon.new(class: "h-4 w-4") if col_action.icon
                 plain label
               end
@@ -353,6 +348,17 @@ module Plutonium
           end
         end
 
+        # Full attribute hash for a column-action link, funnelling the
+        # registered action's author `link:` bag through the action's own
+        # merge point like every other action surface.
+        def column_action_link_attributes(col_action, registered, label)
+          registered.link_attributes({
+            class: "pu-btn pu-btn-ghost pu-btn-xs text-[var(--pu-text-muted)]",
+            title: label,
+            data: column_action_link_data(col_action, registered)
+          })
+        end
+
         # Data attributes for a column-action link, honouring the interaction's
         # shape. `immediate` actions (no inputs) POST straight to the commit route
         # with a confirmation, executed directly; the rest open the form in the

data/lib/plutonium/ui/kanban/resource.rb

@@ -75,13 +75,12 @@ module Plutonium
           # the board carries the shared view switcher (Table | Grid | Board),
           # search, scopes, and filters rather than rendering bare columns.
           div(data: filter_panel_controller_data) do
-            # Persistent append target for move-rejection toasts. It lives
-            # OUTSIDE the per-column turbo-frames so it survives the frame swaps
-            # a move triggers; toasts are position:fixed, so its location in the
-            # DOM has no layout effect. The move handler appends a flash toast
-            # here via turbo_stream when a drop is rejected (WIP / accepts /
-            # locked) so the snap-back is explained rather than silent.
-            div(id: "kanban-flash")
+            # NOTE: move-rejection toasts are appended to the LAYOUT's shared
+            # toast region (Plutonium::FLASH_REGION) rather than one the board
+            # owns. It sits outside every collection and column frame, so it
+            # survives the frame swaps a move triggers, and it is the same
+            # region the reposition drop uses — one flash target for the
+            # framework, not one per draggable surface.
             render_scopes_pills
             render_toolbar
 

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

@@ -27,9 +27,9 @@ module Plutonium
 
         def html_attributes = {lang:, data_controller: "color-mode"}
 
-        def body_attributes = {class: "antialiased min-h-screen bg-[var(--pu-body)] text-[var(--pu-text)]"}
+        def body_attributes = {class: "antialiased pu-min-h-viewport bg-[var(--pu-body)] text-[var(--pu-text)]"}
 
-        def main_attributes = {class: "p-4 min-h-screen"}
+        def main_attributes = {class: "p-4 pu-min-h-viewport"}
 
         def render_head
           head {
@@ -106,8 +106,15 @@ module Plutonium
           }
         end
 
+        # The page's toast region. The id makes it a stable turbo_stream append
+        # target, so any action that answers a stream (rather than rendering a
+        # layout that would consume `flash`) can surface a message without
+        # inventing a region of its own — the reposition drop's rejection toasts
+        # land here. Toasts are position:fixed, so the wrapper has no layout
+        # effect. Rendered once per full page load, outside every collection
+        # frame, so a stream that replaces a collection cannot blow it away.
         def render_flash
-          render partial("flash")
+          div(id: Plutonium::FLASH_REGION) { render partial("flash") }
         end
 
         def render_before_content

data/lib/plutonium/ui/nav_grid_menu.rb

@@ -66,6 +66,7 @@ module Plutonium
       def render_trigger_button
         button(
           type: "button",
+          aria: {expanded: "false"},
           data: {resource_drop_down_target: "trigger"},
           class: "p-2 text-[var(--pu-text-muted)] rounded-[var(--pu-radius-md)] hover:text-[var(--pu-text)] hover:bg-[var(--pu-surface-alt)] focus:ring-2 focus:ring-[var(--pu-border)] transition-colors"
         ) do

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

@@ -127,6 +127,25 @@ module Plutonium
         def render_after_footer
         end
 
+        # Where a modal's "open full page" affordance points: THIS request,
+        # minus the params that only mean something inside a modal.
+        #
+        # Deliberately not bare `request.path`. That drops the whole query
+        # string, and some of it is load-bearing on the standalone page too —
+        # `return_to` (where to go after submitting) and `kanban_column`
+        # (which column a quick-add's new record belongs to) would both be
+        # silently lost, so the expanded form would submit to the wrong place
+        # or into no column.
+        #
+        # `kanban_modal` is the one param that must NOT survive: it marks a
+        # kanban card's modal, where the show page suppresses the metadata
+        # rail. Carried onto a full page it would keep metadata hidden there
+        # for no reason.
+        def open_full_page_url
+          query = request.query_parameters.except(Plutonium::KANBAN_MODAL_PARAM)
+          query.empty? ? request.path : "#{request.path}?#{query.to_query}"
+        end
+
         def page_type = raise NotImplementedError, "#{self.class}#page_type"
       end
     end

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

@@ -27,7 +27,10 @@ module Plutonium
           render modal_class.new(
             title: page_title,
             description: page_description,
-            size: current_definition.modal_size
+            size: current_definition.modal_size,
+            # Opens this form standalone in a NEW TAB (target=_blank), so the
+            # modal — and anything already typed into it — stays put.
+            open_full_url: open_full_page_url
           ) do
             render partial("resource_form")
           end

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

@@ -22,6 +22,40 @@ module Plutonium
           path.empty? ? "/" : path
         end
 
+        # DOM id of the wrapper around the rendered collection (table OR grid;
+        # never the kanban board, which owns its own column frames).
+        #
+        # This is the turbo-stream target the reposition endpoint updates when a
+        # drop leaves the client's optimistic view stale, and the element the
+        # drag controllers (Tasks 7/8) scope themselves to. Resource-scoped so
+        # two collections of DIFFERENT resources on one page (a nested
+        # association panel inside a show page) don't collide.
+        def self.collection_dom_id(resource_class)
+          "pu-collection-#{resource_class.model_name.plural}"
+        end
+
+        # Resolves the index view to render. Extracted to a class method because
+        # the reposition endpoint has to re-render the SAME view the user is
+        # looking at, and re-deriving that from scratch in the controller would
+        # be a second, drifting copy of this precedence.
+        #
+        # Resolution order:
+        # 1. `?view=` URL param (so a shared link can pin a view)
+        # 2. The view-preference cookie (sticky per-resource selection)
+        # 3. The resource's `default_index_view` (which itself defaults to
+        #    `index_views.first`)
+        def self.resolve_view(definition, resource_class, view_param, cookies)
+          enabled = definition.defined_index_views
+
+          requested = view_param&.to_sym
+          return requested if requested && enabled.include?(requested)
+
+          stored = cookies[view_cookie_name(resource_class)]&.to_sym
+          return stored if stored && enabled.include?(stored)
+
+          definition.default_index_view
+        end
+
         private
 
         def page_title
@@ -33,33 +67,50 @@ module Plutonium
         end
 
         def page_actions
-          super || current_definition.defined_actions.values.select { |a| a.resource_action? && !a.kanban_drop? && a.permitted_by?(current_policy) && a.condition_met?(view_context) }
+          super || current_definition.defined_actions.values.select { |a| a.resource_action? && !a.hidden? && a.permitted_by?(current_policy) && a.condition_met?(view_context) }
         end
 
         def render_default_content
-          case selected_view
-          when :kanban then render partial("resource_kanban")
-          when :grid then render partial("resource_grid")
-          else render partial("resource_table")
+          # The board owns its own frames (and its own drop target), so it is
+          # rendered bare. Table and grid share one id'd wrapper: it is what the
+          # reposition endpoint streams into after a drop, so the surface the
+          # drag controller reads and the surface the server replaces are the
+          # same element in both views.
+          render_running_banner
+
+          return render partial("resource_kanban") if selected_view == :kanban
+
+          div(id: self.class.collection_dom_id(resource_class)) do
+            render partial((selected_view == :grid) ? "resource_grid" : "resource_table")
           end
         end
 
-        # Resolution order:
-        # 1. `?view=` URL param (so a shared link can pin a view)
-        # 2. The view-preference cookie (sticky per-resource selection)
-        # 3. The resource's `default_index_view` (which itself defaults to
-        #    `index_views.first`)
-        def selected_view
-          definition = current_definition
-          enabled = definition.defined_index_views
+        # Runs currently working on this resource, above the collection.
+        #
+        # Rendered OUTSIDE the collection wrapper on purpose: that div is what
+        # the reposition endpoint streams into after a drag, so anything inside
+        # it is destroyed on the next drop.
+        #
+        # Scoped through authorized_resource_scope, the same door every other
+        # cross-resource read goes through, so a run dispatched in another tenant
+        # can never appear here — the banner cannot be a way around the policy.
+        def render_running_banner
+          return unless Plutonium.configuration.async_interactions.enabled
+          # A shared resource_class can be registered in a portal that never
+          # registered Run — its "View progress" link would then 500 building
+          # a URL for a route that doesn't exist here.
+          return unless registered_resources.include?(Plutonium::Interaction::Async::Run)
 
-          requested = params[:view]&.to_sym
-          return requested if requested && enabled.include?(requested)
+          runs = authorized_resource_scope(
+            Plutonium::Interaction::Async::Run,
+            relation: Plutonium::Interaction::Async::Run.for_target(resource_class).in_progress
+          ).to_a
 
-          stored = helpers.cookies[self.class.view_cookie_name(resource_class)]&.to_sym
-          return stored if stored && enabled.include?(stored)
+          render Plutonium::UI::Interaction::Async::RunningBanner.new(runs: runs)
+        end
 
-          definition.default_index_view
+        def selected_view
+          self.class.resolve_view(current_definition, resource_class, params[:view], helpers.cookies)
         end
 
         def page_type = :index_page

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

@@ -25,7 +25,11 @@ module Plutonium
             render modal_class.new(
               title: page_title,
               description: page_description,
-              size: current_interactive_action.modal_size(current_definition)
+              size: current_interactive_action.modal_size(current_definition),
+              # The action's own GET path renders the standalone branch below,
+              # and opens in a NEW TAB, so the modal keeps whatever has already
+              # been typed into it.
+              open_full_url: open_full_page_url
             ) do
               render_interactive_action_form
             end

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

@@ -27,7 +27,10 @@ module Plutonium
           render modal_class.new(
             title: page_title,
             description: page_description,
-            size: current_definition.modal_size
+            size: current_definition.modal_size,
+            # Opens this form standalone in a NEW TAB (target=_blank), so the
+            # modal — and anything already typed into it — stays put.
+            open_full_url: open_full_page_url
           ) do
             render partial("resource_form")
           end