lcp 0.1.0

data/app/views/lcp_ruby/dialogs/_dialog_frame.html.erb

@@ -0,0 +1,60 @@
+<% stimulus_controller = dialog_config["stimulus_controller"] %>
+<div class="lcp-dialog-header">
+  <h3>
+    <% if dialog_config["title_key"] %>
+      <%= I18n.t(dialog_config["title_key"], default: presenter.resolved_label) %>
+    <% else %>
+      <%= record.respond_to?(:persisted?) && record.persisted? ? I18n.t("lcp_ruby.form.update") : I18n.t("lcp_ruby.form.create") %> <%= presenter.resolved_label %>
+    <% end %>
+  </h3>
+  <% if dialog_config.fetch("closable", true) %>
+    <button type="button" class="lcp-dialog-close" data-action="close-dialog">&times;</button>
+  <% end %>
+</div>
+<div class="lcp-dialog-body" data-lcp-dialog-size="<%= dialog_config["size"] || "medium" %>"
+     <%= "data-controller=#{stimulus_controller}" if stimulus_controller %>
+     <% if stimulus_controller == "lcp-import-dialog" && record.respond_to?(:source_presenter) && record.source_presenter.present? %>
+       <% _import_pdef = LcpRuby.loader.presenter_definitions[record.source_presenter.to_s] %>
+       <% if _import_pdef %>
+         <% _import_slug = _import_pdef.slug || LcpRuby::Widgets::PresenterZoneResolver.routable_slug_for_model(_import_pdef.model) %>
+         <% if _import_slug %>
+           data-lcp-import-dialog-fields-url-value="<%= lcp_ruby.import_fields_path(lcp_slug: _import_slug) %>"
+         <% end %>
+       <% end %>
+     <% end %>>
+  <% form_url = controller.respond_to?(:dialog_form_url, true) ? controller.send(:dialog_form_url) : nil %>
+  <% has_attachments = model_definition.fields.any?(&:attachment?) %>
+  <% form_data = { "lcp-dialog-form" => true } %>
+  <% form_data[:controller] = "lcp-conditional-rendering" %>
+  <% form_data[:action] = "change->lcp-conditional-rendering#evaluate input->lcp-conditional-rendering#evaluate" %>
+  <% form_data["#{stimulus_controller}-target"] = "form" if stimulus_controller %>
+  <%= form_with(model: record, url: form_url, scope: :record, method: record.respond_to?(:persisted?) && record.persisted? ? :patch : :post, class: "lcp-dialog-form", data: form_data, multipart: has_attachments) do |form| %>
+    <% if record.errors.any? %>
+      <div class="lcp-errors">
+        <ul>
+          <% record.errors.full_messages.each do |message| %>
+            <li><%= message %></li>
+          <% end %>
+        </ul>
+      </div>
+    <% end %>
+
+    <% layout_builder.form_sections.each do |section| %>
+      <%= render partial: "lcp_ruby/resources/form_section", locals: { form: form, section: section } %>
+    <% end %>
+
+    <% if defined?(form_actions) && form_actions.present? %>
+      <%= render "lcp_ruby/resources/form_actions",
+        form_actions: form_actions,
+        record: record,
+        presenter_name: presenter.name,
+        dialog_context: true,
+        max_inline_actions: presenter.max_inline_actions %>
+    <% else %>
+      <div class="lcp-dialog-actions">
+        <button type="button" class="btn" data-action="close-dialog"><%= I18n.t("lcp_ruby.dialogs.close", default: "Close") %></button>
+        <%= form.submit record.respond_to?(:persisted?) && record.persisted? ? I18n.t("lcp_ruby.form.update") : I18n.t("lcp_ruby.form.create"), class: "btn btn-primary" %>
+      </div>
+    <% end %>
+  <% end %>
+</div>

data/app/views/lcp_ruby/dialogs/_dialog_show_frame.html.erb

@@ -0,0 +1,14 @@
+<div class="lcp-dialog-header">
+  <h3><%= record.respond_to?(:to_label) ? record.to_label : record.class.model_name.human %></h3>
+  <button type="button" class="lcp-dialog-close" data-action="close-dialog">&times;</button>
+</div>
+<div class="lcp-dialog-body" data-lcp-dialog-size="large">
+  <%= render "lcp_ruby/resources/show_sections",
+        layout_builder: layout_builder,
+        column_set: column_set,
+        field_resolver: field_resolver,
+        record: record %>
+  <div class="lcp-dialog-actions">
+    <button type="button" class="btn" data-action="close-dialog"><%= I18n.t("lcp_ruby.dialogs.close", default: "Close") %></button>
+  </div>
+</div>

