lcp 0.1.0

data/app/views/lcp_ruby/resources/_form_actions.html.erb

@@ -0,0 +1,38 @@
+<%
+  # Separate cancel (always inline, not counted) from submit actions
+  cancel_action = form_actions.find { |a| a["type"] == "built_in" && a["name"] == "cancel" }
+  submit_actions = form_actions.reject { |a| a["type"] == "built_in" && a["name"] == "cancel" }
+
+  # Split into forced-dropdown vs auto-placed
+  forced_dropdown = submit_actions.select { |a| a["position"] == "dropdown" }
+  auto_actions = submit_actions.reject { |a| a["position"] == "dropdown" }
+
+  # Auto actions: first N inline, rest overflow to dropdown
+  max_inline = defined?(max_inline_actions) ? max_inline_actions : 3
+  inline_actions = auto_actions.first(max_inline)
+  overflow_actions = auto_actions.drop(max_inline) + forced_dropdown
+%>
+<div class="lcp-form-actions">
+  <% inline_actions.each do |action| %>
+    <%= render "lcp_ruby/resources/form_action_button", action: action, record: record, presenter_name: presenter_name %>
+  <% end %>
+
+  <% if overflow_actions.any? %>
+    <div class="lcp-actions-dropdown">
+      <button type="button" class="btn lcp-dropdown-toggle" data-progress-anchor="true"><span data-lcp-btn-label><%= I18n.t("lcp_ruby.form.more_actions", default: "More") %></span></button>
+      <div class="lcp-dropdown-menu">
+        <% overflow_actions.each do |action| %>
+          <%= render "lcp_ruby/resources/form_action_dropdown_item", action: action, record: record, presenter_name: presenter_name %>
+        <% end %>
+      </div>
+    </div>
+  <% end %>
+
+  <% if cancel_action %>
+    <% if defined?(dialog_context) && dialog_context %>
+      <button type="button" class="btn" data-action="close-dialog" data-cancel-in-dialog="true"><%= I18n.t("lcp_ruby.form.cancel") %></button>
+    <% else %>
+      <%= link_to I18n.t("lcp_ruby.form.cancel"), resources_path, class: "btn" %>
+    <% end %>
+  <% end %>
+</div>

data/app/views/lcp_ruby/resources/_form_section.html.erb

