plutonium 0.59.0 → 0.60.0

data/docs/superpowers/plans/2026-06-14-form-sectioning.md.tasks.json

@@ -0,0 +1,40 @@
+{
+  "planPath": "docs/superpowers/plans/2026-06-14-form-sectioning.md",
+  "tasks": [
+    {
+      "id": 1,
+      "subject": "Task 1: FormLayout DSL module + registry",
+      "status": "completed",
+      "description": "Add form_layout/section/ungrouped DSL + ordered inheritable registry + validations; include in Definition::Base and Interaction::Base.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/definition/form_layout.rb\", \"lib/plutonium/definition/base.rb\", \"lib/plutonium/interaction/base.rb\", \"test/plutonium/definition/form_layout_test.rb\", \"test/plutonium/interaction/form_layout_test.rb\"], \"verifyCommand\": \"bin/rails test test/plutonium/definition/form_layout_test.rb test/plutonium/interaction/form_layout_test.rb\", \"acceptanceCriteria\": [\"form_layout records sections in order\", \"section :ungrouped and duplicate ungrouped raise\", \"default label humanizes key\", \"subclasses inherit; redeclare replaces\", \"instance + interaction expose registry\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 2,
+      "subject": "Task 2: Resolve field list into ordered sections",
+      "status": "completed",
+      "blockedBy": [1],
+      "description": "Add resolve_form_sections(resource_fields): assign fields (first-section-wins, order preserved), leftovers to ungrouped (default first / declared position), raise on unknown keys, keep empty sections.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/definition/form_layout.rb\", \"test/plutonium/definition/form_layout_resolution_test.rb\"], \"verifyCommand\": \"bin/rails test test/plutonium/definition/form_layout_resolution_test.rb\", \"acceptanceCriteria\": [\"nil without layout\", \"fields assigned in order; leftovers to ungrouped\", \"ungrouped default-first / explicit-position\", \"unknown field raises\", \"empty sections kept (first-section-wins)\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 3,
+      "subject": "Task 3: Section chrome component + columns helper",
+      "status": "completed",
+      "blockedBy": [1],
+      "description": "Add Components::Section (heading/description, native <details> collapsible, grid by columns), yields field rendering to the form.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/ui/form/components/section.rb\", \"test/plutonium/ui/form/components/section_test.rb\"], \"verifyCommand\": \"bin/rails test test/plutonium/ui/form/components/section_test.rb\", \"acceptanceCriteria\": [\"heading + description render\", \"collapsible emits <details> with open/collapsed\", \"non-collapsible has no <details>\", \"grid_class applied and block content rendered\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 4,
+      "subject": "Task 4: Render sections in resource forms + integration",
+      "status": "completed",
+      "blockedBy": [2, 3],
+      "description": "Form::Resource#render_fields groups via resolver + Section component, evaluates condition in form context, falls back to single grid. Register KitchenSink in admin + add form_layout to KitchenSinkDefinition; integration test.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/ui/form/resource.rb\", \"test/dummy/app/definitions/kitchen_sink_definition.rb\", \"test/dummy/packages/admin_portal/config/routes.rb\", \"test/integration/admin_portal/form_layout_rendering_test.rb\"], \"verifyCommand\": \"bin/rails test test/integration/admin_portal/form_layout_rendering_test.rb test/integration/admin_portal\", \"acceptanceCriteria\": [\"sections + headings render and group fields\", \"collapsible emits <details>\", \"no layout -> single grid unchanged\", \"falsey condition hides section\"], \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 5,
+      "subject": "Task 5: Interaction forms render sections",
+      "status": "completed",
+      "blockedBy": [4],
+      "description": "Confirm interaction forms render form_layout sections (shared render_fields path). Add form_layout to a dummy interaction exercised by an org_portal test; assert grouped render.\n\n```json:metadata\n{\"files\": [\"test/integration/org_portal/form_layout_interaction_test.rb\"], \"verifyCommand\": \"bin/rails test test/integration/org_portal/form_layout_interaction_test.rb\", \"acceptanceCriteria\": [\"interaction form renders section headings\", \"interaction attribute input names unchanged\"], \"requiresUserVerification\": false}\n```"
+    }
+  ],
+  "lastUpdated": "2026-06-14T12:55:00Z"
+}

