hibiki_rails 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb224598ce236ad6d2f55b9648fbcb4644a478e1c86db2839dc3648207cd0605
-  data.tar.gz: 2c4c73dbc34338aca84fde08bf520e47dcc5920a7e4a6403ce9b4ee6d7ec62b6
+  metadata.gz: 2776ffca09f5d60a467d985550fb12c36570a5a22fd5eb7b0a54ee45c30a68e0
+  data.tar.gz: 3a05960da6f7ab9d80a2f6574f6413491610314fd3917a62b48c48127b866830
 SHA512:
-  metadata.gz: 5cace159e074313892f3736f5bed6220e1852fc71d85ee5b063af80c31471662f492d945ad57b5589543b54f43d2f4bac3dce3fdf8718fc0b8b1df18d0f5e756
-  data.tar.gz: 99a518942cc899684e94951d88fea9a08524c83327ae61cc5a924356b16485b33a14cc51fc9fcac3d8dc67d71f96c41ef5f8915d0b97349bc4ed0f74db3de556
+  metadata.gz: 29f7fc27b77dbb5e32e94440afc233da170b4095b77bac378426f834a47da38065b5b35881c63dcefe4e3c0053849f0fd2fd23d87d80708aebbec207fe765e93
+  data.tar.gz: 5f85d166f5ff9dec3dc23a4d8e4aae9fbece2f53ee63b10a163622e799c77f6b989743f27a935db3c1915b9bb56c96332462b983ccf3fc0cd7ab9ea8f5477fa4

data/CHANGELOG.md

@@ -4,6 +4,67 @@ The gem and the npm package are released in lockstep and share these version
 numbers — `app/assets/javascripts/hibiki.js` is a single copy served both ways,
 so importmap and bundler apps always resolve identical client code.
 
+## 0.8.0 — 2026-08-15
+
+### Added
+
+**`on(..., fallback: true)` — progressive enhancement over native controls.**
+A control's native behavior — a link's href, a form's `action=` — is its
+degraded path. Only a `ready` island intercepts the gesture and performs the
+channel action; while connecting, offline, or stalled the client stands aside
+entirely and the browser does what the markup says. A dead-but-undetected
+socket is caught too: when the subscription reports the send failed, the
+client settles the trip and runs the native behavior by hand
+(`form.submit()` / `location.assign`) — the gesture never left, so it cannot
+double-fire. Two guarantees ride along: `confirm:` still gates the native
+path while scripts run (a destructive submit must not slip past the dialog
+just because the island is down), and before any native submit the client
+freshens the form's `authenticity_token` from the `csrf-token` meta tag —
+forms repainted by a channel are rendered without a session and carry no
+token, so freshening is load-bearing, not an edge case. A truly script-free
+page still holds its first-paint token and needs no help.
+
+**`transmit_url` — mirror graph state into the address bar.**
+`transmit_value`'s URL sibling: an equality-gated effect transmits `{ url: }`
+and the client `history.replaceState`s the bar to it. Never `pushState` — the
+URL is a mirror of graph state, not a history entry, so there is no popstate
+choreography and Back leaves the page normally. Same-origin only; the client
+resolves the URL against the page's own origin and refuses anything else.
+
+**The scaffold now generates the whole degraded-path pattern.** The query
+object grows a URL half — `from_params` and canonical `url_params` (defaults
+omitted) — shared by the controller's first paint, the island's
+subscribe-params seeding (the graph starts from the URL's state, so its first
+broadcast repaints what the server painted instead of resetting to defaults),
+the pagination hrefs, and the channel's `transmit_url`, which also mirrors an
+open form's URL so a reload mid-edit lands on the standard edit page. The
+controls become one GET form to the index: live, the controls fire channel
+actions; dead, Enter, Apply, and the direction button submit natively and
+`from_params` answers. Edit is a real link to the edit page, Destroy a real
+`button_to` DELETE form, and the page control's links carry real hrefs — all
+with `fallback: true`, in both view layers and every css variant.
+
+**The scaffold's list gains an inline create form, on by default.** The New
+link (now inside the island) opens a channel-owned create form at the top of
+the list — its own `ReactiveForm` instance, so an open row edit and an open
+create never fight over state — and degrades to the standard new page. The
+shared row form is parameterized (`dom:`, `save_action:`, `cancel_action:`,
+`field_action:`, `cancel_with:`) and serves both uses; `--skip-create` omits
+the whole surface. Generated forms also gate live validation on `dirty?`, so
+a freshly opened form paints clean instead of flagging every blank field.
+
+**`hibiki:rails:multiselect` serves the inline create form too.** The
+dropdown appears with the full option list and an empty selection; each
+checkbox's toggle names the form it belongs to, so an open row edit and the
+create form never cross-write, even side by side.
+
+### Changed
+
+**Re-running the scaffold over a pre-0.8.0 app refreshes a same-styled shared
+page control in place** — the regenerated list passes the new `url:` local,
+which the old shared partial does not declare. A page control written under a
+different `--css` style is still kept and noticed, never restyled.
+
 ## 0.7.0 — 2026-08-12
 
 ### Added