@@ -0,0 +1,235 @@
+<% if section["type"] == "custom" %>
+  <%
+    custom_visible = condition_visible?(section, @record)
+    custom_cond_attrs = conditional_data(section)
+  %>
+  <fieldset class="lcp-form-section lcp-custom-section"
+            <% if custom_cond_attrs.any? %>data-lcp-conditional="section"<% end %>
+            <%= tag.attributes(custom_cond_attrs) %>
+            <% unless custom_visible %>style="display: none"<% end %>>
+    <legend><%= resolve_section_title(section, current_presenter&.name) %></legend>
+    <% if section["description"].present? %>
+      <p class="lcp-section-description"><%= section["description"] %></p>
+    <% end %>
+    <%= render_custom_partial(
+          partial: section["partial"],
+          locals: {
+            record: @record,
+            presenter: current_presenter,
+            evaluator: current_evaluator,
+            section_config: section,
+            form: form,
+            current_user: current_user,
+            page_definition: current_page,
+            params: params
+          },
+          context: "form section '#{section['title']}'"
+        ) %>
+  </fieldset>
+<% elsif section["type"] == "nested_fields" %>
+  <%
+    nested_visible = condition_visible?(section, @record)
+    nested_disabled = condition_disabled?(section, @record)
+    nested_cond_attrs = conditional_data(section)
+    nested_style_parts = []
+    nested_style_parts << "display: none" unless nested_visible
+  %>
+  <fieldset class="lcp-form-section lcp-nested-section <%= 'lcp-conditionally-disabled' if nested_disabled %>"
+            data-controller="lcp-nested-forms"
+            data-lcp-nested-forms-max-value="<%= section['max'] %>"
+            data-lcp-nested-forms-min-value="<%= section['min'] || 0 %>"
+            data-lcp-nested-forms-sortable-value="<%= section['sortable_field'].present? %>"
+            <% if section['sortable_field'] %>data-sortable-field="<%= section['sortable_field'] %>"<% end %>
+            <% if nested_cond_attrs.any? %>data-lcp-conditional="section"<% end %>
+            <%= tag.attributes(nested_cond_attrs) %>
+            <% if nested_style_parts.any? %>style="<%= nested_style_parts.join('; ') %>"<% end %>>
+    <legend><%= resolve_section_title(section, current_presenter&.name) %></legend>
+    <% if section["description"].present? %>
+      <p class="lcp-section-description"><%= section["description"] %></p>
+    <% end %>
+
+    <% if section["json_field"] %>
+      <%# JSON field source: items from a JSON column %>
+      <% json_field_name = section["json_field"] %>
+      <% target_model_def = section["target_model_definition"] %>
+      <% items = @record.respond_to?(json_field_name) ? (@record.send(json_field_name) || []) : [] %>
+      <% items = items.is_a?(Array) ? items : [] %>
+      <div class="lcp-nested-container" data-lcp-nested-forms-target="container">
+        <% items.each_with_index do |item, idx| %>
+          <% item_obj = LcpRuby::JsonItemWrapper.new(item.is_a?(Hash) ? item : {}, target_model_def) %>
+          <% fields_prefix = "record[#{json_field_name}][#{idx}]" %>
+          <%= render "lcp_ruby/resources/json_nested_fields",
+                     prefix: fields_prefix, item: item_obj, section: section, index: idx %>
+        <% end %>
+      </div>
+
+      <% if section["allow_add"] != false %>
+        <div data-lcp-nested-forms-target="template" style="display:none">
+          <% empty_item = LcpRuby::JsonItemWrapper.new({}, target_model_def) %>
+          <%= render "lcp_ruby/resources/json_nested_fields",
+                     prefix: "record[#{json_field_name}][NEW_RECORD]",
+                     item: empty_item, section: section, index: "NEW_RECORD" %>
+        </div>
+        <button type="button" class="btn lcp-nested-add" data-action="lcp-nested-forms#addRow"><%= section["add_label"] || I18n.t("lcp_ruby.nested_fields.add", default: "Add") %></button>
+      <% end %>
+
+      <% if section["allow_add"] == false && section["allow_remove"] == false && items.empty? %>
+        <p class="lcp-empty-nested"><%= section["empty_message"] || I18n.t("lcp_ruby.nested_fields.no_items", default: "No items.") %></p>
+      <% end %>
+    <% else %>
+      <%# Association source: has_many nested attributes %>
+      <div class="lcp-nested-container" data-lcp-nested-forms-target="container">
+        <%= form.fields_for section["association"].to_sym do |nf| %>
+          <%= render "lcp_ruby/resources/nested_fields", form: nf, section: section %>
+        <% end %>
+      </div>
+
+      <% if section["allow_add"] != false %>
+        <% assoc_reflection = @record.class.reflect_on_association(section["association"].to_sym) %>
+        <% if assoc_reflection %>
+          <div data-lcp-nested-forms-target="template" style="display:none">
+            <%= form.fields_for section["association"].to_sym, assoc_reflection.klass.new, child_index: "NEW_RECORD" do |template_f| %>
+              <%= render "lcp_ruby/resources/nested_fields", form: template_f, section: section %>
+            <% end %>
+          </div>
+          <button type="button" class="btn lcp-nested-add" data-action="lcp-nested-forms#addRow"><%= section["add_label"] || I18n.t("lcp_ruby.nested_fields.add", default: "Add") %></button>
+        <% end %>
+      <% end %>
+
+      <% if section["allow_add"] == false && section["allow_remove"] == false && @record.send(section["association"]).empty? %>
+        <p class="lcp-empty-nested"><%= section["empty_message"] || I18n.t("lcp_ruby.nested_fields.no_records", default: "No records.") %></p>
+      <% end %>
+    <% end %>
+  </fieldset>
+<% elsif section["hidden"] %>
+  <%# Hidden section — render only hidden inputs, no wrapper %>
+  <% (section["fields"] || []).each do |field_config| %>
+    <% field_name = field_config["field"] %>
+    <% next unless field_name %>
+    <% raw_value = @record.respond_to?(field_name) ? @record.send(field_name) : nil %>
+    <% value = case raw_value
+       when Hash, Array then raw_value.to_json
+       else raw_value.to_s
+       end %>
+    <%= form.hidden_field(field_name, value: value) %>
+  <% end %>
+<% else %>
+  <% collapsible = section["collapsible"] %>
+  <% collapsed = section["collapsed"] %>
+
+  <%# Skip sections where no fields are writable for the current user %>
+  <%
+    section_has_writable = (section["fields"] || []).any? do |fc|
+      next if fc["type"] == "info" || fc["type"] == "divider"
+      fc["field_definition"] && (current_evaluator.nil? || current_evaluator.field_writable?(fc["field"]))
+    end
+  %>
+
+  <% if section_has_writable %>
+  <%# Section-level conditional rendering %>
+  <%
+    section_visible = condition_visible?(section, @record)
+    section_disabled = condition_disabled?(section, @record)
+    section_cond_attrs = conditional_data(section)
+    section_style_parts = []
+    section_style_parts << "display: none" unless section_visible
+  %>
+
+  <fieldset class="lcp-form-section <%= 'lcp-collapsible' if collapsible %> <%= 'lcp-collapsed' if collapsible && collapsed %> <%= 'lcp-conditionally-disabled' if section_disabled %>"
+            <% if section_cond_attrs.any? %>data-lcp-conditional="section"<% end %>
+            <%= tag.attributes(section_cond_attrs) %>
+            <% if section_style_parts.any? %>style="<%= section_style_parts.join('; ') %>"<% end %>>
+    <legend>
+      <% if collapsible %>
+        <button type="button" class="lcp-collapse-toggle"><%= resolve_section_title(section, current_presenter&.name) %> <span class="lcp-collapse-icon"></span></button>
+      <% else %>
+        <%= resolve_section_title(section, current_presenter&.name) %>
+      <% end %>
+    </legend>
+    <% if section["description"].present? %>
+      <p class="lcp-section-description"><%= section["description"] %></p>
+    <% end %>
+
+    <div class="lcp-collapsible-content" style="<%= 'display: none' if collapsible && collapsed %>">
+      <div class="lcp-form-fields lcp-grid"
+           style="display: grid; grid-template-columns: repeat(<%= section['columns'] || 1 %>, 1fr); gap: 1rem;"
+           <%= "data-responsive-mobile=\"#{section.dig('responsive', 'mobile', 'columns')}\"" if section.dig('responsive', 'mobile', 'columns') %>
+           <%= "data-responsive-tablet=\"#{section.dig('responsive', 'tablet', 'columns')}\"" if section.dig('responsive', 'tablet', 'columns') %>>
+        <% (section["fields"] || []).each do |field_config| %>
+
+
+          <%# Handle info pseudo-field %>
+          <% if field_config["type"] == "info" %>
+            <div class="lcp-info-text" style="grid-column: 1 / -1;"><%= field_config["text"] %></div>
+            <% next %>
+          <% end %>
+
+          <%# Handle divider pseudo-field %>
+          <% if field_config["type"] == "divider" %>
+            <div class="lcp-divider" style="grid-column: 1 / -1;">
+              <hr>
+              <% if field_config["label"] %>
+                <span class="lcp-divider-label"><%= field_config["label"] %></span>
+              <% end %>
+            </div>
+            <% next %>
+          <% end %>
+
+          <% field_name = field_config["field"] %>
+          <% field_def = field_config["field_definition"] %>
+          <% next unless field_def %>
+          <%# date_range is a render-time pairing — base field is virtual.
+              Authorize by the two real columns (`_from`/`_to`) it spans. %>
+          <% if field_config["input_type"].to_s == "date_range"
+               next unless current_evaluator.nil? ||
+                 (current_evaluator.field_writable?("#{field_name}_from") &&
+                  current_evaluator.field_writable?("#{field_name}_to"))
+             else
+               next unless current_evaluator.nil? || current_evaluator.field_writable?(field_name)
+             end %>
+
+          <%# Field-level conditional rendering (hash conditions) %>
+          <%
+            field_visible = condition_visible?(field_config, @record)
+            field_disabled = condition_disabled?(field_config, @record)
+            field_cond_attrs = conditional_data(field_config)
+
+            field_style_parts = []
+            field_style_parts << "display: none" unless field_visible
+            field_style_parts << "grid-column: span #{field_config['col_span']}" if field_config["col_span"]
+          %>
+
+          <div class="lcp-form-field <%= hidden_on_classes(field_config) %> <%= 'lcp-conditionally-disabled' if field_disabled %>"
+               <% if field_cond_attrs.any? %>data-lcp-conditional="field" data-lcp-field-name="<%= field_name %>"<% end %>
+               <%= tag.attributes(field_cond_attrs) %>
+               <% if field_style_parts.any? %>style="<%= field_style_parts.join('; ') %>"<% end %>>
+            <% resolved_input = field_config["input_type"] || field_def.type_definition&.input_type || (field_def.attachment? ? "file_upload" : nil) || field_def.type %>
+
+            <% unless %w[formatting_options field_picker import_mapper].include?(resolved_input) %>
+              <%= form.label field_name, field_def.resolved_label(model_name: current_model_name) %>
+            <% end %>
+
+            <% workflow_readonly = @record && current_evaluator&.workflow_field_readonly?(field_name, @record) %>
+            <% if field_config["readonly"] || workflow_readonly || field_def.computed? %>
+              <% readonly_val = @record.send(field_name) %>
+              <div class="lcp-readonly-value"><%= format_enum_display(readonly_val, field_def, current_model_name) %></div>
+            <% elsif field_config["prefix"] || field_config["suffix"] %>
+              <div class="lcp-input-group">
+                <% if field_config["prefix"] %><span class="lcp-input-prefix"><%= field_config["prefix"] %></span><% end %>
+                <%= render_form_input(form, field_name, resolved_input, field_config, field_def) %>
+                <% if field_config["suffix"] %><span class="lcp-input-suffix"><%= field_config["suffix"] %></span><% end %>
+              </div>
+            <% else %>
+              <%= render_form_input(form, field_name, resolved_input, field_config, field_def) %>
+            <% end %>
+
+            <% if field_config["hint"] %>
+              <span class="lcp-field-hint"><%= field_config["hint"] %></span>
+            <% end %>
+          </div>
+        <% end %>
+      </div>
+    </div>
+  </fieldset>
+  <% end %>
+<% end %>