data/docs/superpowers/specs/2026-06-14-form-sectioning-design.md

@@ -0,0 +1,237 @@
+# Form Sectioning — Design
+
+**Date:** 2026-06-14
+**Status:** Approved (pending spec review)
+
+## Problem
+
+Plutonium forms render every field in a single responsive grid
+(`Form::Resource#render_fields` walks a flat `resource_fields` list inside one
+`fields_wrapper`). There is no way to group fields under headings ("Personal
+details", "Address", …). We want a clean DSL for *sectioning* forms that works
+for both resource definitions and interactions, without disturbing per-field
+configuration.
+
+## Constraints discovered in the codebase
+
+- **Field config lives in the definition** (`input :x, ...` via
+  `DefineableProps`, stored as ordered hashes), but the **set and order of
+  fields actually rendered come from the policy** (`permitted_attributes_for(action)`,
+  via `submittable_attributes_for`). The form receives that flat list as
+  `resource_fields`.
+- **Interactions reuse the resource form.** `Form::Interaction < Form::Resource`
+  and only swaps in `resource_fields` (from `interaction.attribute_names`) and
+  `resource_definition` (the interaction instance). So sectioning added to
+  `Form::Resource#render_fields` is inherited by interactions for free.
+- The shared definition DSL is composed from `Plutonium::Definition::*` concern
+  modules. `StructuredInputs` is the precedent for a module mixed into **both**
+  `Definition::Base` and `Interaction::Base`.
+
+Therefore: sectioning is a **presentation concern declared in the definition**
+that must group a **policy-driven** field list — skipping fields the policy
+filtered out and hiding sections that end up empty.
+
+## DSL
+
+A new shared module `Plutonium::Definition::FormLayout` provides `form_layout`.
+
+```ruby
+form_layout do
+  section :identity, :name, :date_of_birth, :grade,
+    label: "Your identification", description: "Basic info"
+
+  section :address, :street, :city, :country,
+    collapsible: true, columns: 2,
+    condition: -> { object.requires_address? }
+
+  ungrouped label: "Other", collapsible: true
+end
+```
+
+### `section(key, *fields, **opts)`
+
+- `key` — Symbol, the section's identity. Heading defaults to `key.to_s.humanize`.
+  `:ungrouped` is **reserved** for the macro below — `section :ungrouped, …`
+  raises `ArgumentError`.
+- `*fields` — ordered field keys placed in this section.
+- `**opts`:
+  - `label:` — overrides the humanized heading.
+  - `description:` — optional help line under the heading.
+  - `collapsible:` — Boolean (default `false`). Renders as a native
+    `<details>/<summary>` disclosure (no JS).
+  - `collapsed:` — Boolean (default `false`). Initial state when collapsible;
+    `false` ⇒ the `<details>` is `open`.
+  - `columns:` — Integer overriding the section's grid column count. Default
+    inherits the form's responsive grid.
+  - `condition:` — lambda evaluated in the **form instance context** (same
+    semantics as `input ..., condition:`; `object` and helpers available). A
+    falsey result renders nothing for the section.
+
+### `ungrouped(**opts)`
+
+- Configures the implicit bucket that auto-collects every permitted field not
+  claimed by a `section`. Takes **no field list**.
+- Accepts the same options as `section` (`label:`, `description:`,
+  `collapsible:`, `collapsed:`, `columns:`, `condition:`).
+- **Position:** where the macro is called sets where leftovers render. If the
+  macro is omitted, leftovers render **last** (appended after all declared
+  sections), with **no heading**. _(Amended — was "first"; see Amendments.)_
+- Calling `ungrouped` more than once in a single `form_layout` raises
+  `ArgumentError`.
+
+### Field configuration stays on `input`
+
+`form_layout`/`section` only reference field **keys** and carry **section-level**
+options. All per-field rendering config (`as:`, the field's own `label:`,
+`choices:`, per-field `condition:`, `pre_submit:`, blocks) remains on the `input`
+declaration. Layout never duplicates field config.
+
+### Inheritance / override
+
+- Re-declaring `form_layout` in a subclass **replaces** the parent layout as a
+  unit. Field-level `input` config continues to inherit normally.
+- The section registry is duplicated to subclasses on `inherited` (mirrors
+  `StructuredInputs`).
+
+### Backwards compatibility
+
+No `form_layout` declared ⇒ the current single-grid behavior is used unchanged.
+This is equivalent to one implicit, heading-less `ungrouped` region.
+
+## Rendering
+
+`Plutonium::Definition::FormLayout` exposes an ordered, frozen registry of
+section specs (and the `ungrouped` spec + its position) on definition and
+interaction instances.
+
+`Form::Resource#render_fields` becomes:
+
+1. **No layout** → existing path: one `fields_wrapper` over all `resource_fields`.
+2. **Layout present**:
+   - Assign each `section` its `fields ∩ resource_fields`, preserving the
+     section's declared field order.
+   - The `ungrouped` bucket gets `resource_fields` minus all claimed fields,
+     preserving `resource_fields` order.
+   - Build the ordered render list: sections in declared order with the
+     `ungrouped` bucket inserted at its declared position (default: **last**).
+   - For each entry: evaluate `condition` (skip if falsey); render a Section
+     component with its renderable fields. Empty sections are **not**
+     special-cased — they render with defaults (see Edge cases).
+
+Field rendering itself still goes through the existing `render_resource_field`,
+so all input types/components are unaffected.
+
+### Section component
+
+New `Plutonium::UI::Form::Components::Section` (Phlex). Responsibilities:
+
+- Wrapper + heading (`label`) + optional `description`.
+- When `collapsible`, wrap in native `<details>`/`<summary>` (`open` unless
+  `collapsed`), styled with Tailwind/`--pu-*` tokens.
+- A grid (`fields_wrapper`-style) whose column count comes from `columns:` when
+  given, else the existing responsive default
+  (`grid-cols-1 md:grid-cols-2 2xl:grid-cols-4`).
+- Yields to render the section's fields via `render_resource_field`.
+
+A small helper maps `columns:` → grid classes (e.g. `1 → "grid grid-cols-1 gap-6"`,
+`2 → "grid grid-cols-1 md:grid-cols-2 gap-6"`). Theme entries added for section
+heading/description/wrapper so they're themeable like the rest of the form.
+
+## Edge cases
+
+- **Field permitted but in no section** → falls into `ungrouped`.
+- **Section references a policy-filtered field** → that individual field is
+  skipped (no input is rendered for an unpermitted attribute).
+- **Empty section** (all fields filtered out, or none assigned) → **not
+  hidden**. It renders through the normal path with defaults (its default/declared
+  chrome). There is no automatic empty-hiding; to hide a section conditionally,
+  use `condition:`.
+- **Unknown field key in a `section`** (not an attribute at all) → raise at
+  render with a clear message (catches typos), consistent with how the form
+  already errors on unknown fields.
+- **`condition` falsey** → section renders nothing; its fields do **not** spill
+  into `ungrouped` (they remain owned by the suppressed section).
+- **No leftovers** → `ungrouped` renders with defaults (with no fields and no
+  configured heading, that is simply nothing visible; a configured `label:`
+  still renders).
+
+## Files
+
+- **New** `lib/plutonium/definition/form_layout.rb` — DSL module: `form_layout`
+  block builder, ordered + inheritable section registry, `section` / `ungrouped`,
+  instance readers, validation (duplicate `ungrouped`, etc.).
+- **Modify** `lib/plutonium/definition/base.rb` — `include FormLayout`.
+- **Modify** `lib/plutonium/interaction/base.rb` — `include FormLayout`.
+- **New** `lib/plutonium/ui/form/components/section.rb` — section component.
+- **Modify** `lib/plutonium/ui/form/resource.rb` — `render_fields` grouping; columns→grid helper.
+- **Modify** `lib/plutonium/ui/form/theme.rb` — section heading/description/wrapper tokens.
+
+## Testing (RSpec)
+
+- **DSL/registry:** sections recorded in order with options; `ungrouped` spec +
+  position; humanized default label; `label:` override; duplicate `ungrouped`
+  raises; `section :ungrouped` raises; inheritance duplicates registry;
+  re-declaring `form_layout` replaces.
+- **Assignment:** fields land in the right section in declared order; leftovers
+  collect into `ungrouped`; `ungrouped` default position is last; explicit
+  position honored.
+- **Filtering:** policy-filtered field is skipped; an empty section still renders
+  with defaults (is **not** hidden); unknown field key raises.
+- **Conditions:** falsey `condition` hides the section and withholds its fields.
+- **Rendering:** headings/descriptions present; collapsible emits
+  `<details>`/`<summary>` with correct `open`; `columns:` changes grid classes.
+- **Interactions:** an interaction with `form_layout` sections renders grouped
+  via `Form::Interaction`.
+- **Backwards-compat:** a definition with no `form_layout` renders the single
+  grid exactly as before.
+
+## Out of scope (YAGNI)
+
+- Applying sections to show/display pages or the index grid (forms only for now;
+  the same registry could later be reused by `Display::Resource`).
+- Nested sections / tabs.
+- Per-field layout hints (e.g. `field :notes, span: 2`) — Style 1 keeps fields
+  positional; this can be added later via the nested-block form if needed.
+- Stimulus-driven animated collapse (native `<details>` chosen for leanness).
+
+## Amendments (post-implementation)
+
+Changes made after the original plan landed:
+
+- **Implicit `ungrouped` placement: first → last.** When no `ungrouped` macro is
+  declared, leftover fields are now appended **after** all declared sections
+  (was: prepended). This matches the convention of the explicit macro ("the
+  rest" trails the sections you care about) and makes "omit it" equivalent to
+  "declare it last." To float leftovers above your sections, declare `ungrouped`
+  explicitly at the top.
+
+- **`columns:` actually lays out in a grid.** Previously every field wrapper got
+  `col-span-full`, so a section's `columns: N` had no visible effect. Fields in a
+  multi-column section now flow into single grid cells. A field that declares its
+  own span (`input :x, wrapper: {class: "col-span-..."}`) **always wins** — in any
+  section — so authors can opt a field back to full width (or wider) inside a
+  multi-column section.
+
+- **Dynamic section options.** Every section option except `columns:`
+  (`collapsed`, `collapsible`, `label`, `description`, plus the existing
+  `condition`) may be a **proc**, resolved at render time in the form instance
+  context — the same context as input/section `condition:` (so `object`,
+  `current_user`, `params`, helpers are available). The whole layout is resolved
+  once per render in `Form::Resource#resolve_form_layout` (visibility + option
+  evaluation in one pass); `render_form_section` is pure presentation. `columns:`
+  stays a validated literal (it feeds the grid class).
+
+- **Interactions: verified + exercised.** `Form::Interaction < Form::Resource`
+  already inherited the layout path; this is now covered by a dummy interaction
+  (`ReconfigureKitchenSink`, a record action on `KitchenSink`) and an integration
+  test. In an interaction form `object` is the interaction instance and
+  `object.resource` is the record, so record-aware dynamic options work there too
+  (e.g. `collapsed: -> { object.resource.archived? }`).
+
+- **Unrelated fix surfaced while driving the dummy in `development`:** the package
+  engine system (`Plutonium::Package::Engine`) called `Rails.application.initializers`
+  from a `before_configuration` hook, prematurely memoizing `Rails.application.railties`
+  and dropping package engines from the autoload paths when a second
+  `Rails::Application` (combustion, in dev) was instantiated before the packages
+  glob ran — surfacing as `uninitialized constant Blogging::Post`. The view-path
+  neutralization was moved to a real initializer (`before: :add_view_paths`).

data/gemfiles/rails_7.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.58.1)
+    plutonium (0.59.0)
       action_policy (~> 0.7.0)
       csv
       listen (~> 3.8)

data/gemfiles/rails_8.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.58.1)
+    plutonium (0.59.0)
       action_policy (~> 0.7.0)
       csv
       listen (~> 3.8)

