plutonium 0.54.0 → 0.55.0

data/docs/superpowers/plans/2026-06-02-structured-inputs.md.tasks.json

@@ -0,0 +1,60 @@
+{
+  "planPath": "docs/superpowers/plans/2026-06-02-structured-inputs.md",
+  "tasks": [
+    {
+      "id": 0,
+      "subject": "Task 0: Shared structured_input DSL + registry",
+      "status": "completed",
+      "description": "Shared concern: structured_input DSL, defined_structured_inputs registry (inherited), FieldsDefinition holder; included in resource Definition::Base.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/definition/structured_inputs.rb\", \"lib/plutonium/definition/base.rb\", \"test/plutonium/definition/structured_inputs_test.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/plutonium/definition/structured_inputs_test.rb\", \"acceptanceCriteria\": [\"structured_input registers in defined_structured_inputs with block\", \"fields holder exposes declared inputs\", \"repeat/limit options captured\", \"subclasses inherit registry\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 1,
+      "subject": "Task 1: Shared param cleaner",
+      "status": "completed",
+      "description": "Pure ParamCleaner: single hash (strip _destroy) / repeater array (normalize array|index-hash, drop all-blank, strip _destroy).\n\n```json:metadata\n{\"files\": [\"lib/plutonium/structured_inputs/param_cleaner.rb\", \"test/plutonium/structured_inputs/param_cleaner_test.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/plutonium/structured_inputs/param_cleaner_test.rb\", \"acceptanceCriteria\": [\"single passes hash through, strips _destroy\", \"repeater normalizes array and index-hash\", \"drops all-blank rows\", \"blank to {} or []\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 2,
+      "subject": "Task 2: Interaction host — attribute + remove nested surface",
+      "status": "completed",
+      "blockedBy": [0],
+      "description": "On interactions structured_input declares the backing attribute ({} single / [] repeat); remove nested_input + accepts_nested_attributes_for; delete nested_attributes.rb.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/interaction/base.rb\", \"lib/plutonium/interaction/nested_attributes.rb\", \"test/plutonium/interaction/structured_inputs_test.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/plutonium/interaction/structured_inputs_test.rb\", \"acceptanceCriteria\": [\"structured_input declares attribute with {} / [] default\", \"defaults not shared across instances\", \"nested_input/accepts_nested_attributes_for/defined_nested_inputs removed from interactions\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 3,
+      "subject": "Task 3: Rendering — RendersStructuredInputs + form branch",
+      "status": "completed",
+      "blockedBy": [0],
+      "description": "RendersStructuredInputs concern: single via nest_one (one fieldset), repeater via nest_many (repeater chrome), classless, as: name. Branch render_resource_field in resource.rb. Full HTML assertions in Task 6.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/ui/form/concerns/renders_structured_inputs.rb\", \"lib/plutonium/ui/form/resource.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/plutonium/ui/form/hidden_input_test.rb\", \"acceptanceCriteria\": [\"render_resource_field dispatches structured inputs first\", \"single renders one fieldset, no chrome\", \"repeater renders controller container + template + add/delete\", \"no hidden id/_destroy\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 4,
+      "subject": "Task 4: Param flow — apply cleaner on both hosts",
+      "status": "completed",
+      "blockedBy": [0, 1],
+      "description": "ParamsConcern#clean_structured_inputs(definition, params) keyed off defined_structured_inputs; applied in submitted_resource_params and submitted_interaction_params.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/structured_inputs/params_concern.rb\", \"lib/plutonium/resource/controller.rb\", \"lib/plutonium/resource/controllers/interactive_actions.rb\", \"test/plutonium/structured_inputs/params_concern_test.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/plutonium/structured_inputs/params_concern_test.rb\", \"acceptanceCriteria\": [\"clean_structured_inputs rewrites only structured keys\", \"applied in submitted_resource_params\", \"applied in submitted_interaction_params\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 5,
+      "subject": "Task 5: Dummy fixtures (generators)",
+      "status": "completed",
+      "blockedBy": [0, 2, 3],
+      "description": "Via pu:* generators: a catalog resource with json columns + structured_input (single + repeat) + policy permit + admin route; an interaction with single + repeat structured_input wired as an action.\n\n```json:metadata\n{\"files\": [\"test/dummy/packages/catalog/app/definitions/catalog/spec_definition.rb\", \"test/dummy/packages/catalog/app/policies/catalog/spec_policy.rb\", \"test/dummy/packages/catalog/app/interactions/catalog/collect_spec.rb\", \"test/dummy/packages/admin_portal/config/routes.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/integration/admin_portal/resources_test.rb\", \"acceptanceCriteria\": [\"resource with json columns + structured_input\", \"interaction with single + repeat structured_input wired as action\", \"migrations run, app boots\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 6,
+      "subject": "Task 6: Integration tests — render + round-trip (both hosts)",
+      "status": "completed",
+      "blockedBy": [3, 4, 5],
+      "description": "Render + persistence round-trip for single + repeater on resources (JSON column) and interactions (attribute to execute). Contract source of truth for the as: naming.\n\n```json:metadata\n{\"files\": [\"test/integration/admin_portal/structured_input_rendering_test.rb\", \"test/integration/admin_portal/structured_input_roundtrip_test.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/integration/admin_portal/structured_input_rendering_test.rb\", \"acceptanceCriteria\": [\"single + repeater render with correct nested names, no hidden id/_destroy\", \"create persists hash + cleaned array to json columns\", \"interaction execute receives hash + array\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 7,
+      "subject": "Task 7: Full regression + docs",
+      "status": "completed",
+      "blockedBy": [6],
+      "description": "Full suite + cross-version spot checks; rework interaction README to structured_input; document structured_input; update skill docs referencing interaction nested_input.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/interaction/README.md\", \"docs/\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 rake test\", \"acceptanceCriteria\": [\"full suite green\", \"README/docs document structured_input and the interaction removals\"], \"requiresUserVerification\": false}\n```"
+    }
+  ],
+  "lastUpdated": "2026-06-02"
+}