data/app/views/lcp_ruby/resources/_grid_page.html.erb

@@ -0,0 +1,17 @@
+<% if @filter_form&.any? %>
+  <%= render "lcp_ruby/resources/filter_form", filter_form: @filter_form %>
+<% end %>
+<% if @scope_filter_set&.any? %>
+  <%= render "lcp_ruby/resources/scope_filters", scope_filter_set: @scope_filter_set %>
+<% end %>
+<div class="lcp-grid-container">
+  <% @zone_data.each do |zone, data| %>
+    <% next if data[:hidden] %>
+    <div class="lcp-grid-zone" style="<%= grid_style_for(zone) %>"
+         <%= tag.attributes(dev_toolbar_attrs(presenter: zone.presenter_zone? ? zone.presenter : nil, page: current_page&.name, model: zone.presenter_zone? ? current_model_definition&.name : nil, zone: zone.name, page_type: "index", widget_type: zone.widget? ? zone.widget['type'] : nil)) %>>
+      <div class="lcp-widget lcp-widget-<%= zone.widget? ? zone.widget['type'] : 'presenter-zone' %>">
+        <%= render partial: widget_partial_for(zone), locals: { zone: zone, data: data } %>
+      </div>
+    </div>
+  <% end %>
+</div>

data/app/views/lcp_ruby/resources/_grouped_index.html.erb