data/app/views/lcp_ruby/dialogs/_show_secret.html.erb

@@ -0,0 +1,10 @@
+<div class="lcp-dialog-body lcp-dialog-result lcp-dialog-result--single-secret">
+  <h3 class="lcp-dialog-result__title"><%= t(local_assigns[:title_key]) %></h3>
+  <p class="lcp-dialog-result__warning lcp-warning"><%= t(local_assigns[:warning_key]) %></p>
+  <%= render_display_value(record.public_send(local_assigns[:field]), "copy_code", {}, nil, record: record) %>
+  <div class="lcp-dialog-actions">
+    <button type="button" class="btn" data-action="close-dialog">
+      <%= t("lcp_ruby.actions.close", default: "Close") %>
+    </button>
+  </div>
+</div>

data/app/views/lcp_ruby/dialogs/_success.html.erb

@@ -0,0 +1 @@
+<div data-lcp-dialog-action="<%= on_success %>"<% if defined?(flash_message) && flash_message.present? %> data-flash-message="<%= flash_message %>"<% end %>></div>

data/app/views/lcp_ruby/errors/not_found.html.erb

@@ -0,0 +1,5 @@
+<div class="lcp-error-page">
+  <h1><%= I18n.t("lcp_ruby.errors.not_found", default: "Page not found") %></h1>
+  <p class="lcp-error-message"><%= message %></p>
+  <p><%= link_to I18n.t("lcp_ruby.errors.back_to_home", default: "Back to home"), LcpRuby.configuration.breadcrumb_home_path, class: "btn btn-primary" %></p>
+</div>

data/app/views/lcp_ruby/menu_renderers/_user_menu.html.erb

@@ -0,0 +1,51 @@
+<%# Shipped trigger renderer for the user-menu corner item. Emits an
+    avatar (or initials fallback) + display name + caret composition
+    inside the framework's `<button class="lcp-nav-dropdown-toggle">`
+    (the wrapper).
+
+    Locals:
+      item:     the parent :group MenuItem
+      disabled: boolean — when true, applies `lcp-user-menu--disabled`
+                modifier classes for visual feedback alongside the
+                wrapper's aria-disabled / <button disabled>. %>
+<%
+  user = LcpRuby::Current.user
+  disabled_class = local_assigns.fetch(:disabled, false) ? "lcp-user-menu--disabled" : ""
+%>
+<% if user.nil? %>
+  <%# No user in context (login page in apps with public routes). Emit
+      no inner content; the wrapper's aria_label still announces the
+      role to assistive tech. %>
+<% else %>
+<%
+  display_name =
+    if user.respond_to?(:name) && user.name.present?
+      user.name
+    elsif user.respond_to?(:email) && user.email.present?
+      user.email
+    else
+      LcpRuby::Menu.warn_user_menu_no_name(user)
+      "User #{user.id}"
+    end
+
+  avatar_url =
+    if user.respond_to?(:avatar_data_url) && user.avatar_data_url.present?
+      user.avatar_data_url
+    elsif user.respond_to?(:profile_data) && user.profile_data.is_a?(Hash) && user.profile_data["avatar_data_url"].present?
+      user.profile_data["avatar_data_url"]
+    end
+  initials = display_name.to_s.strip[0]&.upcase || "?"
+%>
+
+<% if avatar_url.present? %>
+  <img class="lcp-user-menu__avatar <%= disabled_class %>" src="<%= avatar_url %>" alt="" width="28" height="28">
+<% else %>
+  <span class="lcp-user-menu__avatar lcp-user-menu__avatar--initial <%= disabled_class %>" aria-hidden="true"><%= initials %></span>
+<% end %>
+
+<span class="lcp-user-menu__label <%= disabled_class %>"><%= display_name %></span>
+<%# Reuse lcp-nav-caret so the existing rotate-on-aria-expanded CSS
+    selector applies to this trigger too. The glyph itself comes from
+    `.lcp-nav-caret::after`, so no inline text. %>
+<span class="lcp-user-menu__caret lcp-nav-caret <%= disabled_class %>" aria-hidden="true"></span>
+<% end %>

data/app/views/lcp_ruby/menu_renderers/_user_menu_panel.html.erb