data/docs/superpowers/specs/2026-06-01-structured-inputs-design.md

@@ -0,0 +1,191 @@
+# Structured Inputs
+
+**Date:** 2026-06-01 (updated 2026-06-02)
+**Status:** Approved — DSL name `structured_input` final; ready for implementation plan
+
+## Problem
+
+There is no first-class way to collect a **structured input** — a group of
+fields gathered into one object, or a variable-length list of such objects —
+without an ActiveRecord association behind it:
+
+- **Interactions** declare scalar `attribute`s only. They cannot collect a
+  structured object (`address => {street:, city:}`) or a list of them. The
+  included `nested_input` is model-backed and silently renders nothing for the
+  classless case (characterized in
+  `test/plutonium/ui/form/interaction_nested_input_test.rb`).
+- **Resources** can edit a JSON/jsonb column only as a raw JSON textarea or a
+  flat `key_value_store` — no structured UI for `{a, b}` or `[{a, b}, …]` stored
+  in a JSON column. Association-backed repetition is `nested_input`'s job; JSON
+  columns have nothing.
+
+## Goal
+
+One DSL — **`structured_input`** — for a *classless* group of fields, collected
+as:
+
+- a **hash** (single object) by default, or
+- an **array of hashes** when `repeat:` is given (the repeater),
+
+rendered with a fields group, and feeding either an **interaction attribute** or
+a **resource JSON column**. The single object is the base; the repeater is the
+same group rendered N times.
+
+### Non-goals
+
+- Type coercion of values. Rows/objects are plain hashes; the host validates.
+- Replacing model-backed `nested_input` (stays the resource association feature).
+
+## Feasibility anchors
+
+This design follows the grain of phlexi-form rather than fighting it:
+
+1. **`nest_one` → hash, `nest_many` → array.** The library's own
+   `extract_input` already produces exactly these shapes, and `nest_many` is
+   literally `nest_one` repeated:
+
+   ```ruby
+   # Namespace#extract_input (nest_one):   { key => { field => value, … } }
+   # NamespaceCollection#extract_input (nest_many):
+   params = params[key]
+   params = params.values if params.is_a?(Hash)        # index-hash → array, free
+   { key => Array(params).map { |p| namespace.extract_input([p]) } }
+   ```
+
+2. **Hash-backed rendering.** `Phlexi::Field::Support::Value.from` reads
+   `object[key]` for a `Hash`, so a row/object is a plain hash and the blank
+   template is `{}`. No synthesized classes.
+
+3. **Form-driven param extraction.** Plutonium extracts submitted resource
+   params via `build_form(record).extract_input(params)`
+   (`controller.rb#submitted_resource_params`). Nesting with `as: :<name>` makes
+   the extracted hash/array land under `:<name>`, which assigns **directly** to
+   the JSON column / interaction attribute — no `_attributes=` setter, no manual
+   strong-params.
+
+## Design
+
+### 1. The DSL — `structured_input`
+
+```ruby
+# single → hash
+structured_input :address do |f|
+  f.input :street
+  f.input :city
+end
+# value: address => { street:, city: }
+
+# repeater → array of hashes (max 10 rows)
+structured_input :contacts, repeat: 10 do |f|
+  f.input :label
+  f.input :phone_number
+end
+# value: contacts => [ { label:, phone_number: }, … ]
+```
+
+- `repeat:` semantics: **`repeat: <int>` = maximum rows**; `repeat: true` =
+  repeater with the default cap; **absent = single** (hash). Presence of
+  `repeat:` always means an array — `repeat: 1` is "array, max one row", *not*
+  the single form.
+- Fields come from a block or `using:`/`fields:` (the existing lightweight
+  `NestedInputsDefinition` holder, `defineable_props :field, :input`).
+- Registers config in a `defined_structured_inputs` registry, via a shared
+  module included by both resource definitions (`Plutonium::Definition::Base`)
+  and interactions (`Plutonium::Interaction::Base`) — both already mix in
+  `DefineableProps`.
+
+### 2. Rendering (shared, classless)
+
+The unit is the **fields group** — the declared inputs rendered over a nested
+builder. Single and repeater differ only in `nest_one` vs `nest_many` and the
+surrounding chrome:
+
+- **Single:** `nest_one(:address, as: :address)` over the current value (or `{}`)
+  → one fieldset of inputs. No add/remove chrome, no `<template>`, no hidden
+  `id`/`_destroy`.
+- **Repeater:** `nest_many(:contacts, as: :contacts)` → the existing repeater
+  chrome (the `nested-resource-form-fields` Stimulus controller, `limit` = the
+  `repeat` cap, a `<template>` holding a blank `{}` row, existing rows from the
+  array value, an add button, a per-row delete control). No hidden `id`/`_destroy`.
+
+This reuses the same Stimulus controller and visual structure as the model-backed
+repeater, but is a **separate classless code path**. Model-backed `nested_input`
+rendering is untouched (still covered by
+`test/integration/admin_portal/nested_form_rendering_test.rb`).
+
+### 3. Param flow (shared)
+
+- Nesting with `as: :<name>` → `extract_input` yields `{name => {…}}` (single) or
+  `{name => [{…}, …]}` (repeater, index-hash already normalized to array).
+- The value assigns **directly** to the JSON column / interaction attribute.
+- A shared **clean step**, keyed off `defined_structured_inputs`, runs
+  post-extract: for repeaters, drop all-blank rows and strip `_destroy`; single
+  passes through. Rows are positional — **no ids**.
+
+### 4. Host — interactions
+
+`structured_input :name` declares `attribute :name` defaulting to `{}` (single)
+or `[]` (repeater). The extracted+cleaned value flows into the attribute;
+`execute` sees a hash or an array.
+
+### 5. Host — resources (JSON, no model macro)
+
+Because it is classless, the resource side needs **no `accepts_nested_attributes_for`-style
+model declaration** — just:
+
+- **Model:** a `json`/`jsonb` column named `name`.
+- **Definition:** `structured_input :name …`.
+- **Policy:** permit `:name` in `permitted_attributes_for_*` so the form renders
+  it.
+
+Params then flow via the form's `extract_input` → clean → `record.name = hash/array`
+→ persisted in the JSON column. The `nested_input` model/definition split
+dissolves here; classless JSON needs only the column + the definition DSL.
+
+### 6. Remove the broken nested surface from interactions
+
+- `nested_input` is **removed** from interactions (`Interaction::Base` stops
+  mixing in `Plutonium::Definition::NestedInputs`) → `NoMethodError` at
+  class-load. `defined_nested_inputs` is likewise undefined; the inherited form
+  branch is guarded by `respond_to?` and simply skips.
+- `accepts_nested_attributes_for` is **removed** from interactions
+  (`Interaction::Base` stops mixing in `Plutonium::Interaction::NestedAttributes`).
+  Build models explicitly in `execute` if ever needed.
+
+Resources keep both model-backed `nested_input` and AR `accepts_nested_attributes_for`
+unchanged, and additionally gain `structured_input`.
+
+## Testing
+
+- **Clean step** (unit): array and index-keyed-hash → array; all-blank rows
+  dropped; `_destroy` stripped; single passes through; no ids.
+- **Single** (interaction + resource): renders one fieldset; round-trip → a hash
+  value on the attribute / JSON column.
+- **Repeater** (interaction + resource): renders the repeater chrome with
+  `host[contacts][NEW_RECORD][label]` naming, add/delete, no hidden id/`_destroy`;
+  round-trip → an array value; blank rows rejected; edit repopulates.
+- **Guard** (unit): interactions do not respond to `nested_input` /
+  `accepts_nested_attributes_for` / `defined_nested_inputs` (replaces the current
+  `interaction_nested_input_test.rb`).
+- **Regression**: resource `nested_input` unchanged — existing characterization
+  tests stay green.
+- Fixtures via the `pu:*` generators; the resource fixture uses a JSON column.
+
+## Open questions (resolve in plan)
+
+- **Clean-step placement:** one shared function, two call sites (the resource
+  controller param path; the interaction's param assignment). Confirm the exact
+  hooks.
+- **Field naming:** `as: :<name>` (direct assignment, recommended) vs a
+  `_attributes` suffix. Verify no collision with form/extract internals.
+- **JSON column type in the dummy fixture:** SQLite `json`/serialized text for
+  the test; document `jsonb` as the production recommendation.
+
+## Risk / breaking change
+
+- Removing `nested_input` + `accepts_nested_attributes_for` from interactions is
+  a deliberate breaking change; the only previously-working case (an interaction
+  mirroring a real resource association) is redundant with resource forms.
+  Offenders get a `NoMethodError` naming the method; the README is reworked to
+  `structured_input`.
+- `structured_input` is additive on resources and new on interactions.

data/gemfiles/rails_8.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.53.1)
+    plutonium (0.54.0)
       action_policy (~> 0.7.0)
       listen (~> 3.8)
       pagy (~> 43.0)