@@ -0,0 +1,61 @@
+<% if @records.empty? %>
+  <div class="lcp-empty-state">
+    <p><%= I18n.t("lcp_ruby.grouped.empty_state", default: "No groups match your criteria.") %></p>
+  </div>
+<% else %>
+  <% columns = @column_set.visible_table_columns %>
+  <% col_field_defs = columns.each_with_object({}) do |col, map|
+       next if col["field"]&.include?(".")
+       map[col["field"]] = current_model_definition&.field(col["field"])
+     end %>
+  <% row_click = current_presenter.group_row_click %>
+  <table class="lcp-table">
+    <thead>
+      <tr>
+        <% columns.each do |col| %>
+          <% col_label = field_label_for(col, field_def: col_field_defs[col["field"]], model_name: current_model_name) %>
+          <th style="<%= "width: #{col['width']}" if col['width'] %>"
+              class="<%= hidden_on_classes(col) %>"
+              data-field="<%= col['field'] %>">
+            <% if col["sortable"] %>
+              <%= link_to url_for(sort: col["field"], direction: toggle_direction(col["field"])),
+                    class: "#{'lcp-sorted' if current_sort_field == col['field']}" do %>
+                <%= col_label %>
+                <% if current_sort_field == col["field"] %>
+                  <span class="lcp-sort-icon lcp-sort-<%= current_sort_direction %>"></span>
+                <% end %>
+              <% end %>
+            <% else %>
+              <%= col_label %>
+            <% end %>
+          </th>
+        <% end %>
+      </tr>
+    </thead>
+    <tbody>
+      <% @records.each do |row| %>
+        <% row_url = row_click ? grouped_row_click_url(row, current_presenter) : nil %>
+        <% row_classes = [] %>
+        <% row_classes << "lcp-row-clickable" if row_url %>
+        <% row_classes << compute_item_classes(row, current_presenter) %>
+        <tr class="<%= row_classes.reject(&:blank?).join(' ') %>"
+            <%= tag.attributes(data: { href: row_url }) if row_url %>>
+          <% columns.each do |col| %>
+            <td class="<%= hidden_on_classes(col) %>">
+              <% value = row.respond_to?(col["field"]) ? row.public_send(col["field"]) : nil %>
+              <% if col["renderer"] %>
+                <%= render_display_value(value, col["renderer"], col["options"], nil, record: row) %>
+              <% elsif value.is_a?(Numeric) %>
+                <% opts = col["options"] || {} %>
+                <% formatted = opts["precision"] ? number_with_precision(value, precision: opts["precision"]) : number_with_delimiter(value) %>
+                <%= formatted %><%= opts["suffix"] %>
+              <% else %>
+                <%= empty_value_placeholder(value, current_presenter) %>
+              <% end %>
+            </td>
+          <% end %>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>