data/gemfiles/rails_8.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.58.1)
+    plutonium (0.59.0)
       action_policy (~> 0.7.0)
       csv
       listen (~> 3.8)

data/lib/generators/pu/rodauth/admin_generator.rb

@@ -95,13 +95,16 @@ module Pu
       def create_invite_interaction
         template "app/interactions/invite_admin_interaction.rb",
           "app/interactions/#{normalized_name}/invite_interaction.rb"
+        template "app/interactions/resend_admin_interaction.rb",
+          "app/interactions/#{normalized_name}/resend_invite_interaction.rb"
 
         inject_into_file "app/definitions/#{normalized_name}_definition.rb",
-          "  action :invite, interaction: #{name.classify}::InviteInteraction, collection: true, category: :primary\n",
+          "  action :invite, interaction: #{name.classify}::InviteInteraction, collection: true, category: :primary\n" \
+          "  action :resend_invite, interaction: #{name.classify}::ResendInviteInteraction, record_action: true, category: :secondary\n",
           after: /class #{name.classify}Definition < .+\n/
 
         inject_into_file "app/policies/#{normalized_name}_policy.rb",
-          "def invite?\n    true\n  end\n\n  ",
+          "def invite?\n    true\n  end\n\n  def resend_invite?\n    record.unverified?\n  end\n\n  ",
           before: "# Core attributes"
       end
 