data/lib/plutonium/definition/base.rb

@@ -33,6 +33,7 @@ module Plutonium
       include Scoping
       include Search
       include NestedInputs
+      include StructuredInputs
       include IndexViews
       include Metadata
 

data/lib/plutonium/definition/structured_inputs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Definition
+    # Classless structured inputs: a group of fields collected into a hash
+    # (single) or an array of hashes (when `repeat:` is given). Mixed into both
+    # resource definitions and interactions.
+    #
+    # @example
+    #   structured_input :address do |f|
+    #     f.input :street
+    #     f.input :city
+    #   end
+    #
+    #   structured_input :contacts, repeat: 10 do |f|
+    #     f.input :label
+    #     f.input :phone_number
+    #   end
+    module StructuredInputs
+      extend ActiveSupport::Concern
+
+      # Holder built per render from a structured_input block. Reuses the same
+      # field/input DSL as the rest of Plutonium definitions.
+      class FieldsDefinition
+        include Plutonium::Definition::DefineableProps
+
+        defineable_props :field, :input
+      end
+
+      class_methods do
+        # @option options [Integer, true] :repeat  presence => array; Integer => max rows
+        # @option options [Class] :using  a FieldsDefinition-like class instead of a block
+        # @option options [Array<Symbol>] :fields  restrict rendered fields
+        def structured_input(name, **options, &block)
+          unless block || options[:using]
+            raise ArgumentError,
+              "`structured_input :#{name}` needs a block or `using:` — e.g. " \
+              "`structured_input :#{name} do |f| f.input :field end` or " \
+              "`structured_input :#{name}, using: #{name.to_s.classify}Fields`"
+          end
+
+          defined_structured_inputs[name] = {options:, block:}.compact
+        end
+
+        def defined_structured_inputs
+          @defined_structured_inputs ||= {}
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(
+            :@defined_structured_inputs,
+            defined_structured_inputs.deep_dup
+          )
+        end
+      end
+
+      # Instance access mirrors the defineable_prop convention (where
+      # `defined_<plural>` is available on instances). The form's render path and
+      # the param cleaner both hold a definition instance, so they read the
+      # registry through here.
+      def defined_structured_inputs
+        self.class.defined_structured_inputs
+      end
+    end
+  end
+end

