plutonium 0.61.0 → 0.62.0

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

@@ -53,7 +53,19 @@ module Plutonium
         # Resolved by the controller and threaded through to Kanban::Card.
         # Defaults to "_top" so a card always escapes the column's lazy frame when
         # the component is built outside a controller (tests, board shell).
-        def initialize(column:, cards:, total:, per_column:, resource_definition:, resource_fields:, column_action_data: [], column_add_url: nil, card_fields: nil, card_show_frame: "_top")
+        # collapsed: the EFFECTIVE collapse state for this render (the user's
+        # cookie-persisted choice resolved against the column default by the
+        # controller). nil → fall back to the column's declared default. The
+        # component still emits the DEFAULT separately (data-kanban-default-
+        # collapsed) so the controller can store only deltas from it.
+        # drop_form_url_template: the kanban_move_form member URL with an __ID__
+        # placeholder for the dragged card's record id (mirrors the board's
+        # move-url template). Set by the controller ONLY for columns that declare
+        # an enter_interaction:; nil for plain columns. When present, the wrapper
+        # advertises data-kanban-drop-interaction + data-kanban-drop-form-url-
+        # template so Task 6's Stimulus controller opens the interaction modal on
+        # drop instead of committing the move immediately.
+        def initialize(column:, cards:, total:, per_column:, resource_definition:, resource_fields:, column_action_data: [], column_add_url: nil, board_url: nil, card_fields: nil, card_show_frame: "_top", collapsed: nil, drop_form_url_template: nil, drop_immediate: false, drop_confirm: nil)
           @column = column
           @cards = cards
           @total = total
@@ -62,8 +74,19 @@ module Plutonium
           @resource_fields = resource_fields
           @column_action_data = column_action_data
           @column_add_url = column_add_url
+          @board_url = board_url
           @card_fields = card_fields
           @card_show_frame = card_show_frame
+          @collapsed = collapsed
+          @drop_form_url_template = drop_form_url_template
+          @drop_immediate = drop_immediate
+          @drop_confirm = drop_confirm
+        end
+
+        # Effective collapse state: the caller's resolved value, or the column
+        # default when none was passed (tests / board shell / non-cookie paths).
+        def effective_collapsed?
+          @collapsed.nil? ? column.collapsed? : @collapsed
         end
 
         def view_template
@@ -73,13 +96,9 @@ module Plutonium
           div(
             class: tokens(
               "pu-kanban-column-wrapper",
-              column.collapsed? && "pu-kanban-column-collapsed"
+              effective_collapsed? && "pu-kanban-column-collapsed"
             ),
-            data: {
-              kanban_col: column.key.to_s,
-              kanban_accepts: accepts_value,
-              kanban_locked: column.locked?.to_s
-            }
+            data: wrapper_data
           ) do
             render_collapsed_strip
             render_expanded
@@ -88,6 +107,33 @@ module Plutonium
 
         private
 
+        # Data attributes for the [data-kanban-col] wrapper. Drop-policy hints
+        # (accepts/locked) and the collapse default are always present; the
+        # drop-interaction attributes are added only when the column declares an
+        # enter_interaction: (advertised via the controller-computed template).
+        def wrapper_data
+          data = {
+            kanban_col: column.key.to_s,
+            # The DEFAULT (not the effective state) so the controller can store
+            # only a delta from it in the cookie.
+            kanban_default_collapsed: column.collapsed?.to_s,
+            kanban_accepts: accepts_value,
+            kanban_locked: column.locked?.to_s
+          }
+
+          if column.enter_interaction?
+            data[:kanban_drop_interaction] = "true"
+            data[:kanban_drop_form_url_template] = @drop_form_url_template
+            # An input-less interaction commits directly on drop (no form modal);
+            # the client reads this to skip opening an empty modal. The optional
+            # confirm message (auto "<label>?" for immediate actions) gates it.
+            data[:kanban_drop_immediate] = "true" if @drop_immediate
+            data[:kanban_drop_confirm] = @drop_confirm if @drop_confirm.present?
+          end
+
+          data
+        end
+
         # ---------------------------------------------------------------
         # Collapsed strip
         # ---------------------------------------------------------------