data/app/views/lcp_ruby/resources/_inline_create_form.html.erb

@@ -0,0 +1,50 @@
+<% fields.each do |field| %>
+  <div class="lcp-form-field">
+    <label for="inline_record_<%= field[:name] %>"><%= field[:label] %><%= " *" if field[:required] %></label>
+    <% case field[:type] %>
+    <% when "string", "email", "phone", "url", "color" %>
+      <input type="<%= field[:type] == 'string' ? 'text' : field[:type] %>"
+             name="inline_record[<%= field[:name] %>]"
+             id="inline_record_<%= field[:name] %>"
+             placeholder="<%= field[:placeholder] %>"
+             <%= "required" if field[:required] %>>
+    <% when "text" %>
+      <textarea name="inline_record[<%= field[:name] %>]"
+                id="inline_record_<%= field[:name] %>"
+                rows="3"
+                placeholder="<%= field[:placeholder] %>"
+                <%= "required" if field[:required] %>></textarea>
+    <% when "integer", "float", "decimal" %>
+      <input type="number"
+             name="inline_record[<%= field[:name] %>]"
+             id="inline_record_<%= field[:name] %>"
+             step="<%= field[:type] == 'integer' ? '1' : 'any' %>"
+             <%= "required" if field[:required] %>>
+    <% when "boolean" %>
+      <input type="hidden" name="inline_record[<%= field[:name] %>]" value="0">
+      <input type="checkbox"
+             name="inline_record[<%= field[:name] %>]"
+             id="inline_record_<%= field[:name] %>"
+             value="1">
+    <% when "date" %>
+      <input type="date"
+             name="inline_record[<%= field[:name] %>]"
+             id="inline_record_<%= field[:name] %>"
+             <%= "required" if field[:required] %>>
+    <% when "datetime" %>
+      <input type="datetime-local"
+             name="inline_record[<%= field[:name] %>]"
+             id="inline_record_<%= field[:name] %>"
+             <%= "required" if field[:required] %>>
+    <% when "enum" %>
+      <select name="inline_record[<%= field[:name] %>]"
+              id="inline_record_<%= field[:name] %>"
+              <%= "required" if field[:required] %>>
+        <option value=""><%= I18n.t("lcp_ruby.select.include_blank") %></option>
+        <% (field[:enum_values] || []).each do |v| %>
+          <option value="<%= v %>"><%= v.humanize %></option>
+        <% end %>
+      </select>
+    <% end %>
+  </div>
+<% end %>