data/lib/plutonium/interaction/README.md

@@ -262,71 +262,21 @@ class MyInteraction < Plutonium::Interaction::Base
 end
 ```
 
-### Interactions with Nested Attributes
+### Interactions with Structured Input
 
-This example demonstrates how to handle nested attributes—specifically,
-a `User` with multiple `Contact` and `UserAddress` records using
-a Plutonium `Interaction`.
+> **Note:** `nested_input` and `accepts_nested_attributes_for` are **not**
+> available on interactions. They are resource-only features that work with
+> model-backed `has_many`/`has_one` associations. For collecting structured or
+> repeating input inside an interaction, use `structured_input` instead.
 
-#### Key Highlights
+`structured_input` declares an attribute on the interaction and renders an
+inline fieldset in the auto-generated form. It comes in two forms:
 
-The model definitions are included here for completeness, but the primary focus
-remains on demonstrating how to build interactions that handle nested
-attributes.
-
-- Core user attributes (`first_name`, `last_name`, `email`) are declared and
-  validated at the top level of the interaction.
-
-- Nested associations (`contacts`, `addresses`) are managed via
-  `accepts_nested_attributes_for`. The optional `reject_if` condition is used
-  to discard entries that lack required fields—helping ensure data integrity at
-  the input level.
-
-- The `nested_input` DSL provides a declarative way to structure nested inputs,
-  specifying accepted fields and mapping them to their respective definition
-  classes (`ContactDefinition` and `UserAddressDefinition`).
-
-- During execution, a `User` instance is initialized with both top-level and
-  nested attributes, then persisted with all applicable validations.
-
-**Note:** The `class_name` option is explicitly defined in the interaction's
-`accepts_nested_attributes_for` macro because the `addresses` association does
-not directly map to its underlying model name. Simply provide the class name,
-for example, `class_name: "UserAddress"`, to ensure the correct model is used.
-
-**This is essential only when the association name differs from the actual
-class name.**
-
-This approach enables seamless handling of complex nested input from forms or
-API requests, while keeping validation logic clean, maintainable, and modular.
+- **Single** — the attribute arrives in `execute` as a plain `Hash`.
+- **Repeat** — the attribute arrives as an `Array` of hashes (capped at the
+  given number of rows; `repeat: true` defaults to 10).
 
 ```ruby