data/lib/generators/pu/rodauth/migration_generator.rb

@@ -20,7 +20,7 @@ module Pu
       desc "Generate migrations for supported features\n\n" \
            "Supported Features\n" \
            "=========================================\n" \
-           "#{MIGRATION_CONFIG.keys.sort.map(&:to_s).join "\n"}\n\n\n\n"
+           "#{MIGRATION_CONFIG.keys.sort.join "\n"}\n\n\n\n"
 
       class_option :features, required: true, type: :array,
         desc: "Rodauth features to create tables for (otp, sms_codes, single_session, account_expiration etc.)"

data/lib/generators/pu/rodauth/templates/app/interactions/resend_admin_interaction.rb.tt

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class <%= name.classify %>::ResendInviteInteraction < Plutonium::Resource::Interaction
+  presents label: "Resend Invitation", icon: Phlex::TablerIcons::MailForward
+
+  attribute :resource
+
+  def execute
+    unless resource.unverified?
+      return failed("Can only resend invitations to unverified accounts")
+    end
+
+    RodauthApp.rodauth(:<%= normalized_name %>).verify_account_resend(login: resource.email)
+    succeed(resource).with_message("Invitation resent to #{resource.email}")
+  rescue ::Rodauth::InternalRequestError => e
+    failed(e.message)
+  end
+end