@@ -0,0 +1,32 @@
+<%# Shipped panel renderer for the user-menu dropdown. Emits a
+    profile-card header (display name + email) on top, then a
+    standard items list. Pairs naturally with the
+    `lcp_ruby/user_menu` trigger renderer; either may be used
+    standalone (configurator-friendly à la carte).
+
+    Locals:
+      item:  the parent :group MenuItem
+      items: already-expanded + visibility-filtered children
+             (from LayoutHelper#panel_items_for) %>
+<%
+  user = LcpRuby::Current.user
+  display_name =
+    if user&.respond_to?(:name) && user.name.present?
+      user.name
+    elsif user&.respond_to?(:email) && user.email.present?
+      user.email
+    end
+%>
+<% if user.present? && display_name.present? %>
+  <header class="lcp-user-menu-panel__header">
+    <div class="lcp-user-menu-panel__name"><%= display_name %></div>
+    <% if user.respond_to?(:email) && user.email.present? && display_name != user.email %>
+      <div class="lcp-user-menu-panel__email"><%= user.email %></div>
+    <% end %>
+  </header>
+<% end %>
+<ul class="lcp-user-menu-panel__items">
+  <% items.each do |child| %>
+    <%= render_menu_item(child) %>
+  <% end %>
+</ul>

data/app/views/lcp_ruby/navigation/_auto_top.html.erb

@@ -0,0 +1,16 @@
+<%# Auto-mode top nav — emitted when no menu.yml is defined. Mirrors
+    _top.html.erb's leftZone/rightZone structure so the
+    lcp-responsive-top-nav controller works the same in auto mode. The
+    responsive policy falls back to framework defaults (overflow_more @
+    768px) because menu_definition is nil here. %>
+<%= tag.nav class: "lcp-nav", data: responsive_top_nav_data_attrs(nil) do %>
+  <ul class="lcp-nav-list lcp-nav-list--left" data-lcp-responsive-top-nav-target="leftZone">
+    <% navigable_entries.each_with_index do |entry, index| %>
+      <li class="lcp-nav-item" data-original-index="<%= index %>">
+        <%= link_to entry[:label], lcp_ruby.resources_path(lcp_slug: entry[:slug]),
+              class: entry[:all_slugs].include?(params[:lcp_slug]) ? "active" : "" %>
+      </li>
+    <% end %>
+  </ul>
+  <ul class="lcp-nav-list lcp-nav-list--right" data-lcp-responsive-top-nav-target="rightZone"></ul>
+<% end %>

data/app/views/lcp_ruby/navigation/_both_sidebar.html.erb

@@ -0,0 +1 @@
+<%= render "lcp_ruby/navigation/sidebar" %>

data/app/views/lcp_ruby/navigation/_both_top.html.erb

@@ -0,0 +1 @@
+<%= render "lcp_ruby/navigation/top" %>

data/app/views/lcp_ruby/navigation/_impersonation_banner.html.erb

@@ -0,0 +1,14 @@
+<% if impersonating? %>
+  <div class="lcp-impersonation-banner">
+    <span><%= I18n.t("lcp_ruby.impersonation.viewing_as_role", default: "Viewing as role:") %> <strong><%= impersonated_role %></strong></span>
+    <%= button_to I18n.t("lcp_ruby.impersonation.stop", default: "Stop impersonation"), lcp_ruby.stop_impersonate_path, method: :delete, class: "btn btn-danger" %>
+  </div>
+<% elsif available_roles_for_impersonation.any? %>
+  <div class="lcp-impersonation-banner lcp-impersonation-selector">
+    <%= form_with url: lcp_ruby.impersonate_path, method: :post, style: "display: inline-flex; align-items: center; gap: 0.5rem;" do |f| %>
+      <label for="impersonate_role"><%= I18n.t("lcp_ruby.impersonation.view_as", default: "View as:") %></label>
+      <%= select_tag :role, options_for_select(available_roles_for_impersonation), prompt: I18n.t("lcp_ruby.impersonation.select_role_prompt", default: "Select role..."), id: "impersonate_role" %>
+      <%= submit_tag I18n.t("lcp_ruby.impersonation.impersonate", default: "Impersonate"), class: "btn" %>
+    <% end %>
+  </div>
+<% end %>

data/app/views/lcp_ruby/navigation/_item_content.html.erb

@@ -0,0 +1,23 @@
+<%# Renders the inner content of a menu item link/button. By default
+    emits icon + label; when `render:` is set on the item, delegates to
+    the host-/platform-shipped renderer partial.
+
+    Locals:
+      item:        LcpRuby::Metadata::MenuItem (required)
+      label_class: String — layout-specific class for the label span
+                   (e.g. "lcp-nav-label", "lcp-sidebar-label",
+                   "lcp-sidebar-group-label").
+      disabled:    Boolean (optional) — forwarded to the render: partial
+                   so renderers can adapt visually to disable_when:.
+                   Defaults to false. %>
+<% if item.render_partial.present? %>
+  <%= render item.render_partial_path,
+        item: item,
+        disabled: local_assigns.fetch(:disabled, false) %>
+<% else %>
+  <% label = menu_item_label(item) %>
+  <%= menu_item_icon_html(item) %>
+  <% if label.present? %>
+    <span class="<%= label_class %>"><%= label %></span>
+  <% end %>
+<% end %>

data/app/views/lcp_ruby/navigation/_link_or_button.html.erb

@@ -0,0 +1,51 @@
+<%# Renders a menu item as `<a href>` (GET) or `<button_to>` (non-GET)
+    based on the resolved URL+method pair from `menu_item_url(item)`.
+    Used by `_top_item.html.erb` and `_sidebar_item.html.erb` for root
+    items, dropdown children, and submenu grandchildren — three
+    nesting levels share the same wrapper logic.
+
+    `disable_when:` is honoured here:
+      - GET items get `aria-disabled="true"`, `tabindex="-1"`, and the
+        Stimulus `lcp-menu` controller wired to suppress click +
+        Enter/Space activation.
+      - Non-GET items render `<button disabled>` natively (no
+        Stimulus needed — disabled buttons silently ignore activation).
+
+    Locals:
+      item:          LcpRuby::Metadata::MenuItem (required)
+      klass:         CSS class string for the wrapper (active state etc.)
+      label_class:   forwarded to _item_content (default "lcp-nav-label") %>
+<% link_data = menu_item_url(item) %>
+<% if link_data && link_data[:url] %>
+  <% _label_class = local_assigns.fetch(:label_class, "lcp-nav-label") %>
+  <% disabled = !item.meets_enabled?(LcpRuby::Current.user) %>
+  <% wrapper_class = disabled ? "#{klass} lcp-menu-item lcp-menu-item--disabled".strip : klass %>
+  <%# Wrapper drops its native badge when render: is present — the
+      renderer takes full inner-content control and may emit its own
+      badge wherever fits the design. Without this drop, the badge
+      would land after the renderer's last element (e.g., after the
+      avatar+name+caret of a user-menu trigger), producing visual
+      artifacts. %>
+  <% inner_content_locals = { item: item, label_class: _label_class, disabled: disabled } %>
+  <% if link_data[:method] == :get %>
+    <% link_attrs = {
+         class: wrapper_class,
+         aria: { label: menu_item_link_aria_label(item) }
+       }
+       if disabled
+         link_attrs[:aria][:disabled] = "true"
+         link_attrs[:tabindex] = "-1"
+         link_attrs[:data] = {
+           controller: "lcp-menu",
+           action: "click->lcp-menu#prevent keydown.enter->lcp-menu#prevent keydown.space->lcp-menu#prevent"
+         }
+       end %>
+    <%= link_to link_data[:url], **link_attrs do %>
+      <%= render partial: "lcp_ruby/navigation/item_content", locals: inner_content_locals %><%= menu_item_badge(item) unless item.render_partial.present? %>
+    <% end %>
+  <% else %>
+    <%= button_to link_data[:url], method: link_data[:method], class: wrapper_class, form: { class: "lcp-menu-item-form" }, disabled: disabled, aria: { label: menu_item_link_aria_label(item) } do %>
+      <%= render partial: "lcp_ruby/navigation/item_content", locals: inner_content_locals %><%= menu_item_badge(item) unless item.render_partial.present? %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/lcp_ruby/navigation/_mobile_header.html.erb