data/app/assets/javascripts/hibiki.js

@@ -52,6 +52,11 @@
 //                 data-hibiki-debounce="250"           ms to let the gesture settle
 //                 data-hibiki-confirm="Are you sure?"  window.confirm gate
 //                 data-hibiki-reset="false"            keep a submitted form's inputs
+//                 data-hibiki-fallback="true"          the control's native behavior
+//                 (a link's navigation, a form's action=) is its fallback: while the
+//                 island is `ready` the event is intercepted and only the channel
+//                 action fires; in every other state the client stands aside and the
+//                 browser does what the markup says
 //   value sites   data-hibiki-value="<name>"           reactive-value placeholder;
 //                 the server's transmit_value message updates every match
 //
@@ -122,6 +127,27 @@ const formPayload = (form) => {
   return payload
 }
 
+// Before a fallback form goes native, re-stamp its CSRF token from the
+// page's csrf-token meta — which is first-paint fresh and session-valid.
+// Server-side repaints render without a session (ApplicationController
+// .render has none), so a repainted form embeds a stale token or none at
+// all; and this only ever runs with scripts alive, which is exactly when
+// the DOM may have been repainted. A truly script-free page still holds
+// its first-paint token and never needed the help.
+const freshenToken = (control) => {
+  if (!(control instanceof HTMLFormElement)) return
+  const meta = document.querySelector('meta[name="csrf-token"]')
+  if (!meta) return
+  let input = control.querySelector('input[name="authenticity_token"]')
+  if (!input) {
+    input = document.createElement("input")
+    input.type = "hidden"
+    input.name = "authenticity_token"
+    control.appendChild(input)
+  }
+  input.value = meta.content
+}
+
 // The subclassable base: one channel subscription per controller element,
 // identified by a per-page-load cid (data-<identifier>-cid-value).
 export class ChannelController extends Controller {
@@ -212,13 +238,25 @@ export class ChannelController extends Controller {
   // ActionCable's own Subscription#perform already writes `action`.)
   //
   // Returns the seq so a caller that knows which control fired can attach
-  // it; nobody has to.
+  // it; nobody has to. Returns undefined instead when the socket turned
+  // out to be closed under a subscription still believed live.
   perform(action, payload = {}) {
     const seq = ++this.seq
     payload.hbk = seq
     if (this.subscribed) {
       this.beginBusy(seq)
-      this.subscription.perform(action, payload)
+      // Action Cable's Subscription#perform returns false when the socket
+      // is not open — the gap between the socket dying and the connection
+      // monitor noticing, during which `subscribed` still says live. The
+      // frame went nowhere: settle rather than letting the trip stall out
+      // at the ceiling, and stamp `offline` now instead of when the
+      // monitor catches up. The monitor still owns reconnecting; its
+      // `connected` callback restores `ready` exactly as after a real gap.
+      if (this.subscription.perform(action, payload) === false) {
+        this.settle(seq)
+        this.linkClosed()
+        return undefined
+      }
       return seq
     }
     // Queue rather than drop while the subscription is still coming up.
@@ -368,7 +406,7 @@ export class ChannelController extends Controller {
     this.received(data)
   }
 
-  // Server → DOM (transmit transport). Two message shapes:
+  // Server → DOM (transmit transport). Three message shapes:
   //
   // { value: { name, text } } — a reactive value (transmit_value): write
   // the text into every [data-hibiki-value=name] placeholder, document-
@@ -376,11 +414,13 @@ export class ChannelController extends Controller {
   // textContent assignment keeps values text-only and preserves each
   // site's own tag/classes, so per-placeholder styling survives updates.
   //
+  // { url } — mirror graph state into the address bar (transmit_url).
+  //
   // { html } — a fragment: swap it in by its root id.
   //
   // Anything else is not ours to interpret. Subclasses may override, but
   // should call super (or handle `value`) to keep reactive values live.
-  received({ html, value }) {
+  received({ html, value, url }) {
     if (value) {
       const selector = `[data-hibiki-value="${CSS.escape(value.name)}"]`
       for (const site of document.querySelectorAll(selector)) {
@@ -388,6 +428,7 @@ export class ChannelController extends Controller {
       }
       return
     }
+    if (url !== undefined) return this.replaceUrl(url)
     if (!html) return
     const template = document.createElement("template")
     template.innerHTML = html
@@ -396,6 +437,17 @@ export class ChannelController extends Controller {
     }
   }
 
+  // replaceState, never pushState: the URL is a mirror of graph state, not
+  // a history entry — Back needs no popstate handling and leaves the page
+  // normally. Same-origin only, so a channel can move the bar solely
+  // within its own app (replaceState would throw on a cross-origin URL;
+  // refusing keeps it silent and intentional).
+  replaceUrl(url) {
+    const resolved = new URL(url, window.location.href)
+    if (resolved.origin !== window.location.origin) return
+    history.replaceState(history.state, "", resolved)
+  }
+
   // `static channel = "..."` wins; otherwise infer Rails-style from the
   // identifier: "counter" → CounterChannel, "my-thing" → MyThingChannel.
   channelName() {
@@ -574,9 +626,27 @@ export default class HibikiController extends ChannelController {
     if (!token) return
     const action = token.slice(event.type.length + 2)
 
-    // Before the confirm, not after: declining must not let the form
-    // navigate away.
-    if (event.type === "submit") event.preventDefault()
+    // A fallback control's native behavior IS the degraded path: unless
+    // the island is `ready`, stand aside — no perform, no queueing — and
+    // the browser follows the href or submits the form to its own
+    // action=. Deliberately not the connect-window queue: a queued gesture
+    // renders nothing until the link comes up, while the control's
+    // destination answers immediately. Two touches before stepping back:
+    // a confirm: still gates the native behavior (scripts are running, so
+    // a destructive submit must not slip past the dialog), and a form's
+    // authenticity_token is freshened — server-rendered repaints carry no
+    // session, so their forms embed a stale token or none at all.
+    const fallback = "hibikiFallback" in control.dataset
+    if (fallback && this.state !== "ready") {
+      const message = control.dataset.hibikiConfirm
+      if (message && !window.confirm(message)) return event.preventDefault?.()
+      return freshenToken(control)
+    }
+
+    // Before the confirm, not after: declining must not let the form (or
+    // a fallback control's navigation) proceed. Optional call because the
+    // `visible` pseudo-event arrives as a plain object.
+    if (event.type === "submit" || fallback) event.preventDefault?.()
 
     const message = control.dataset.hibikiConfirm
     if (message && !window.confirm(message)) return
@@ -601,7 +671,15 @@ export default class HibikiController extends ChannelController {
     }
     // perform stamps `hbk` after this merge, so a field literally named hbk
     // loses to the seq rather than corrupting it.
-    this.trackControl(this.perform(action, payload), control)
+    const seq = this.perform(action, payload)
+    // The send failed on a socket believed live (perform already marked the
+    // island offline). The gesture's default was prevented in dispatch, so
+    // for a fallback control honor the contract by hand — the action never
+    // left the machine, so the native behavior cannot double-fire.
+    if (seq === undefined && "hibikiFallback" in control.dataset) {
+      return this.fallthrough(control)
+    }
+    this.trackControl(seq, control)
     // Resetting is right for an "add" form and wrong for an edit one: it
     // runs synchronously, before the server has replied, so a failed commit
     // would discard what the user typed.
@@ -610,6 +688,19 @@ export default class HibikiController extends ChannelController {
     }
   }
 
+  // The native behavior the intercepted event would have had. submit(),
+  // not requestSubmit(): the submit event already fired and was prevented,
+  // and re-dispatching it would loop straight back through the delegated
+  // listener.
+  fallthrough(control) {
+    if (control instanceof HTMLFormElement) {
+      freshenToken(control)
+      control.submit()
+    } else if (control.href) {
+      window.location.assign(control.href)
+    }
+  }
+
   // One timer per (control, action): two events on one element debounce
   // independently, and a second control's typing never cancels the first's.
   debounce(control, action, wait, fire) {

data/lib/generators/hibiki/rails/multiselect/templates/concern.rb.tt

@@ -26,7 +26,7 @@ module <%= concern_module_name %>
 
 <% if search? -%>
       @<%= target_plural %>_query = Hibiki::State.new("")
-      # Only read while a row is being edited. The filter narrows this list
+      # Only read while a form is open. The filter narrows this list
       # and nothing else — the selection survives it.
       @<%= target_plural %>_options = Hibiki::Derived.new do
         @db_version.value
@@ -40,7 +40,7 @@ module <%= concern_module_name %>
         { options: rows.first(OPTIONS_LIMIT), truncated: rows.size > OPTIONS_LIMIT }
       end
 <% else -%>
-      # Only read while a row is being edited.
+      # Only read while a form is open.
       @<%= target_plural %>_options = Hibiki::Derived.new do
         @db_version.value
         { options: <%= target_class_name %>.order(:<%= label_column %>).pluck(:<%= label_column %>, :id) }
@@ -54,11 +54,19 @@ module <%= concern_module_name %>
       # Each edit starts with an unfiltered dropdown.
       @<%= target_plural %>_query.value = ""
     end
+
+    # The inline create form's dropdown, likewise. `super if defined?` —
+    # on a scaffold without inline create there is nothing to wrap and
+    # this hook is inert.
+    def new_form(data)
+      super if defined?(super)
+      @<%= target_plural %>_query.value = ""
+    end
 <% end -%>
 
     def list_locals
       locals = super
-      return locals unless locals[:editing_id]
+      return locals unless locals[:editing_id] || locals[:creating]
 
       extras = locals.fetch(:extras, {})
       locals.merge(extras: extras.merge(<%= extras_key %>: <%= extras_value_source %>))
@@ -66,16 +74,18 @@ module <%= concern_module_name %>
   end
 
   # One checkbox toggled: a SET, not a toggle — the client sends the box's
-  # checked state, so two tabs converge.
+  # checked state, so two tabs converge. `dom` names the form the box
+  # belongs to — a row edit and the inline create form can be open at once.
   def <%= toggle_action %>(data)
-    return unless @editing_id.peek
+    form = multiselect_form(data["dom"].to_s)
+    return unless form
 
     # Untrusted id — resolve it against the table before it enters the form.
     id = <%= target_class_name %>.where(id: data["id"]).pick(:id)
     return unless id
 
-    ids = @form.<%= ids_attr %>
-    @form.<%= ids_attr %> = data["checked"] ? ids | [id] : ids - [id]
+    ids = form.<%= ids_attr %>
+    form.<%= ids_attr %> = data["checked"] ? ids | [id] : ids - [id]
   end
 <% if search? -%>
 
@@ -84,4 +94,15 @@ module <%= concern_module_name %>
     @<%= target_plural %>_query.value = data["query"].to_s
   end
 <% end -%>
+
+  private
+
+  # Which open form a toggle aims at; nil drops the write.
+  def multiselect_form(dom)
+    if dom.end_with?("_new")
+      @new_form if @creating&.peek
+    else
+      @form if @editing_id.peek
+    end
+  end
 end

data/lib/generators/hibiki/rails/multiselect_helpers.rb

@@ -173,7 +173,7 @@ module Hibiki
           [%("checked"), "id", "#{form_ref}.#{ids_attr}.include?(id)",
            %(id: "\#{#{dom_ref}}_#{target_singular}_\#{id}"),
            *css_args(:checkbox_sm),
-           %(**on(:#{toggle_action}, event: :change, with: { id: id }))]
+           %(**on(:#{toggle_action}, event: :change, with: { id: id, dom: #{dom_ref} }))]
         end
 
         def filter_field_args

data/lib/generators/hibiki/rails/multiselect_injections.rb

@@ -145,7 +145,11 @@ module Hibiki
 
         def inject_component_render
           path = view_path("row_form.rb")
-          line = "        render #{component_class_name}.new(form: @form, dom: dom, extras: @extras)\n"
+          # Two vintages of row_form: dom became a keyword (@dom) when the
+          # form was parameterized for inline create; before that it was a
+          # private method.
+          dom = wired?(path, "@dom = dom") ? "@dom" : "dom"
+          line = "        render #{component_class_name}.new(form: @form, dom: #{dom}, extras: @extras)\n"
           return if wired?(path, "Multiselect.new")
           return manual_wiring(path, line) unless wired?(path, PHLEX_FIELDSET_CLOSE)
 
@@ -218,7 +222,8 @@ module Hibiki
         def thread_extras_erb
           [view_path("_list.html.erb"), view_path("_#{row_partial}.html.erb"),
            view_path("_#{row_form_partial}.html.erb")].each do |path|
-            gsub_file path, /^(<%# locals: \(.*?)\) -%>/, '\1, extras: {}) -%>', verbose: false
+            # /m: the row form's locals header wraps onto a second line.
+            gsub_file path, /^(<%# locals: \(.*?)\) -%>/m, '\1, extras: {}) -%>', verbose: false
           end
           # `form: form` appears exactly once per file, inside the one render
           # call that must pass extras on.

data/lib/generators/hibiki/rails/scaffold/scaffold_generator.rb

@@ -44,6 +44,8 @@ module Hibiki
                                        desc: "No windowing at all — skips both pagination modes"
         class_option :skip_search, type: :boolean, default: false,
                                    desc: "Omit the search box and the LIKE terms behind it"
+        class_option :skip_create, type: :boolean, default: false,
+                                   desc: "Omit the inline create form — New always navigates"
         class_option :page_size, type: :numeric, default: 20, desc: "Rows per page"
         class_option :phlex, type: :boolean, default: false,
                              desc: "Emit Phlex components under app/views instead of ERB templates"

data/lib/generators/hibiki/rails/scaffold_controller/scaffold_controller_generator.rb

@@ -57,6 +57,8 @@ module Hibiki
                                        desc: "No windowing at all — skips both pagination modes"
         class_option :skip_search, type: :boolean, default: false,
                                    desc: "Omit the search box and the LIKE terms behind it"
+        class_option :skip_create, type: :boolean, default: false,
+                                   desc: "Omit the inline create form — New always navigates"
         class_option :page_size, type: :numeric, default: 20,
                                  desc: "Rows per page"
         class_option :skip_routes, type: :boolean,
@@ -297,6 +299,7 @@ module Hibiki
 
         def infinite? = options[:infinite_scroll]
         def searchable? = schema.searchable? && !options[:skip_search]
+        def inline_create? = !options[:skip_create]
 
         # The view layer. It reaches the templates and nothing else: the graph,
         # the query object, the form, the actions and the whole data-hibiki

data/lib/generators/hibiki/rails/scaffold_controller/templates/daisyui/views/_pagination.html.erb.tt

@@ -7,13 +7,19 @@
      the page-number window) arrives as a local from the list partial. The
      `--css=` marker below is how a later scaffold run detects a variant
      mismatch — keep it. -%>
-<%%# locals: (page: 1, page_count: 1, pages: [], anchor:, id:) -%>
+<%%# locals: (page: 1, page_count: 1, pages: [], anchor:, id:, url: nil) -%>
 <%%# Shared page control (--css=<%= css_variant %>), rendered above and below
-    every scaffolded list. The links are anchors to the list, so a click also
-    does the browser's own fragment jump; data-turbo="false" keeps Turbo Drive
-    out. `on` returns a { data: } hash — merge, don't splat, or the anchor
-    stops scrolling. %>
-<%% page_data = ->(n) { { turbo: false }.merge(on(:go_to_page, with: { page: n })[:data]) } %>
+    every scaffolded list. `url` is an optional ->(page) { path } builder:
+    when given, links carry real hrefs (plus the fragment) and fallback —
+    a dead island degrades to native navigation. Without it the links are
+    plain anchors to the list, as before. data-turbo="false" keeps Turbo
+    Drive out. `on` returns a { data: } hash — merge, don't splat, or the
+    anchor stops scrolling. %>
+<%% href = ->(n) { url ? "#{url.(n)}#{anchor}" : anchor } %>
+<%% page_data = ->(n) do
+     { turbo: false }.merge(on(:go_to_page, with: { page: n },
+                               fallback: url ? true : nil)[:data])
+   end %>
 <%%# The wrapper always renders (so idiomorph has a node to pair with) and
     stays bare — layout classes here would leave dead space when empty. %>
 <div id="<%%= id %>">
@@ -24,7 +30,7 @@
       <%% if page == 1 %>
         <span class="join-item btn btn-disabled" aria-disabled="true">«</span>
       <%% else %>
-        <%%= link_to "«", anchor, class: "join-item btn", rel: "prev",
+        <%%= link_to "«", href.(page - 1), class: "join-item btn", rel: "prev",
                     "aria-label": "Previous page", data: page_data.(page - 1) %>
       <%% end %>
 
@@ -34,7 +40,7 @@
         <%% elsif n == page %>
           <span class="join-item btn btn-active" aria-current="page"><%%= n %></span>
         <%% else %>
-          <%%= link_to n, anchor, class: "join-item btn",
+          <%%= link_to n, href.(n), class: "join-item btn",
                       "aria-label": "Page #{n}", data: page_data.(n) %>
         <%% end %>
       <%% end %>
@@ -42,7 +48,7 @@
       <%% if page == page_count %>
         <span class="join-item btn btn-disabled" aria-disabled="true">»</span>
       <%% else %>
-        <%%= link_to "»", anchor, class: "join-item btn", rel: "next",
+        <%%= link_to "»", href.(page + 1), class: "join-item btn", rel: "next",
                     "aria-label": "Next page", data: page_data.(page + 1) %>
       <%% end %>
     </nav>

data/lib/generators/hibiki/rails/scaffold_controller/templates/none/views/_pagination.html.erb.tt

@@ -10,13 +10,19 @@
      the page-number window) arrives as a local from the list partial. The
      `--css=` marker below is how a later scaffold run detects a variant
      mismatch — keep it. -%>
-<%%# locals: (page: 1, page_count: 1, pages: [], anchor:, id:) -%>
+<%%# locals: (page: 1, page_count: 1, pages: [], anchor:, id:, url: nil) -%>
 <%%# Shared page control (--css=<%= css_variant %>), rendered above and below
-    every scaffolded list. The links are anchors to the list, so a click also
-    does the browser's own fragment jump; data-turbo="false" keeps Turbo Drive
-    out. `on` returns a { data: } hash — merge, don't splat, or the anchor
-    stops scrolling. %>
-<%% page_data = ->(n) { { turbo: false }.merge(on(:go_to_page, with: { page: n })[:data]) } %>
+    every scaffolded list. `url` is an optional ->(page) { path } builder:
+    when given, links carry real hrefs (plus the fragment) and fallback —
+    a dead island degrades to native navigation. Without it the links are
+    plain anchors to the list, as before. data-turbo="false" keeps Turbo
+    Drive out. `on` returns a { data: } hash — merge, don't splat, or the
+    anchor stops scrolling. %>
+<%% href = ->(n) { url ? "#{url.(n)}#{anchor}" : anchor } %>
+<%% page_data = ->(n) do
+     { turbo: false }.merge(on(:go_to_page, with: { page: n },
+                               fallback: url ? true : nil)[:data])
+   end %>
 <%%# The wrapper always renders, so idiomorph always has a node to pair with. %>
 <div id="<%%= id %>">
   <%% if page_count > 1 %>
@@ -26,7 +32,7 @@
       <%% if page == 1 %>
         <span aria-disabled="true">«</span>
       <%% else %>
-        <%%= link_to "«", anchor, rel: "prev",
+        <%%= link_to "«", href.(page - 1), rel: "prev",
                     "aria-label": "Previous page", data: page_data.(page - 1) %>
       <%% end %>
 
@@ -36,14 +42,14 @@
         <%% elsif n == page %>
           <strong aria-current="page"><%%= n %></strong>
         <%% else %>
-          <%%= link_to n, anchor, "aria-label": "Page #{n}", data: page_data.(n) %>
+          <%%= link_to n, href.(n), "aria-label": "Page #{n}", data: page_data.(n) %>
         <%% end %>
       <%% end %>
 
       <%% if page == page_count %>
         <span aria-disabled="true">»</span>
       <%% else %>
-        <%%= link_to "»", anchor, rel: "next",
+        <%%= link_to "»", href.(page + 1), rel: "next",
                     "aria-label": "Next page", data: page_data.(page + 1) %>
       <%% end %>
     </nav>

data/lib/generators/hibiki/rails/scaffold_controller/templates/phlex/daisyui/views/pagination.rb.tt

@@ -6,13 +6,15 @@
 # frozen_string_literal: true
 
 # Shared page control (--css=<%= css_variant %>), rendered above and below
-# every scaffolded list. The links are anchors to the list, so a click also
-# does the browser's own fragment jump; data-turbo="false" keeps Turbo Drive
-# out.
+# every scaffolded list. `url` is an optional ->(page) { path } builder:
+# when given, links carry real hrefs (plus the fragment) and fallback — a
+# dead island degrades to native navigation. Without it the links are plain
+# anchors to the list, as before. data-turbo="false" keeps Turbo Drive out.
 class Views::Shared::Pagination < Views::Base
 <%= phlex_includes(:link_to, hibiki: true) %>
 
-<%= initializer_source([%w[page 1], %w[page_count 1], %w[pages []], ["anchor"], ["id"]]) %>
+<%= initializer_source([%w[page 1], %w[page_count 1], %w[pages []], ["anchor"], ["id"],
+                        %w[url nil]]) %>
 
   def view_template
     # The wrapper always renders (so idiomorph has a node to pair with) and
@@ -53,7 +55,11 @@ class Views::Shared::Pagination < Views::Base
   # The STRING "false", not the boolean — Phlex omits false-valued attributes.
   # And merge, don't splat: the anchor needs its own data attribute too.
   def step(text, n, label:, rel: nil)
-    link_to text, @anchor, class: "join-item btn", rel:, "aria-label": label,
-            data: { turbo: "false" }.merge(on(:go_to_page, with: { page: n })[:data])
+    link_to text, href(n), class: "join-item btn", rel:, "aria-label": label,
+            data: { turbo: "false" }.merge(on(:go_to_page, with: { page: n },
+                                              fallback: @url ? true : nil)[:data])
   end
+
+  # A real href when a url builder was given; a bare anchor otherwise.
+  def href(n) = @url ? "#{@url.(n)}#{@anchor}" : @anchor
 end

data/lib/generators/hibiki/rails/scaffold_controller/templates/phlex/none/views/pagination.rb.tt

@@ -6,16 +6,18 @@
 # frozen_string_literal: true
 
 # Shared page control (--css=<%= css_variant %>), rendered above and below
-# every scaffolded list. The links are anchors to the list, so a click also
-# does the browser's own fragment jump; data-turbo="false" keeps Turbo Drive
-# out.
+# every scaffolded list. `url` is an optional ->(page) { path } builder:
+# when given, links carry real hrefs (plus the fragment) and fallback — a
+# dead island degrades to native navigation. Without it the links are plain
+# anchors to the list, as before. data-turbo="false" keeps Turbo Drive out.
 #
 # Unstyled, so the current page changes ELEMENT (strong) — there is no class
 # to carry the signal.
 class Views::Shared::Pagination < Views::Base
 <%= phlex_includes(:link_to, hibiki: true) %>
 
-<%= initializer_source([%w[page 1], %w[page_count 1], %w[pages []], ["anchor"], ["id"]]) %>
+<%= initializer_source([%w[page 1], %w[page_count 1], %w[pages []], ["anchor"], ["id"],
+                        %w[url nil]]) %>
 
   def view_template
     # The wrapper always renders, so idiomorph always has a node to pair with.
@@ -55,7 +57,11 @@ class Views::Shared::Pagination < Views::Base
   # The STRING "false", not the boolean — Phlex omits false-valued attributes.
   # And merge, don't splat: the anchor needs its own data attribute too.
   def step(text, n, label:, rel: nil)
-    link_to text, @anchor, rel:, "aria-label": label,
-            data: { turbo: "false" }.merge(on(:go_to_page, with: { page: n })[:data])
+    link_to text, href(n), rel:, "aria-label": label,
+            data: { turbo: "false" }.merge(on(:go_to_page, with: { page: n },
+                                              fallback: @url ? true : nil)[:data])
   end
+
+  # A real href when a url builder was given; a bare anchor otherwise.
+  def href(n) = @url ? "#{@url.(n)}#{@anchor}" : @anchor
 end