-# app/models/user.rb
-class User < ApplicationRecord
-  include Plutonium::Resource::Record
-
-  has_many :contacts
-  has_many :addresses, class_name: "UserAddress"
-
-  accepts_nested_attributes_for :contacts, :addresses
-end
-
-# app/models/contact.rb
-class Contact < ApplicationRecord
-  include Plutonium::Resource::Record
-
-  belongs_to :user
-  validates :label, :phone_number, presence: true
-end
-
-# app/models/user_address.rb
-class UserAddress < ApplicationRecord
-  include Plutonium::Resource::Record
-
-  belongs_to :user
-  validates :label, :map_url, presence: true
-end
-
 # app/interactions/users/interactions/create_user_interaction.rb
 module Users
   module Interactions
@@ -338,37 +288,33 @@ module Users
       attribute :first_name, :string
       attribute :last_name, :string
       attribute :email, :string
-      attribute :contacts
-      attribute :addresses
 
       validates :first_name, :last_name, presence: true
       validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
 
-      accepts_nested_attributes_for :contacts,
-        reject_if: proc { |attributes| attributes[:label].blank? }
-
-      accepts_nested_attributes_for :addresses, class_name: "UserAddress",
-        reject_if: proc { |attributes| attributes[:label].blank? }
-
-      nested_input :contacts,
-        using: ContactDefinition,
-        fields: %i[label phone_number],
-        description: "Add one or more contacts for this user."
+      # single → a hash
+      structured_input :address do |f|
+        f.input :street
+        f.input :city
+      end
 