@@ -0,0 +1,23 @@
+<%# Thin mobile header rendered above the sidebar-only layout when the
+    sidebar's below_breakpoint mode is `off_canvas`. Contains a hamburger
+    button that toggles the sidebar drawer.
+
+    The layout always renders this partial (it costs ~50 bytes); CSS
+    `.lcp-mobile-header` is `display: none` by default, and shown only
+    via `body.lcp-sidebar-off-canvas-active .lcp-mobile-header` — the
+    class is toggled by lcp-responsive-sidebar when matchMedia flips
+    below breakpoint. Apps with a top_menu already get the auto-injected
+    sidebar_toggle and do not render this strip. %>
+<header class="lcp-mobile-header" role="banner">
+  <button type="button"
+          class="lcp-mobile-header__toggle"
+          data-controller="lcp-sidebar-toggle"
+          data-action="click->lcp-sidebar-toggle#toggle"
+          aria-label="<%= I18n.t('lcp_ruby.nav.open_menu', default: 'Open menu') %>"
+          aria-controls="lcp-sidebar"
+          aria-expanded="false">
+    <span class="lcp-menu-icon" aria-hidden="true">
+      <i data-lucide="menu"></i>
+    </span>
+  </button>
+</header>

data/app/views/lcp_ruby/navigation/_panel_item.html.erb