data/app/views/lcp_ruby/resources/_json_items_list.html.erb

@@ -0,0 +1,77 @@
+<%# Renders a json_items_list section on the show page.
+    Displays JSON array items as structured rows with field labels and values.
+    Locals:
+      section  - the enriched section hash from LayoutBuilder (with field_definitions)
+      record   - the parent record
+%>
+<%
+  json_field_name = section["json_field"]
+  items = record.respond_to?(json_field_name) ? (record.public_send(json_field_name) || []) : []
+  items = if items.is_a?(String)
+    begin; JSON.parse(items); rescue JSON::ParserError; []; end
+  else
+    items
+  end
+  target_model_def = section["target_model_definition"]
+
+  # Collect all display fields (flat or from sub_sections)
+  all_field_groups = if section["sub_sections"]
+    section["sub_sections"].map do |ss|
+      { title: ss["title"], fields: ss["fields"] || [], columns: ss["columns"] }
+    end
+  else
+    [{ title: nil, fields: section["fields"] || [], columns: section["columns"] }]
+  end
+%>
+
+<div class="lcp-json-items-list">
+  <% if items.empty? %>
+    <div class="lcp-json-items-list__empty">
+      <%= section["empty_message"] || I18n.t("lcp_ruby.nested_fields.no_items", default: "No items.") %>
+    </div>
+  <% else %>
+    <% items.each_with_index do |item_hash, idx| %>
+      <%
+        item = if target_model_def
+          LcpRuby::JsonItemWrapper.new(item_hash, target_model_def)
+        else
+          LcpRuby::JsonItemWrapper.new(item_hash)
+        end
+      %>
+      <div class="lcp-json-item">
+        <div class="lcp-json-item__number"><%= idx + 1 %></div>
+        <div class="lcp-json-item__body">
+          <% all_field_groups.each do |group| %>
+            <% if group[:title] %>
+              <div class="lcp-json-item__group-title"><%= group[:title] %></div>
+            <% end %>
+            <div class="lcp-json-item__fields" style="display: grid; grid-template-columns: repeat(<%= group[:columns] || group[:fields].size %>, 1fr); gap: 0.5rem 1rem;">
+              <% group[:fields].each do |field_config| %>
+                <% field_name = field_config["field"] %>
+                <% next unless field_name %>
+                <% field_def = field_config["field_definition"] %>
+                <% value = item.respond_to?(field_name) ? item.public_send(field_name) : item_hash[field_name.to_s] %>
+                <div class="lcp-json-item__field">
+                  <div class="lcp-json-item__label"><%= field_config["label"] || field_def&.resolved_label(model_name: target_model_def&.name) || field_name.to_s.humanize %></div>
+                  <div class="lcp-json-item__value">
+                    <% if field_config["renderer"] %>
+                      <%= render_display_value(value, field_config["renderer"], field_config["options"], field_def, record: record) %>
+                    <% elsif field_def&.type == "boolean" %>
+                      <%= render_display_value(value, "boolean_icon", {}) %>
+                    <% elsif field_def&.enum? %>
+                      <%= field_def.enum_label_for(value, model_name: target_model_def&.name) %>
+                    <% elsif value.nil? %>
+                      <span class="lcp-json-item__nil">&mdash;</span>
+                    <% else %>
+                      <%= value %>
+                    <% end %>
+                  </div>
+                </div>
+              <% end %>
+            </div>
+          <% end %>
+        </div>
+      </div>
+    <% end %>
+  <% end %>
+</div>