@@ -102,6 +148,9 @@ module Plutonium
                    "rounded-[var(--pu-radius-md)] select-none",
             data: {kanban_role: "strip"}
           ) do
+            # The color dot is the outcome signal for terminal columns (:done
+            # green, :lost red) — keep it visible when collapsed too.
+            render_color_dot(column.color) if column.color
             span(
               class: "text-xs font-semibold text-[var(--pu-text-muted)] " \
                      "[writing-mode:vertical-lr] rotate-180"
@@ -120,7 +169,9 @@ module Plutonium
                 kanban_column_key: column.key.to_s
               }
             ) { plain "▶" }
-            render_column_actions if column.actions.any?
+            # No column actions here: a collapsed column is a thin strip, so its
+            # bulk actions (and "+ Add") stay hidden until it's expanded. They
+            # live only in the expanded header (render_header).
           end
         end
 
@@ -147,7 +198,13 @@ module Plutonium
             div(class: "flex items-center gap-2 min-w-0 flex-1") do
               render_color_dot(column.color) if column.color
               span(class: "font-semibold text-sm text-[var(--pu-text)] truncate") { plain column.label }
-              render_wip_badge if column.wip
+              # Always show a card count (matching the collapsed strip); when a
+              # WIP limit is set it becomes the "count/limit" badge instead.
+              if column.wip
+                render_wip_badge
+              else
+                render_count_badge
+              end
             end
             render_column_actions if @column_add_url || column.actions.any?
             # Collapse toggle — always present in the expanded header so the
@@ -167,6 +224,12 @@ module Plutonium
           end
         end
 