@@ -0,0 +1,32 @@
+<%# Renders a single child of a `render_panel:` group's items list.
+    Used by `render_menu_item(item, context: :panel)` from
+    panel-renderer partials (e.g. `lcp_ruby/menu_renderers/_user_menu_panel`).
+
+    Locals:
+      item:  LcpRuby::Metadata::MenuItem (required)
+
+    Dispatches on item type:
+      :separator → <li class="lcp-panel-separator" role="separator">
+      widget:    → <li class="lcp-menu-widget"> with the render: partial inline
+      :link or :view_group → <li class="lcp-panel-item">
+                  with `<a href>` (GET) or `<button_to>` (non-GET).
+      :group     → REJECTED. The boot validator forbids :group children
+                  in panels (no nested submenus); reaching this branch
+                  means the validator was bypassed — raise rather than
+                  silently emit malformed wrapping. %>
+<% if item.separator? %>
+  <li class="lcp-panel-separator" role="separator"></li>
+<% elsif item.widget? %>
+  <%= render "lcp_ruby/navigation/widget_item", item: item %>
+<% elsif item.group? %>
+  <% raise RuntimeError, "nested :group inside panel — validator should have caught this" %>
+<% else %>
+  <% pi_classes = [ "lcp-panel-item" ]
+     pi_classes << "lcp-panel-item--icon-only" if menu_item_icon_only?(item) %>
+  <li class="<%= pi_classes.join(' ') %>">
+    <%= render "lcp_ruby/navigation/link_or_button",
+          item: item,
+          klass: menu_item_active?(item, params[:lcp_slug]) ? "active lcp-panel-link" : "lcp-panel-link",
+          label_class: "lcp-panel-label" %>
+  </li>
+<% end %>

data/app/views/lcp_ruby/navigation/_sidebar.html.erb

@@ -0,0 +1,38 @@
+<%# Full sidebar navigation (sidebar-only layout mode).
+    data-rail is server-rendered from cookies[:lcp_sidebar] (with policy
+    fallback) so first paint matches the user's persisted state.
+    lcp-drawer gives off_canvas mode focus trap + scroll lock + backdrop
+    + ESC; above breakpoint it stays inert until lcp-sidebar-toggle
+    calls drawer.open(). %>
+<% sidebar_items = visible_menu_items(menu_definition.sidebar_menu) %>
+<% policy = menu_definition.responsive %>
+<% rail_state = sidebar_initial_rail_state(menu_definition) %>
+<% sidebar_data = {
+     controller: "lcp-sidebar lcp-responsive-sidebar lcp-drawer",
+     action: "click->lcp-sidebar#toggle",
+     above_breakpoint: policy.sidebar_above_breakpoint,
+     below_breakpoint: policy.sidebar_below_breakpoint,
+     breakpoint: policy.sidebar_breakpoint.to_s,
+     persist: policy.sidebar_persist,
+     rail: rail_state
+   } %>
+<%# Only emit user_toggle="false" when explicitly disabled — its absence
+    means default (enabled) and avoids the .to_s round-trip. %>
+<% sidebar_data[:user_toggle] = "false" unless policy.sidebar_user_toggle? %>
+<%= tag.aside id: "lcp-sidebar", class: "lcp-sidebar", data: sidebar_data do %>
+  <nav class="lcp-sidebar-nav">
+    <ul class="lcp-sidebar-list lcp-sidebar-main">
+      <% menu_main_items(sidebar_items).each do |item| %>
+        <%= render partial: "lcp_ruby/navigation/sidebar_item", locals: { item: item, depth: 0 } %>
+      <% end %>
+    </ul>
+    <% bottom = menu_bottom_items(sidebar_items) %>
+    <% if bottom.any? %>
+      <ul class="lcp-sidebar-list lcp-sidebar-bottom">
+        <% bottom.each do |item| %>
+          <%= render partial: "lcp_ruby/navigation/sidebar_item", locals: { item: item, depth: 0 } %>
+        <% end %>
+      </ul>
+    <% end %>
+  </nav>
+<% end %>

data/app/views/lcp_ruby/navigation/_sidebar_item.html.erb