data/lib/generators/pu/rodauth/views_generator.rb

@@ -13,7 +13,7 @@ module Pu
       desc "Generate views for selected features\n\n" \
            "Supported Features\n" \
            "=========================================\n" \
-           "#{VIEW_CONFIG.keys.sort.map(&:to_s).join "\n"}\n\n\n\n"
+           "#{VIEW_CONFIG.keys.sort.join "\n"}\n\n\n\n"
 
       argument :plugin_name, type: :string, optional: true,
         desc: "[CONFIG] Name of the configured rodauth app. Leave blank to use the primary account."

data/lib/plutonium/definition/base.rb

@@ -34,6 +34,7 @@ module Plutonium
       include Search
       include NestedInputs
       include StructuredInputs
+      include FormLayout
       include IndexViews
       include Metadata
 

data/lib/plutonium/definition/form_layout.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Definition
+    # Declarative form sectioning. Mixed into both resource definitions and
+    # interactions (mirrors StructuredInputs). The layout references field KEYS
+    # only and carries section-level options; per-field config stays on `input`.
+    #
+    # @example
+    #   form_layout do
+    #     section :identity, :name, :email, label: "Your identification"
+    #     section :address, :street, :city, collapsible: true, columns: 2,
+    #       condition: -> { object.requires_address? }
+    #     ungrouped label: "Other"
+    #   end
+    module FormLayout
+      extend ActiveSupport::Concern
+
+      UNGROUPED_KEY = :ungrouped
+
+      # One declared section, or the implicit `ungrouped` bucket (empty `fields`).
+      Section = Struct.new(:key, :fields, :options) do
+        def ungrouped? = key == UNGROUPED_KEY
+        def label = options[:label] || key.to_s.humanize
+        def description = options[:description]
+        def collapsible? = !!options[:collapsible]
+        def collapsed? = !!options[:collapsed]
+        def columns = options[:columns]
+        def condition = options[:condition]
+      end
+
+      # A section paired with the concrete fields it will render (after policy
+      # filtering). Produced by #resolve_form_sections (a later task).
+      ResolvedSection = Struct.new(:section, :fields)
+
+      # Collects section/ungrouped calls from a form_layout block in order.
+      class Builder
+        attr_reader :sections
+
+        def initialize
+          @sections = []
+          @ungrouped_seen = false
+        end
+
+        def section(key, *fields, **options)
+          if key == UNGROUPED_KEY
+            raise ArgumentError,
+              "`section :#{UNGROUPED_KEY}` is reserved — use the `ungrouped` macro"
+          end
+          validate_columns!(options)
+          @sections << Section.new(key:, fields: fields.freeze, options: options.freeze)
+        end
+
+        def ungrouped(**options)
+          raise ArgumentError, "`ungrouped` may only be declared once" if @ungrouped_seen
+          @ungrouped_seen = true
+          validate_columns!(options)
+          @sections << Section.new(key: UNGROUPED_KEY, fields: [].freeze, options: options.freeze)
+        end
+
+        private
+
+        def validate_columns!(options)
+          return unless options.key?(:columns)
+          value = options[:columns]
+          unless Integer === value && value > 0
+            raise ArgumentError,
+              "form_layout :columns must be a positive Integer, got #{value.inspect}"
+          end
+        end
+      end
+
+      class_methods do
+        # Declare the form layout. Re-declaring replaces it as a unit.
+        def form_layout(&block)
+          raise ArgumentError, "`form_layout` requires a block" unless block
+          builder = Builder.new
+          builder.instance_exec(&block)
+          @defined_form_layout = builder.sections.freeze
+        end
+
+        # Ordered Array<Section>, or nil when no layout was declared.
+        def defined_form_layout
+          @defined_form_layout
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@defined_form_layout, defined_form_layout&.dup)
+        end
+      end
+
+      # Instance access — the form render path holds a definition/interaction
+      # instance (mirrors the defineable_prop convention).
+      def defined_form_layout
+        self.class.defined_form_layout
+      end
+
+      # Resolve the policy-filtered field list into ordered ResolvedSections.
+      # Returns nil when no layout is declared (caller falls back to one grid).
+      def resolve_form_sections(resource_fields)
+        layout = defined_form_layout
+        return nil unless layout
+
+        resource_fields = resource_fields.map(&:to_sym)
+        known = resource_fields.to_set
+
+        # First-section-wins assignment: map each field to the first section key.
+        owner = {}
+        layout.each do |section|
+          next if section.ungrouped?
+          section.fields.each do |f|
+            unless known.include?(f)
+              raise ArgumentError,
+                "form_layout section :#{section.key} references unknown field :#{f}"
+            end
+            owner[f] ||= section.key
+          end
+        end
+        leftovers = resource_fields.reject { |f| owner.key?(f) }
+
+        resolved = layout.map do |section|
+          fields =
+            if section.ungrouped?
+              leftovers
+            else
+              section.fields.select { |f| owner[f] == section.key }
+            end
+          ResolvedSection.new(section:, fields:)
+        end
+
+        unless layout.any?(&:ungrouped?)
+          implicit = ResolvedSection.new(
+            section: Section.new(key: UNGROUPED_KEY, fields: [].freeze, options: {}.freeze),
+            fields: leftovers
+          )
+          resolved.push(implicit)
+        end
+
+        resolved
+      end
+    end
+  end
+end