+        # Plain card-count badge for columns without a WIP limit — mirrors the
+        # count shown on the collapsed strip so the number is visible either way.
+        def render_count_badge
+          span(class: "pu-badge pu-badge-neutral text-xs font-mono") { plain cards.size.to_s }
+        end
+
         def render_wip_badge
           over = wip_over_limit?
           span(
@@ -243,15 +306,17 @@ module Plutonium
         # Renders bulk-action links for each column action, and the "+ Add"
         # quick-add button when column_add_url is present.
         #
-        # Each bulk-action link targets GET /resources/bulk_actions/:key?ids[]=…,
-        # which is the existing interactive_bulk_action route.  The action is only
-        # rendered when:
-        #   1. The resolved action is registered in defined_actions (auto-registered
-        #      by Definition::IndexViews.kanban at class-load time).
-        #   2. current_policy.allowed_to?(:"#{key}?") returns true.
+        # Each link targets /resources/bulk_actions/:key?ids[]=… — the same path
+        # for the GET form and the POST commit. The render mirrors ActionButton so
+        # the action's shape is honoured (see #column_action_link_data):
+        #   • an interaction with NO user inputs is `immediate` → POST + confirm,
+        #     executed directly instead of opening an empty form modal;
+        #   • one with inputs opens the interaction form in the remote modal.
         #
-        # The bulk endpoint re-authorizes each record individually, so this
-        # check is a display-only gate — not the security boundary.
+        # The action is only rendered when it's registered in defined_actions
+        # (auto-registered by Definition::IndexViews.kanban) and permitted by the
+        # policy. The bulk endpoint re-authorizes each record, so this is a
+        # display-only gate, not the security boundary.
         def render_column_actions
           div(class: "flex items-center gap-1 shrink-0") do
             render_add_button if @column_add_url
@@ -268,19 +333,18 @@ module Plutonium
               # if clicked. An empty column simply renders no action link.
               next if ids.empty?
 
-              url = resource_url_for(resource_class, interaction: col_action.key, ids: ids)
+              # return_to the board so the action redirects back to it (not the
+              # table index) AND the board refreshes: the board-bound redirect is
+              # tagged with kanban_reload (KanbanActions#kanban_reload_url), so the
+              # column re-fetches and the mutated cards (e.g. archived) update.
+              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
-              data_attrs = {
-                kanban_action: col_action.key.to_s,
-                kanban_column: column.key.to_s
-              }
-              data_attrs[:turbo_confirm] = col_action.confirmation if col_action.confirmation
 
               link_to(
                 url,
                 class: "pu-btn pu-btn-ghost pu-btn-xs text-[var(--pu-text-muted)]",
                 title: label,
-                data: data_attrs
+                data: column_action_link_data(col_action, registered)
               ) do
                 render col_action.icon.new(class: "h-4 w-4") if col_action.icon
                 plain label
@@ -289,6 +353,29 @@ module Plutonium
           end
         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
+        # remote modal. The confirmation prefers the DSL-supplied one, falling
+        # back to the action's own default ("<label>?" for immediate actions).
+        def column_action_link_data(col_action, registered)
+          data = {
+            kanban_action: col_action.key.to_s,
+            kanban_column: column.key.to_s
+          }
+
+          if registered.immediate
+            data[:turbo_method] = :post
+            confirmation = col_action.confirmation || registered.confirmation
+            data[:turbo_confirm] = confirmation if confirmation.present?
+          else
+            data[:turbo_frame] = Plutonium::REMOTE_MODAL_FRAME
+            data[:turbo_confirm] = col_action.confirmation if col_action.confirmation
+          end
+
+          data
+        end
+
         # ---------------------------------------------------------------
         # Pure helpers
         # ---------------------------------------------------------------

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

@@ -24,6 +24,28 @@ module Plutonium
         include Phlex::Rails::Helpers::TurboFrameTag
         include Phlex::Rails::Helpers::TurboStreamFrom
 
+        # Per-board collapse cookie. Stores ONLY the column keys whose collapse
+        # state differs from the server default (a compact delta): a board sitting
+        # at its defaults writes nothing, and toggling a column back to default
+        # drops its key — so the cookie can't balloon. Path-scoped to the engine
+        # mount so it rides only this board's requests. The server reads it to
+        # render each column in the user's state (no client re-apply / FOUC); the
+        # kanban controller writes it on toggle.
+        def self.collapse_cookie_name(resource_class)
+          "pu_kbc_#{resource_class.name.gsub("::", "_").underscore}"
+        end
+
+        def self.collapse_cookie_path(request)
+          path = request.script_name.to_s
+          path.empty? ? "/" : path
+        end
+
+        # The set of column keys (strings) flipped from their default, parsed
+        # from the cookie value. Order/whitespace-tolerant; blanks dropped.
+        def self.collapse_flips(cookie_value)
+          cookie_value.to_s.split(",").filter_map { |k| k.strip.presence }
+        end
+
         attr_reader :board, :grouped_data, :resource_definition, :resource_fields,
           :resource_class, :scoped_entity
 
@@ -64,18 +86,31 @@ module Plutonium
             render_toolbar
 
             div(
+              # `data-turbo-permanent` freezes the loaded board across index
+              # navigations (search / filter / scope all change the URL): Turbo
+              # transplants THIS element instead of re-rendering it as empty lazy
+              # shells, so the columns never blank. The `kanban` controller then
+              # syncs the frozen frames to the new URL (morphing cards in place).
+              # The id MUST be resource-scoped — a shared id would make Turbo
+              # preserve one resource's board when navigating to another's.
+              id: "kanban-board-#{resource_class.model_name.param_key}",
               class: "pu-kanban-board flex gap-4 overflow-x-auto p-4 min-h-0",
               data: {
+                turbo_permanent: true,
                 controller: "kanban",
                 # Stimulus value consumed by the drag controller to build the
                 # per-record move URL at drop time. The collection path comes from
                 # request.path so tenant / engine scoping is preserved automatically.
                 # Example: /admin/tasks/__ID__/kanban_move
-                kanban_move_url_template_value: kanban_move_url_template
+                kanban_move_url_template_value: kanban_move_url_template,
+                # Name + path the controller uses to write the collapse cookie —
+                # must match what the server reads (see collapse_cookie_name/path).
+                kanban_collapse_cookie_value: self.class.collapse_cookie_name(resource_class),
+                kanban_collapse_path_value: self.class.collapse_cookie_path(request)
               }
             ) do
               grouped_data.each do |entry|
-                render_column_frame(entry[:column])
+                render_column_frame(entry[:column], collapsed: entry[:collapsed])
               end
             end
 
@@ -157,29 +192,101 @@ module Plutonium
           )
         end
 