@@ -0,0 +1,38 @@
+<%# Recursive sidebar item rendering — expects local: item, depth (optional) %>
+<% depth = local_assigns.fetch(:depth, 0) %>
+<% if item.separator? %>
+  <li class="lcp-sidebar-separator"></li>
+<% elsif item.widget? %>
+  <%= render "lcp_ruby/navigation/widget_item", item: item %>
+<% elsif item.group? %>
+  <% group_classes = [ "lcp-sidebar-group", "lcp-sidebar-depth-#{depth}" ]
+     group_classes << "lcp-sidebar-group-active" if menu_item_active?(item, params[:lcp_slug])
+     group_classes << "lcp-sidebar-item--icon-only" if menu_item_icon_only?(item) %>
+  <li class="<%= group_classes.join(' ') %>">
+    <%= tag.button class: "lcp-sidebar-group-toggle", type: "button", data: { "lcp-toggle": "sidebar-group" }, aria: { label: menu_item_link_aria_label(item) } do %>
+      <%= render partial: "lcp_ruby/navigation/item_content", locals: { item: item, label_class: "lcp-sidebar-group-label" } %>
+      <%# Drop the framework's native badge + caret when the renderer
+          owns the inner content — same pattern as _top_item.html.erb.
+          Otherwise we'd render two carets (e.g. lcp_ruby/user_menu emits
+          its own lcp-user-menu__caret). %>
+      <% unless item.render_partial.present? %>
+        <%= menu_item_badge(item) %>
+        <span class="lcp-sidebar-group-arrow"></span>
+      <% end %>
+    <% end %>
+    <ul class="lcp-sidebar-group-children">
+      <% item.children.each do |child| %>
+        <%= render partial: "lcp_ruby/navigation/sidebar_item", locals: { item: child, depth: depth + 1 } %>
+      <% end %>
+    </ul>
+  </li>
+<% else %>
+  <% item_classes = [ "lcp-sidebar-item" ]
+     item_classes << "lcp-sidebar-item--icon-only" if menu_item_icon_only?(item) %>
+  <li class="<%= item_classes.join(' ') %>">
+    <%= render "lcp_ruby/navigation/link_or_button",
+          item: item,
+          klass: "lcp-sidebar-link#{' active' if menu_item_active?(item, params[:lcp_slug])}",
+          label_class: "lcp-sidebar-label" %>
+  </li>
+<% end %>

data/app/views/lcp_ruby/navigation/_sidebar_toggle.html.erb

@@ -0,0 +1,32 @@
+<%# Renders a sidebar_toggle: item — the button that opens the sidebar's
+    off-canvas drawer below breakpoint. Platform-owned UI chrome; no
+    destination URL.
+
+    Locals:
+      item:  LcpRuby::Metadata::MenuItem of type :sidebar_toggle
+      right: Boolean (optional) %>
+<% right = local_assigns.fetch(:right, false) %>
+<% li_index = local_assigns.fetch(:index, nil) %>
+<% aria_label = item.resolved_aria_label || I18n.t("lcp_ruby.nav.open_menu", default: "Open menu") %>
+<% root_classes = [ "lcp-nav-item", "lcp-nav-item--sidebar-toggle" ]
+   root_classes << "lcp-nav-item--right" if right
+   root_classes << "lcp-nav-item--icon-only" if menu_item_icon_only?(item) %>
+<%# Implicit pin: always — platform chrome never collapses.
+    data-original-index keeps the responsive_top_nav controller's order
+    snapshot consistent. Built via `tag.li(data: …)` so Rails escapes
+    every attribute value rather than via string interpolation. %>
+<% li_data = { controller: "lcp-sidebar-toggle", pin: "always" } %>
+<% li_data[:original_index] = li_index unless li_index.nil? %>
+<%= tag.li class: root_classes.join(' '), data: li_data do %>
+  <%= tag.button class: "lcp-nav-link lcp-nav-sidebar-toggle",
+                 type: "button",
+                 aria: { label: aria_label, controls: "lcp-sidebar", expanded: false },
+                 data: { action: "click->lcp-sidebar-toggle#toggle" } do %>
+    <span class="lcp-menu-icon" aria-hidden="true">
+      <i data-lucide="<%= item.icon || 'menu' %>"></i>
+    </span>
+    <% if item.label.present? %>
+      <span class="lcp-nav-label"><%= item.resolved_label(nil) %></span>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/lcp_ruby/navigation/_top.html.erb