data/lib/plutonium/interaction/base.rb

@@ -26,6 +26,7 @@ module Plutonium
       include Plutonium::Definition::ConfigAttr
       include Plutonium::Definition::Presentable
       include Plutonium::Definition::StructuredInputs
+      include Plutonium::Definition::FormLayout
 
       # On interactions, declaring a structured input also declares the backing
       # ActiveModel attribute so the value survives `attributes=` and appears in

data/lib/plutonium/package/engine.rb

@@ -4,14 +4,24 @@ module Plutonium
       extend ActiveSupport::Concern
 
       included do
-        # prevent this package from being added to the view lookup
-        # since we need finer control over how views are resolved.
-        # view lookup configuration is handled at the controller level
-        config.before_configuration do
-          # this touches the internals of rails, but I could not find a good way of doing this
-          # we get the initializer instance and set the block property to a noop
+        # Prevent this package's app/views from being appended to the global
+        # ActionController/ActionMailer view lookup — Plutonium resolves package
+        # views at the controller level (see Plutonium::Core::Controllers::Bootable,
+        # which reads current_engine.paths["app/views"]). We neutralize the
+        # engine's built-in `add_view_paths` initializer rather than clearing
+        # config.paths["app/views"], which that controller-level resolver needs.
+        #
+        # This MUST run as a real initializer (before :add_view_paths), NOT in
+        # before_configuration: that hook can fire before sibling package engines
+        # are loaded (it does in development, where :before_configuration has
+        # already run by the time config/packages.rb loads). Touching
+        # Rails.application.initializers there forces Rails.application.railties
+        # to memoize early — with only the packages loaded so far — permanently
+        # dropping the rest from the autoload paths (e.g. `uninitialized constant
+        # Blogging::Post`). By initializer-run time, railties is fully populated.
+        initializer :plutonium_neutralize_add_view_paths, before: :add_view_paths do
           add_view_paths_initializer = Rails.application.initializers.find do |a|