-        def render_column_frame(column)
-          attrs = {src: column_frame_src(column)}
+        def render_column_frame(column, collapsed: false)
+          # `refresh: "morph"` marks the frame morphable; `data-kanban-col-frame`
+          # lets the `kanban` controller find each column frame and rewrite its
+          # src to the current URL params (search / filter / scope) so cards
+          # morph in place instead of the frame blanking on reload.
+          attrs = {
+            src: column_frame_src(column),
+            refresh: "morph",
+            data: {kanban_col_frame: column.key}
+          }
           attrs[:loading] = "lazy" if board.lazy?
 
           turbo_frame_tag(column_frame_id(column), **attrs) do
-            # Header is inside the frame so the shell is meaningful while the
-            # body (card list) loads. Task 6 replaces the frame contents with
-            # the full column body rendered by Kanban::Column.
+            # The placeholder mirrors the SHAPE of the loaded column (a thin strip
+            # when collapsed, the full w-72 box otherwise) so the lazy body load
+            # doesn't snap between orientations/widths — a collapsed column that
+            # renders as an open header and then flips shut is the FOUC this fixes.
+            if collapsed
+              render_collapsed_placeholder(column)
+            else
+              render_column_placeholder(column)
+            end
+          end
+        end
+
+        # Full-column placeholder: matches the loaded expanded column box (w-72)
+        # so an expanded column doesn't resize when its body arrives.
+        def render_column_placeholder(column)
+          div(class: "pu-kanban-column w-72 shrink-0 flex flex-col bg-[var(--pu-surface-alt)] " \
+                     "border border-[var(--pu-border)] rounded-[var(--pu-radius-md)] overflow-hidden") do
             render_column_header(column)
           end
         end
 
-        # Mirrors Kanban::Column#render_header structurally (no count badge) so
-        # the shell→loaded transition doesn't flash a stale count or restructure.
+        # Strip placeholder: matches the loaded collapsed strip's full layout
+        # (w-10, justify-between, dot + vertical label + count badge + expand
+        # icon) so a collapsed column paints as a strip from the first frame AND
+        # doesn't grow/redistribute when the real strip (with its count + button)
+        # swaps in. The count/icon are reserved as invisible-/subtle skeletons.
+        def render_collapsed_placeholder(column)
+          div(
+            class: "pu-kanban-strip w-10 shrink-0 flex flex-col items-center justify-between py-3 gap-2 " \
+                   "bg-[var(--pu-surface)] border border-[var(--pu-border)] " \
+                   "rounded-[var(--pu-radius-md)] select-none",
+            data: {kanban_role: "strip"}
+          ) do
+            render_color_dot(column.color) if column.color
+            span(
+              class: "text-xs font-semibold text-[var(--pu-text-muted)] " \
+                     "[writing-mode:vertical-lr] rotate-180"
+            ) { plain column.label }
+            # The strip ALWAYS shows a card-count badge + expand button when
+            # loaded, so reserve both (unlike the header's wip-only count).
+            span(class: "pu-badge pu-badge-neutral text-xs font-mono opacity-0", aria_hidden: "true") { plain "0" }
+            span(class: "p-0.5 text-[var(--pu-text-subtle)]", aria_hidden: "true") { plain "▶" }
+          end
+        end
+
+        # Mirrors Kanban::Column#render_header's LAYOUT (dot + label, plus reserved
+        # slots for the count badge and the collapse icon) so the header keeps its
+        # exact size when the loaded body swaps in — nothing shifts or grows. The
+        # reserved slots are invisible skeletons; the real count/icon replace them
+        # on load without a reflow.
         def render_column_header(column)