data/app/views/lcp_ruby/resources/_json_nested_fields.html.erb

@@ -0,0 +1,30 @@
+<% sortable_field = section["sortable_field"] %>
+<div class="lcp-nested-row" data-lcp-condition-scope
+     <% if sortable_field %>data-action="mousedown->lcp-nested-forms#handleMouseDown dragstart->lcp-nested-forms#dragStart touchstart->lcp-nested-forms#handleTouchStart"<% end %>>
+  <% if sortable_field %>
+    <span class="lcp-drag-handle">&#9776;</span>
+  <% end %>
+
+  <%
+    json_input_renderer = ->(field_config, field_def, field_name) {
+      input_name = "#{prefix}[#{field_name}]"
+      value = item.respond_to?(field_name) ? item.send(field_name) : nil
+      resolved_input = field_config["input_type"] || field_def.type_definition&.input_type || field_def.type
+      render_json_field_input(input_name, value, resolved_input, field_config, field_def)
+    }
+  %>
+  <%= render "lcp_ruby/resources/nested_row_content",
+             section: section, record_or_item: item,
+             sortable_field: sortable_field, input_renderer: json_input_renderer %>
+
+  <% if sortable_field %>
+    <input type="hidden" name="<%= prefix %>[<%= sortable_field %>]"
+           value="<%= item.respond_to?(sortable_field) ? item.send(sortable_field) : index %>"
+           class="lcp-position-field">
+  <% end %>
+
+  <% if section["allow_remove"] != false %>
+    <input type="hidden" name="<%= prefix %>[_destroy]" value="0" class="lcp-destroy-flag">
+    <button type="button" class="btn btn-danger lcp-nested-remove" data-action="lcp-nested-forms#removeRow"><%= I18n.t("lcp_ruby.nested_fields.remove", default: "Remove") %></button>
+  <% end %>
+</div>

data/app/views/lcp_ruby/resources/_kanban_card.html.erb

@@ -0,0 +1,31 @@
+<%# Kanban-card wrapper: drag attributes (draggable, data-allowed-targets),
+    layout-specific class (.lcp-kanban-card), shared .lcp-card class, ARIA,
+    accent style. Body composition delegated to _kanban_card_body unless
+    card.render_with: overrides it. Locals: record, card_config %>
+<% kanban_classes = [ "lcp-kanban-card", "lcp-card", compute_item_classes(record, current_presenter).presence ].compact %>
+<% allowed_targets = @kanban_provider&.allowed_targets(record: record, user: current_user) %>
+<% can_drag = @kanban_provider ? @kanban_provider.can_move?(record: record, user: current_user) : false %>
+<% data_attrs = { record_id: record.id, kanban_move_url: kanban_move_resource_path(record) }
+   data_attrs[:allowed_targets] = allowed_targets.map(&:to_s).join(",") if allowed_targets %>
+<%= tag.div(
+      class: kanban_classes,
+      data: data_attrs,
+      draggable: can_drag,
+      style: card_accent_style(record, card_config).presence,
+      **card_aria_attributes(record, card_config, current_presenter)
+    ) do %>
+  <% if (custom = card_config["render_with"]).present? %>
+    <%= render_custom_partial(
+          partial: custom,
+          locals: { record: record, card_config: card_config,
+                    presenter: current_presenter,
+                    column_set: @column_set, action_set: @action_set },
+          context: "kanban render_with for presenter=#{current_presenter.name}, record_id=#{record.id}"
+        ) %>
+  <% else %>
+    <%= render partial: "lcp_ruby/resources/kanban_card_body",
+               locals: { record: record, card_config: card_config,
+                         presenter: current_presenter,
+                         column_set: @column_set, action_set: @action_set } %>
+  <% end %>
+<% end %>

data/app/views/lcp_ruby/resources/_kanban_card_body.html.erb