-      nested_input :addresses,
-        using: UserAddressDefinition,
-        fields: %i[label map_url],
-        description: "Add one or more addresses for this user."
+      # repeater → an array of hashes (max 5 rows)
+      structured_input :contacts, repeat: 5 do |f|
+        f.input :label
+        f.input :phone_number
+      end
 
       private
 
       def execute
-        user = User.new(self.attributes)
+        # address  => { "street" => "...", "city" => "..." }
+        # contacts => [ { "label" => "...", "phone_number" => "..." }, ... ]
+        user = User.new(first_name: first_name, last_name: last_name, email: email)
 
         if user.save
           success(user).with_message("User created successfully")
         else
-          failed(user.errors)
+          failure(user.errors)
         end
       end
     end

data/lib/plutonium/interaction/base.rb

@@ -25,8 +25,16 @@ module Plutonium
       include Plutonium::Definition::DefineableProps
       include Plutonium::Definition::ConfigAttr
       include Plutonium::Definition::Presentable
-      include Plutonium::Definition::NestedInputs
-      include Plutonium::Interaction::NestedAttributes
+      include Plutonium::Definition::StructuredInputs
+
+      # On interactions, declaring a structured input also declares the backing
+      # ActiveModel attribute so the value survives `attributes=` and appears in
+      # `attribute_names` (which drives the interaction form's field list).
+      def self.structured_input(name, **options, &block)
+        super
+        default = options[:repeat] ? -> { [] } : -> { {} }
+        attribute name, default: default
+      end
 
       # include Plutonium::Interaction::Concerns::WorkflowDSL
 

data/lib/plutonium/resource/controller.rb

@@ -16,6 +16,7 @@ module Plutonium
       include Plutonium::Resource::Controllers::CrudActions
       include Plutonium::Resource::Controllers::InteractiveActions
       include Plutonium::Resource::Controllers::Typeahead
+      include Plutonium::StructuredInputs::ParamsConcern
 
       included do
         after_action { response.headers.merge!(@pagy.headers_hash) if @pagy }
@@ -144,7 +145,11 @@ module Plutonium
         # Use existing record (cloned) for context during param extraction, or new instance for create
         # Pass form_action: false to prevent form from trying to generate URL (cloned record has id: nil)
         extraction_record = resource_record?&.dup || resource_class.new
-        @submitted_resource_params ||= build_form(extraction_record, form_action: false).extract_input(params, view_context:)[resource_param_key.to_sym].compact
+        @submitted_resource_params ||= begin
+          extracted = build_form(extraction_record, form_action: false)
+            .extract_input(params, view_context:)[resource_param_key.to_sym].compact
+          clean_structured_inputs(current_definition, extracted)
+        end
       end
 
       # Returns the resource parameters, including scoped and parent parameters

data/lib/plutonium/resource/controllers/interactive_actions.rb

@@ -3,6 +3,7 @@ module Plutonium
     module Controllers
       module InteractiveActions
         extend ActiveSupport::Concern
+        include Plutonium::StructuredInputs::ParamsConcern
 
         included do
           helper_method :current_interactive_action
@@ -239,13 +240,16 @@ module Plutonium
           @interaction
         end
 
-        # Returns the submitted resource parameters
-        # @return [Hash] The submitted resource parameters
+        # Returns the submitted interaction parameters
+        # @return [Hash] The submitted interaction parameters
         def submitted_interaction_params