-          div(class: "px-3 py-2 flex items-center justify-between border-b border-[var(--pu-border)] bg-[var(--pu-surface)]") do
-            div(class: "flex items-center gap-2 min-w-0") do
+          div(class: "px-3 py-2 flex items-center justify-between gap-2 border-b border-[var(--pu-border)] bg-[var(--pu-surface)]") do
+            div(class: "flex items-center gap-2 min-w-0 flex-1") do
               render_color_dot(column.color) if column.color
               span(class: "font-semibold text-sm text-[var(--pu-text)] truncate") { plain column.label }
+              # The loaded header always shows a count now — a plain count, or a
+              # "count/limit" badge for wip columns — so reserve it either way,
+              # sized to the eventual text.
+              render_count_placeholder(column.wip ? "0/0" : "0")
             end
+            render_icon_placeholder
           end
         end
 
+        # Invisible badge skeleton reserving the count badge's height and
+        # approximate width so the label doesn't reflow when the count appears.
+        def render_count_placeholder(text)
+          span(
+            class: "pu-badge pu-badge-neutral text-xs font-mono opacity-0",
+            aria_hidden: "true"
+          ) { plain text }
+        end
+
+        # Reserves the collapse toggle's footprint (the loaded header always has
+        # one on the right) so the row height and label width don't change on load.
+        def render_icon_placeholder
+          span(
+            class: "shrink-0 p-0.5 text-[var(--pu-text-subtle)]",
+            aria_hidden: "true"
+          ) { plain "◀" }
+        end
+
         # Builds the move URL template for the Stimulus drag controller.
         # The collection path from the current request is used so engine
         # mounting and path-scoped tenancy are automatically preserved.

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

@@ -27,7 +27,7 @@ module Plutonium
 
         def html_attributes = {lang:, data_controller: "color-mode"}
 
-        def body_attributes = {class: "antialiased min-h-screen bg-[var(--pu-body)]"}
+        def body_attributes = {class: "antialiased min-h-screen bg-[var(--pu-body)] text-[var(--pu-text)]"}
 
         def main_attributes = {class: "p-4 min-h-screen"}
 

data/lib/plutonium/ui/options/has_cents_field.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Options
+      # Shared detector for a `has_cents` money field, so the form and display
+      # inferred-type chains agree on what counts as currency (an explicit
+      # `as: :currency` is never needed for a `has_cents` attribute). Included
+      # into both `Form::Options::InferredTypes` and `Display::Options::InferredTypes`.
+      module HasCentsField
+        private
+
+        # Whether the field being rendered is a `has_cents` decimal accessor.
+        def has_cents_field?
+          klass = object.class
+          klass.respond_to?(:has_cents_decimal_attribute?) && klass.has_cents_decimal_attribute?(key)
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,7 @@ module Plutonium
         end
 
         def page_actions
-          super || current_definition.defined_actions.values.select { |a| a.resource_action? && a.permitted_by?(current_policy) && a.condition_met?(view_context) }
+          super || current_definition.defined_actions.values.select { |a| a.resource_action? && !a.kanban_drop? && a.permitted_by?(current_policy) && a.condition_met?(view_context) }
         end
 
         def render_default_content

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

@@ -27,13 +27,23 @@ module Plutonium
               description: page_description,
               size: current_interactive_action.modal_size(current_definition)
             ) do
-              render partial("interactive_action_form")
+              render_interactive_action_form
             end
           else
-            div(class: "pb-20") { render partial("interactive_action_form") }
+            div(class: "pb-20") { render_interactive_action_form }
           end
         end
 
+        # Renders the interaction's form inside the modal/page chrome.
+        # Extracted as a seam so subclasses (e.g. the kanban drop-move page)
+        # can swap in a form that posts elsewhere and carries extra context
+        # without duplicating the modal chrome above.
+        def render_interactive_action_form
+          render partial(interactive_action_form_partial)
+        end
+
+        def interactive_action_form_partial = "interactive_action_form"
+
         def page_type = :interactive_action_page
       end
     end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Page