@@ -0,0 +1,26 @@
+<%# Menu-driven top navigation with responsive modes.
+    Phase 1 — leftZone/rightZone targets for the lcp-responsive-top-nav
+    controller. The controller reads `data-responsive-mode` and, in
+    `overflow_more` mode, moves left-zone items that don't fit into a
+    synthesized *More* dropdown. Right-zone items are implicitly pinned
+    (never overflow). %>
+<%# `visible_top_menu_items` (Phase 2) wraps `visible_menu_items` and
+    auto-injects a synthesized sidebar_toggle when the policy calls for
+    it. `_sidebar.html.erb` continues to call `visible_menu_items` bare. %>
+<% items = visible_top_menu_items(menu_definition) %>
+<% left_items = menu_left_top_items(items) %>
+<% right_items = menu_right_top_items(items) %>
+<%= tag.nav class: "lcp-nav", data: responsive_top_nav_data_attrs(menu_definition) do %>
+  <ul class="lcp-nav-list lcp-nav-list--left" data-lcp-responsive-top-nav-target="leftZone">
+    <% left_items.each_with_index do |item, index| %>
+      <%= render partial: "lcp_ruby/navigation/top_item",
+                 locals: { item: item, right: false, index: index } %>
+    <% end %>
+  </ul>
+  <ul class="lcp-nav-list lcp-nav-list--right" data-lcp-responsive-top-nav-target="rightZone">
+    <% right_items.each do |item| %>
+      <%= render partial: "lcp_ruby/navigation/top_item",
+                 locals: { item: item, right: true, index: nil } %>
+    <% end %>
+  </ul>
+<% end %>

data/app/views/lcp_ruby/navigation/_top_item.html.erb