@@ -0,0 +1,17 @@
+<%# Kanban-specific zone composition. ~15-line counterpart to
+    _tile_card_body — different ARRANGEMENT (compact header, no banner image,
+    no description zone) but reuses the same shared CardHelper zone helpers.
+    Locals: record, card_config, presenter, column_set, action_set %>
+<% row_click = presenter.index_config["row_click"] %>
+<% title_id = card_title_id(record, presenter.name) %>
+
+<div class="lcp-kanban-header">
+  <%= card_avatar(record, card_config) %>
+  <div class="lcp-card-title" id="<%= title_id %>">
+    <%= card_title(record, card_config, row_click: row_click, title_id: title_id) %>
+  </div>
+  <%= card_subtitle(record, card_config) %>
+</div>
+
+<%= card_field_list(record, card_config, column_set: column_set) %>
+<%= card_actions(record, action_set, card_config) %>

data/app/views/lcp_ruby/resources/_kanban_column.html.erb

@@ -0,0 +1,33 @@
+<%# One kanban column wrapped in a Turbo Frame.
+    Frame ID convention (kanban_view.md l.386): `kanban_col_<presenter_slug>_<safe_value>`
+    where safe_value = column.value.to_s.parameterize(separator: "_").
+    Locals: column, board %>
+<% safe_value = column.value.to_s.parameterize(separator: "_") %>
+<% frame_id = "kanban_col_#{current_presenter.slug}_#{safe_value}" %>
+<% records = board.records_for(column.value) %>
+<% page = (params[:kanban_page].presence || 1).to_i %>
+<% cards_per_column = (current_presenter.kanban_config["cards_per_column"] || 20).to_i %>
+<% column_count = column.count.to_i %>
+<% has_more = column_count > (page * cards_per_column) %>
+<% next_page_params = request.query_parameters.merge(
+     "kanban_column" => column.value.to_s,
+     "kanban_page" => (page + 1).to_s
+   ) %>
+
+<%= turbo_frame_tag frame_id,
+                    class: "lcp-kanban-column",
+                    data: { column_value: column.value.to_s } do %>
+  <%= render "lcp_ruby/resources/kanban_column_header", column: column %>
+  <div class="lcp-kanban-column-body">
+    <% records.each do |record| %>
+      <%= render partial: "lcp_ruby/resources/kanban_card",
+                 locals: { record: record, card_config: current_presenter.card_config } %>
+    <% end %>
+    <% if has_more %>
+      <%= link_to I18n.t("lcp_ruby.kanban.load_more", default: "Load more"),
+                  "#{request.path}?#{next_page_params.to_query}",
+                  class: "lcp-kanban-load-more",
+                  data: { turbo_frame: frame_id } %>
+    <% end %>
+  </div>
+<% end %>

data/app/views/lcp_ruby/resources/_kanban_column_header.html.erb

@@ -0,0 +1,10 @@
+<%# Kanban column header. Phase 1 surface: title + count badge.
+    Phase 4 will extend this template with column_aggregate + progress_bar
+    via additive slots. Locals: column. %>
+<% style_attr = column.color ? "--lcp-card-accent: var(--lcp-#{column.color});" : nil %>
+<div class="lcp-kanban-column-header" style="<%= style_attr %>">
+  <h3 class="lcp-kanban-column-title"><%= column.label %></h3>
+  <% if column.count %>
+    <span class="lcp-kanban-column-count" data-kanban-count="true"><%= column.count %></span>
+  <% end %>
+</div>

data/app/views/lcp_ruby/resources/_kanban_index.html.erb

@@ -0,0 +1,17 @@
+<%# Lazy-load (?kanban_column=) is short-circuited in the controller before
+    this partial renders, so this template only emits the full board. %>
+<% if @kanban_board.columns.empty? %>
+  <div class="lcp-empty-state">
+    <p><%= current_presenter.index_config["empty_message"] ||
+            I18n.t("lcp_ruby.kanban.empty", default: "No records match your filters") %></p>
+  </div>
+<% else %>
+  <div class="lcp-kanban-board"
+       data-controller="lcp-kanban-board"
+       data-lcp-kanban-board-presenter-slug-value="<%= current_presenter.slug %>">
+    <% @kanban_board.columns.each do |col| %>
+      <%= render partial: "lcp_ruby/resources/kanban_column",
+                 locals: { column: col, board: @kanban_board } %>
+    <% end %>
+  </div>
+<% end %>