+      # Modal page shown when a card is dropped into a column that declares a
+      # `enter_interaction:`. It reuses the interactive-action modal chrome
+      # (title/description/modal mode all come from the enter_interaction's
+      # auto-registered record action) but renders a form that POSTs to the
+      # `kanban_move` member route instead of the interaction's own commit URL,
+      # carrying the move context (from_column/to_column/to_index) as hidden
+      # fields alongside the interaction's own inputs.
+      class KanbanMove < InteractiveAction
+        private
+
+        def interactive_action_form_partial = "kanban_move_action_form"
+      end
+    end
+  end
+end

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

@@ -15,7 +15,7 @@ module Plutonium
         end
 
         def page_actions
-          super || current_definition.defined_actions.values.select { |a| a.record_action? && a.permitted_by?(current_policy) && a.condition_met?(view_context, record: resource_record!) }
+          super || current_definition.defined_actions.values.select { |a| a.record_action? && !a.kanban_drop? && a.permitted_by?(current_policy) && a.condition_met?(view_context, record: resource_record!) }
         end
 
         def render_default_content
@@ -48,7 +48,12 @@ module Plutonium
             size: :lg,
             open_full_url: request.path
           ) do
-            render partial("resource_details")
+            # The modal body owns no padding — content provides its own (the
+            # form uses this same padded, scrollable region). Without it the
+            # detail cards sit flush against the modal edges.
+            div(class: "flex-1 min-h-0 overflow-y-auto px-6 py-5") do
+              render partial("resource_details")
+            end
           end
         end
 

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

@@ -151,7 +151,7 @@ module Plutonium
               policy = policy_for(record:)
 
               actions = resource_definition.defined_actions
-                .select { |k, a| a.collection_record_action? && policy.allowed_to?(:"#{k}?") && a.condition_met?(view_context, record:) }
+                .select { |k, a| a.collection_record_action? && !a.kanban_drop? && policy.allowed_to?(:"#{k}?") && a.condition_met?(view_context, record:) }
                 .values
 
               primary_actions = actions.select { |a| a.category.primary? }.sort_by(&:position)

data/lib/plutonium/ui/wizard/summary_display.rb

@@ -33,11 +33,44 @@ module Plutonium
           input_options = @summary_inputs[name]&.dig(:options) || {}
           field_options = input_options[:label] ? {label: input_options[:label]} : {}
 
+          # A currency input stages a plain decimal; the data snapshot carries no
+          # has_cents reflection, so inference would render it as a bare number.
+          # Force the currency display and thread the declared `unit:` so the
+          # recap reads "$1,234.56", matching the input's prefix.
+          if input_options[:as]&.to_sym == :currency
+            return render field(name, **field_options).wrapped { |f|
+              render f.send(:create_component, Plutonium::UI::Display::Components::Currency, :currency, unit: input_options[:unit])
+            }
+          end
+
+          # A choice input (select/radio_buttons) stages the raw value; its
+          # value -> label map lives only in `choices:`. Resolve it and render the
+          # label as a string, rather than inferring a plain-string tag off the
+          # raw value (which would show "female" instead of "Female").
+          if input_options[:choices]
+            label = resolve_choice_label(name, input_options)
+            return render field(name, value: label, **field_options).wrapped { |f| render f.string_tag }
+          end
+
           render field(name, **field_options).wrapped do |f|
             render instance_exec(f, &summary_tag_block(name))
           end
         end
 