-            a.context_class == self && a.name.to_s == "add_view_paths"
+            a.context_class == self.class && a.name.to_s == "add_view_paths"
           end
           add_view_paths_initializer&.instance_variable_set(:@block, ->(app) {})
         end

data/lib/plutonium/ui/form/components/section.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Renders a form section's chrome (heading/description, optional native
+        # <details> collapsible, and a fields grid) and yields to a block that
+        # renders the section's fields (the form supplies render_resource_field).
+        class Section < Plutonium::UI::Component::Base
+          def initialize(resolved, grid_class:)
+            @section = resolved.section
+            @grid_class = grid_class
+          end
+
+          SECTION_CLASS = "space-y-4 border-t border-[var(--pu-border-muted)] pt-6 first:border-t-0 first:pt-0"
+          HEADING_CLASS = "text-base font-semibold text-[var(--pu-text)]"
+          SUMMARY_CLASS = "#{HEADING_CLASS} cursor-pointer select-none"
+          DESCRIPTION_CLASS = "text-sm text-[var(--pu-text-muted)]"
+
+          def view_template(&fields_block)
+            if @section.collapsible?
+              details(open: !@section.collapsed?, class: SECTION_CLASS) do
+                summary(class: SUMMARY_CLASS) { heading_text }
+                describe
+                grid(&fields_block)
+              end
+            else
+              div(class: SECTION_CLASS) do
+                header_block
+                grid(&fields_block)
+              end
+            end
+          end
+
+          private
+
+          def header_block
+            return if @section.ungrouped? && @section.options[:label].nil?
+            h3(class: HEADING_CLASS) { heading_text }
+            describe
+          end
+
+          def heading_text = @section.label
+
+          def describe
+            return unless @section.description
+            p(class: DESCRIPTION_CLASS) { @section.description }
+          end
+
+          def grid(&fields_block)
+            div(class: @grid_class, &fields_block)
+          end
+        end
+      end
+    end
+  end
+end