-          @submitted_interaction_params ||= current_interactive_action
-            .interaction
-            .build_form(current_interactive_action.interaction.new(view_context:))
-            .extract_input(params, view_context:)[:interaction]
+          @submitted_interaction_params ||= begin
+            interaction = current_interactive_action.interaction
+            extracted = interaction
+              .build_form(interaction.new(view_context:))
+              .extract_input(params, view_context:)[:interaction]
+            clean_structured_inputs(interaction, extracted)
+          end
         end
 
         def redirect_url_after_action_on(resource_record_or_resource_class)

data/lib/plutonium/structured_inputs/param_cleaner.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module StructuredInputs
+    # Normalises an extracted structured-input value before it is stored.
+    #
+    # The form's `extract_input` already yields a `Hash` (single) or an
+    # `Array<Hash>` (repeater), so the only work left is to symbolise keys and,
+    # for repeaters, drop rows the user left entirely blank.
+    module ParamCleaner
+      module_function
+
+      # @param value [Hash, Array, nil] the extracted param for this input
+      # @param repeat [Boolean, Integer] truthy => array (repeater), else hash
+      # @return [Hash, Array<Hash>]
+      def call(value, repeat:)
+        repeat ? clean_collection(value) : clean_one(value)
+      end
+
+      def clean_one(value)
+        value.is_a?(Hash) ? symbolize(value) : {}
+      end
+
+      def clean_collection(value)
+        Array(value)
+          .select { |row| row.is_a?(Hash) }
+          .map { |row| symbolize(row) }
+          .reject { |row| row.values.all? { |v| v.to_s.strip.empty? } }
+      end
+
+      def symbolize(row)
+        row.to_h.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/plutonium/structured_inputs/params_concern.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module StructuredInputs
+    # Rewrites structured-input params in place through ParamCleaner. Shared by
+    # the resource controller and the interactive-actions controller.
+    module ParamsConcern
+      # @param definition a definition instance (resource) or class (interaction)
+      #   exposing `defined_structured_inputs`
+      # @param params [Hash] extracted form params (mutable copy)
+      # @return [Hash]
+      def clean_structured_inputs(definition, params)
+        registry = structured_inputs_registry(definition)
+        return params unless registry
+
+        registry.each do |name, entry|
+          next unless params.key?(name)
+
+          repeat = entry[:options]&.fetch(:repeat, false)
+          params[name] = Plutonium::StructuredInputs::ParamCleaner.call(params[name], repeat:)
+        end
+        params
+      end
+
+      private
+
+      def structured_inputs_registry(definition)
+        if definition.respond_to?(:defined_structured_inputs)
+          definition.defined_structured_inputs
+        elsif definition.class.respond_to?(:defined_structured_inputs)
+          definition.class.defined_structured_inputs
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/concerns/renders_nested_resource_fields.rb

@@ -10,7 +10,7 @@ module Plutonium
         module RendersNestedResourceFields
           extend ActiveSupport::Concern
 
-          DEFAULT_NESTED_LIMIT = 10
+          DEFAULT_NESTED_LIMIT = RepeaterFieldStyles::DEFAULT_LIMIT
           NESTED_OPTION_KEYS = [:allow_destroy, :update_only, :macro, :class].freeze
           SINGULAR_MACROS = %i[belongs_to has_one].freeze
 
@@ -193,7 +193,7 @@ module Plutonium
           def render_nested_fields_fieldset(nested, context)
             fieldset(
               data_new_record: !nested.object&.persisted?,
-              class: "nested-resource-form-fields border border-[var(--pu-border)] rounded-[var(--pu-radius-md)] p-4 space-y-4 relative"
+              class: RepeaterFieldStyles::FIELDSET_CLASS
             ) do
               render_nested_fields_fieldset_content(nested, context)
               render_nested_fields_delete_button(nested, context.options)
@@ -201,7 +201,7 @@ module Plutonium
           end
 
           def render_nested_fields_fieldset_content(nested, context)
-            div(class: "grid grid-cols-1 md:grid-cols-2 2xl:grid-cols-4 gap-4 grid-flow-row-dense") do
+            div(class: RepeaterFieldStyles::FIELD_GRID_CLASS) do
               render_nested_fields_hidden_fields(nested, context)
               render_nested_fields_visible_fields(nested, context)
             end