+        # Map the raw value(s) to their choice label(s) using the SAME mapper the
+        # form's select uses, so summary labels always match the form. Falls back
+        # to the raw value for anything not in `choices:`; nil for an empty field
+        # (so the display renders its placeholder).
+        def resolve_choice_label(name, input_options)
+          mapper = Phlexi::Form::SimpleChoicesMapper.new(
+            input_options[:choices],
+            label_method: input_options[:label_method],
+            value_method: input_options[:value_method]
+          )
+          raw = Phlexi::Field::Support::Value.from(object, name)
+          Array(raw).map { |value| mapper[value] || value }.join(", ").presence
+        end
+
         # Pick the display component the same way a resource display does — infer it
         # from the value's TYPE (date, boolean, number, currency, …) instead of
         # stringifying everything. The one override: an attachment field stages a

data/lib/plutonium/version.rb

@@ -1,5 +1,5 @@
 module Plutonium
-  VERSION = "0.61.0"
+  VERSION = "0.62.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.61.0",
+  "version": "0.62.0",
   "description": "Build production-ready Rails apps in minutes, not days. Convention-driven, fully customizable, AI-ready.",
   "type": "module",
   "main": "src/js/core.js",
@@ -49,6 +49,7 @@
     "postcss-import": "^16.1.1",
     "tailwindcss": "^4.3.0",
     "vitepress": "^1.6.4",
+    "vitepress-plugin-llms": "^1.13.2",
     "vitepress-plugin-mermaid": "^2.0.17"
   },
   "scripts": {
@@ -59,8 +60,9 @@
     "js:dev": "node esbuild.config.js --dev",
     "css:prod": "postcss src/css/plutonium.entry.css -o app/assets/plutonium.css && postcss src/css/plutonium.entry.css -o src/dist/css/plutonium.css",
     "js:prod": "node esbuild.config.js",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
+    "docs:sync-skills": "node docs/.vitepress/sync-skills.mjs",
+    "docs:dev": "yarn docs:sync-skills && vitepress dev docs",
+    "docs:build": "yarn docs:sync-skills && vitepress build docs",
     "docs:preview": "vitepress preview docs"
   }
 }

data/src/css/components.css

@@ -635,6 +635,11 @@ select.pu-input[multiple] option {
    own pinned-right surface and intentionally does not opt in. */
 .pu-dialog {
   background-color: var(--pu-surface);
+  /* Pair the surface background with the theme text colour. The UA stylesheet
+     resets <dialog> color to CanvasText (black) and it does NOT inherit from
+     <body>, so without this any unstyled text inside a modal (e.g. a show page's
+     plain field values) renders black on the dark surface. */
+  color: var(--pu-text);
   border: 1px solid var(--pu-border);
   border-radius: var(--pu-radius-lg);
 }

data/src/js/controllers/currency_input_controller.js

@@ -0,0 +1,39 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Connects to data-controller="currency-input"
+//
+// Pads a currency input's left edge to exactly clear its overlaid unit prefix.
+//
+// The prefix ("$", "£", "GH₵", "USD", …) is absolutely positioned at the
+// field's left edge; its width varies by symbol AND font, so any fixed padding
+// is wrong for some currency — too little clips a wide prefix (digits collide
+// with it, as with "GH₵"), too much wastes space on a bare "$". This measures
+// the rendered prefix and sets padding-left to match, so the caret always sits
+// just past the symbol regardless of currency or typeface.
+//
+// DOM contract:
+//   wrapper  data-controller="currency-input"
+//   prefix   data-currency-input-target="prefix"   (the overlaid unit span)
+//   input    data-currency-input-target="field"    (the number input)
+export default class extends Controller {
+  static targets = ["prefix", "field"]
+  // Space between the prefix and the first digit, in px.
+  static values = { gap: { type: Number, default: 6 } }
+
+  connect() {
+    this.#pad()
+    // Web fonts often load after connect; the fallback font's metrics differ,
+    // so re-measure once they're ready to correct the padding.
+    document.fonts.ready.then(() => this.#pad())
+  }
+
+  #pad() {
+    // Inline !important so it beats pu-input's own left padding (a plain class
+    // would lose the cascade — see the note this replaces in currency.rb).
+    this.fieldTarget.style.setProperty(
+      "padding-left",
+      `${this.prefixTarget.offsetWidth + this.gapValue}px`,
+      "important"
+    )
+  }
+}