@@ -0,0 +1,112 @@
+<%# Per-item renderer for top_menu.
+    Locals:
+      item:  LcpRuby::Metadata::MenuItem (required)
+      right: Boolean (optional, default false) — when true, root <li> gets lcp-nav-item--right
+      index: Integer (optional) — original 0-based left-zone index. Threaded
+             from _top.html.erb's each_with_index loop. Powers
+             `data-original-index` for the lcp-responsive-top-nav controller. %>
+<% right = local_assigns.fetch(:right, false) %>
+<% li_index = local_assigns.fetch(:index, nil) %>
+<%# Per-item responsive data-* attrs (responsive_priority, pin,
+    hide_below, etc.). Only emitted on left-zone, non-separator items —
+    right-zone items never overflow, separators inherit position.
+    Passed through `tag.li(data: …)` below so Rails escapes attribute
+    values — never via string interpolation + html_safe. %>
+<% responsive_attrs = right ? {} : top_menu_item_responsive_data_attrs(item, index: li_index) %>
+<% if item.separator? %>
+  <li class="lcp-nav-separator<%= ' lcp-nav-item--right' if right %>"></li>
+<% elsif item.sidebar_toggle? %>
+  <%= render "lcp_ruby/navigation/sidebar_toggle",
+             item: item, right: right, index: li_index %>
+<% elsif item.widget? %>
+  <%# widget: drops the framework <a>/<button_to> wrapper entirely. %>
+  <%= render "lcp_ruby/navigation/widget_item", item: item %>
+<% elsif item.group? %>
+  <% root_classes = [ "lcp-nav-item", "lcp-nav-dropdown" ]
+     root_classes << "active" if menu_item_active?(item, params[:lcp_slug])
+     root_classes << "lcp-nav-item--right" if right
+     root_classes << "lcp-nav-item--icon-only" if menu_item_icon_only?(item) %>
+  <% group_disabled = !item.meets_enabled?(LcpRuby::Current.user) %>
+  <% root_classes << "lcp-nav-dropdown--disabled" if group_disabled %>
+  <%= tag.li class: root_classes.join(' '),
+             data: { controller: "lcp-dropdown" }.merge(responsive_attrs) do %>
+    <%# Group trigger. With disable_when: true the button is rendered
+        natively-disabled (no Stimulus needed — disabled buttons don't
+        fire activation events). With render: set, the renderer owns
+        the trigger's inner content and the wrapper drops its native
+        caret. %>
+    <% toggle_class = "lcp-nav-dropdown-toggle"
+       toggle_class += " lcp-menu-item--disabled" if group_disabled %>
+    <%= tag.button class: toggle_class, type: "button", disabled: group_disabled, aria: { label: menu_item_link_aria_label(item), haspopup: "menu", expanded: false } do %>
+      <%= render partial: "lcp_ruby/navigation/item_content", locals: { item: item, label_class: "lcp-nav-label", disabled: group_disabled } %><%= menu_item_badge(item) unless item.render_partial.present? %>
+      <% unless item.render_partial.present? %>
+        <span class="lcp-nav-caret"></span>
+      <% end %>
+    <% end %>
+    <%# Panel: replaced wholesale by render_panel: when present. The
+        partial gets `item:` (parent group) and `items:` (already
+        expanded + visibility/permission filtered children — provided
+        via panel_items_for). %>
+    <% if item.render_panel_partial.present? %>
+      <div class="lcp-nav-dropdown-menu lcp-nav-dropdown-menu--custom">
+        <%= render item.render_panel_partial_path, item: item, items: panel_items_for(item) %>
+      </div>
+    <% else %>
+    <ul class="lcp-nav-dropdown-menu">
+      <% item.children.each do |child| %>
+        <% if child.separator? %>
+          <li class="lcp-nav-dropdown-separator"></li>
+        <% elsif child.widget? %>
+          <%= render "lcp_ruby/navigation/widget_item", item: child %>
+        <% elsif child.group? %>
+          <% child_active = menu_item_active?(child, params[:lcp_slug]) %>
+          <% submenu_classes = [ "lcp-nav-submenu" ]
+             submenu_classes << "active" if child_active
+             submenu_classes << "lcp-nav-item--icon-only" if menu_item_icon_only?(child) %>
+          <li class="<%= submenu_classes.join(' ') %>" data-controller="lcp-submenu lcp-dropdown">
+            <%= tag.button class: "lcp-nav-submenu-toggle#{' active' if child_active}", type: "button", aria: { haspopup: "menu", expanded: false, label: menu_item_link_aria_label(child) } do %>
+              <%= render partial: "lcp_ruby/navigation/item_content", locals: { item: child, label_class: "lcp-nav-label" } %><%= menu_item_badge(child) %>
+              <span class="lcp-nav-submenu-arrow"></span>
+            <% end %>
+            <%# Site nav uses <nav> + links, not the ARIA application-menu
+                pattern — placing role="menu"/role="menuitem" here would
+                require keyboard arrow-key handling we don't ship. %>
+            <ul class="lcp-nav-submenu-menu">
+              <% child.children.each do |grandchild| %>
+                <% if grandchild.separator? %>
+                  <li class="lcp-nav-dropdown-separator"></li>
+                <% else %>
+                  <% gc_classes = [ "lcp-nav-dropdown-item" ]
+                     gc_classes << "lcp-nav-item--icon-only" if menu_item_icon_only?(grandchild) %>
+                  <li class="<%= gc_classes.join(' ') %>">
+                    <%= render "lcp_ruby/navigation/link_or_button",
+                          item: grandchild,
+                          klass: menu_item_active?(grandchild, params[:lcp_slug]) ? "active" : "" %>
+                  </li>
+                <% end %>
+              <% end %>
+            </ul>
+          </li>
+        <% else %>
+          <% di_classes = [ "lcp-nav-dropdown-item" ]
+             di_classes << "lcp-nav-item--icon-only" if menu_item_icon_only?(child) %>
+          <li class="<%= di_classes.join(' ') %>">
+            <%= render "lcp_ruby/navigation/link_or_button",
+                  item: child,
+                  klass: menu_item_active?(child, params[:lcp_slug]) ? "active" : "" %>
+          </li>
+        <% end %>
+      <% end %>
+    </ul>
+    <% end %>
+  <% end %>
+<% else %>
+  <% root_classes = [ "lcp-nav-item" ]
+     root_classes << "lcp-nav-item--right" if right
+     root_classes << "lcp-nav-item--icon-only" if menu_item_icon_only?(item) %>
+  <%= tag.li class: root_classes.join(' '), data: responsive_attrs do %>
+    <%= render "lcp_ruby/navigation/link_or_button",
+          item: item,
+          klass: menu_item_active?(item, params[:lcp_slug]) ? "active" : "" %>
+  <% end %>
+<% end %>

data/app/views/lcp_ruby/navigation/_widget_item.html.erb

@@ -0,0 +1,14 @@
+<%# Renders a `widget: true` menu item — drops the framework
+    `<a>`/`<button_to>` wrapper entirely so the renderer can emit
+    interactive HTML (search input, theme toggle, etc.). The
+    framework still owns the `<li class="lcp-menu-widget">` container
+    for layout consistency.
+
+    Locals:
+      item:  LcpRuby::Metadata::MenuItem with widget: true %>
+<% disabled = !item.meets_enabled?(LcpRuby::Current.user) %>
+<% li_class = "lcp-menu-widget#{' lcp-menu-item--disabled' if disabled}" %>
+<% aria = menu_item_link_aria_label(item) %>
+<%= tag.li(class: li_class, **(aria.present? ? { aria: { label: aria } } : {})) do %>
+  <%= render item.render_partial_path, item: item, disabled: disabled %>
+<% end %>