hibiki_rails 0.1.0

data/lib/generators/hibiki/rails/install/templates/connection.rb.tt

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Stock ActionCable boilerplate. Identify the connection here when your
+# channels need it, e.g. `identified_by :current_user`.
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/lib/generators/hibiki/rails/install/templates/hibiki_controller.js.tt

@@ -0,0 +1,7 @@
+// Registers the packaged hibiki client (the "hibiki-rails" module: the
+// engine's importmap pin, or the npm package in bundler apps) as the
+// "hibiki" Stimulus controller — the Ruby helpers hardcode that
+// identifier in data-controller. File-backed on purpose: `bin/rails
+// stimulus:manifest:update` re-derives this exact registration from the
+// filename, so it survives manifest rewrites.
+export { default } from "hibiki-rails"

data/lib/generators/hibiki/rails/island/island_generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "../generator_helpers"
+
+module Hibiki
+  module Rails
+    module Generators
+      # The island shape — the packaged generic "hibiki" controller drives
+      # the island, so there is NO per-component JS: a channel and a
+      # self-contained view partial stamped through Hibiki::Rails::Helpers
+      # (never raw data-hibiki-* attributes — that contract is private to
+      # the gem). Emits the same working mini-example as the stimulus
+      # shape, over the same Turbo-broadcast transport.
+      #
+      # Needs the one-time wiring from hibiki:rails:install (the register
+      # line + the Helpers include); post_install hints when it's missing.
+      class IslandGenerator < ::Rails::Generators::NamedBase
+        include GeneratorHelpers
+
+        source_root File.expand_path("templates", __dir__)
+
+        desc "Scaffolds a reactive island on the packaged \"hibiki\" controller: " \
+             "channel + a self-contained view partial, no per-component JS."
+
+        argument :view_path, type: :string, required: false, default: nil,
+                             desc: "Views directory under app/views (default: NAME)"
+
+        def create_channel
+          template "channel.rb.tt", "app/channels/#{file_path}_channel.rb"
+        end
+
+        def create_views
+          template "island.html.erb.tt", "app/views/#{view_dir}/_#{file_name}.html.erb"
+          template "display.html.erb.tt", "app/views/#{view_dir}/_#{file_name}_display.html.erb"
+        end
+
+        def post_install
+          say <<~MSG
+
+            Render it from any page:
+
+              <%= render "#{view_dir}/#{file_name}" %>
+
+          MSG
+          wiring_hint
+        end
+
+        private
+
+        def view_dir = view_path.presence || file_path
+
+        def wiring_hint
+          return if hibiki_registered? && helpers_included?
+
+          say_status :hint, "the packaged client is not fully wired " \
+                            "(register line and/or Helpers include) — run: " \
+                            "bin/rails g hibiki:rails:install", :yellow
+        end
+      end
+    end
+  end
+end

data/lib/generators/hibiki/rails/island/templates/channel.rb.tt

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Generated by hibiki:rails:island — a working mini-example: one state,
+# one derived, one action, one broadcasting effect. The concern owns the
+# actor, the root, the per-action batch, and the [channel_name, cid]
+# stream convention; this class is just the graph and its actions.
+class <%= class_name %>Channel < ApplicationCable::Channel
+  include Hibiki::Rails::Channel
+
+  def build_graph
+    @count = Hibiki::State.new(0)
+    doubled = Hibiki::Derived.new { @count.value * 2 }
+
+    Hibiki::Effect.new do
+      broadcast_replace target: "<%= display_dom_id %>",
+                        partial: "<%= view_dir %>/<%= file_name %>_display",
+                        locals: { count: @count.value, doubled: doubled.value }
+    end
+  end
+
+  # Public methods are client-invocable actions; keep helpers private.
+  def increment = @count.value += 1
+end

data/lib/generators/hibiki/rails/island/templates/display.html.erb.tt

@@ -0,0 +1,5 @@
+<%%# The root id is the broadcast replacement key — keep it in sync with the
+    channel effect's target. %>
+<p id="<%= display_dom_id %>">
+  count: <strong><%%= count %></strong> &middot; doubled: <strong><%%= doubled %></strong>
+</p>

data/lib/generators/hibiki/rails/island/templates/island.html.erb.tt

@@ -0,0 +1,14 @@
+<%%# Stamped through Hibiki::Rails::Helpers (hibiki_island / on) — never
+    write the underlying data attributes by hand, they are private to the
+    gem and version with its packaged JS. %>
+<%% cid = local_assigns.fetch(:cid) { SecureRandom.uuid } %>
+<%%= tag.div(**hibiki_island(<%= class_name %>Channel, cid:)) do %>
+  <%%= turbo_stream_from "<%= stream_name %>", cid %>
+
+  <%%# Paint-avoidance placeholder only: the controller subscribes AFTER the
+      Turbo stream above confirms, so the graph's first broadcast replaces
+      this. %>
+  <%%= render "<%= view_dir %>/<%= file_name %>_display", count: 0, doubled: 0 %>
+
+  <p><%%= tag.button("+1", **on(:increment)) %></p>
+<%% end %>

data/lib/generators/hibiki/rails/phlex/phlex_generator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "../generator_helpers"
+
+module Hibiki
+  module Rails
+    module Generators
+      # The Phlex component shape — the component owns the state
+      # (Hibiki::Reactive), the channel owns the transport: one render
+      # effect re-renders the same instance and transmits the HTML over
+      # the channel's own subscription (no Turbo streams involved).
+      # Emits a working mini-example: channel + component + an island
+      # wrapper component renderable from any page.
+      #
+      # Generated code needs the hibiki_phlex gem (and phlex-rails to
+      # render components from views) — warn, don't fail, when it isn't
+      # in the bundle, so the scaffold can come first.
+      class PhlexGenerator < ::Rails::Generators::NamedBase
+        include GeneratorHelpers
+
+        source_root File.expand_path("templates", __dir__)
+
+        desc "Scaffolds a reactive Phlex component: channel (transmit transport) + " \
+             "component + island wrapper. Requires the hibiki_phlex gem."
+
+        def warn_without_hibiki_phlex
+          require "hibiki/phlex"
+        rescue LoadError
+          say_status :warn, "hibiki_phlex is not in this bundle — the generated channel " \
+                            "calls Hibiki::Phlex.render_effect. Add `gem \"hibiki_phlex\"` " \
+                            "(and `gem \"phlex-rails\"` to render components from views).", :yellow
+        end
+
+        def create_channel
+          template "channel.rb.tt", "app/channels/#{file_path}_channel.rb"
+        end
+
+        def create_component
+          template "component.rb.tt", "app/components/#{file_path}.rb"
+        end
+
+        def create_island_component
+          template "island_component.rb.tt", "app/components/#{file_path}_island.rb"
+        end
+
+        def post_install
+          say <<~MSG
+
+            Render it from any page:
+
+              <%= render #{class_name}Island.new %>
+
+          MSG
+          register_hint
+        end
+
+        private
+
+        # The whole component is the transmitted fragment; its root id is
+        # the swap key.
+        def component_dom_id = name_parts.join("_")
+
+        def register_hint
+          return if hibiki_registered?
+
+          say_status :hint, "the packaged client is not registered — run: " \
+                            "bin/rails g hibiki:rails:install", :yellow
+        end
+      end
+    end
+  end
+end

data/lib/generators/hibiki/rails/phlex/templates/channel.rb.tt

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Generated by hibiki:rails:phlex — the component owns the state
+# (Hibiki::Reactive); the channel owns the transport. One render effect,
+# re-rendering THE SAME INSTANCE, its HTML transmitted over the channel's
+# own subscription and swapped in by the fragment's root DOM id.
+class <%= class_name %>Channel < ApplicationCable::Channel
+  include Hibiki::Rails::Channel
+
+  def build_graph
+    @component = <%= class_name %>.new
+
+    # First run is the dependency-collecting initial render.
+    Hibiki::Phlex.render_effect(@component) { |html| transmit({ html: }) }
+  end
+
+  # Public methods are client-invocable actions; delegate to the component.
+  def increment = @component.increment
+end

data/lib/generators/hibiki/rails/phlex/templates/component.rb.tt

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Generated by hibiki:rails:phlex — a working mini-example. The component
+# is a plain Ruby object: Hibiki::Reactive gives it per-instance signals
+# read as ordinary method calls (no .value anywhere), Rerenderable lets
+# the channel's render effect re-render this same instance, and Helpers
+# stamps the client's wire protocol.
+class <%= class_name %> < Phlex::HTML
+  include Hibiki::Reactive
+  include Hibiki::Phlex::Rerenderable
+  include Hibiki::Rails::Helpers
+
+  state :count, 0
+  derived(:doubled) { count * 2 }
+
+  def view_template
+    # The root id is the swap key for transmitted fragments — page-unique.
+    div(id: "<%= component_dom_id %>") do
+      p { "count: #{count} · doubled: #{doubled}" }
+      # Inside the swapped fragment on purpose: the island's root-scoped
+      # delegation keeps the button working across replacements.
+      button(**on(:increment)) { "+1" }
+    end
+  end
+
+  def increment
+    self.count += 1
+  end
+end

data/lib/generators/hibiki/rails/phlex/templates/island_component.rb.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# The island wrapper: one channel subscription per render, identified by
+# a per-page-load cid. Render from any page:
+#
+#   <%%= render <%= class_name %>Island.new %>
+class <%= class_name %>Island < Phlex::HTML
+  include Hibiki::Rails::Helpers
+
+  def view_template
+    div(**hibiki_island(<%= class_name %>Channel, cid: SecureRandom.uuid)) do
+      # A throwaway instance as a paint-avoidance placeholder; the
+      # channel's long-lived instance takes over from its first transmit.
+      render <%= class_name %>.new
+    end
+  end
+end

data/lib/generators/hibiki/rails/stimulus/stimulus_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "../generator_helpers"
+
+module Hibiki
+  module Rails
+    module Generators
+      # The ChannelController shape — stock Stimulus vocabulary
+      # (data-controller / data-action) over the Turbo-broadcast transport.
+      # Emits a working mini-example (one state, one derived, one action,
+      # one broadcasting effect) meant to be reshaped in place: a channel,
+      # a ChannelController subclass, and a self-contained view partial.
+      # Importmap apps need no wiring — the controller eager-loads from the
+      # controllers directory; jsbundling apps get the import/register pair
+      # appended to controllers/index.js (stimulus:manifest:update format).
+      class StimulusGenerator < ::Rails::Generators::NamedBase
+        include GeneratorHelpers
+
+        source_root File.expand_path("templates", __dir__)
+
+        desc "Scaffolds a reactive component on the subclassable ChannelController " \
+             "base: channel + Stimulus controller + a self-contained view partial."
+
+        argument :view_path, type: :string, required: false, default: nil,
+                             desc: "Views directory under app/views (default: NAME)"
+
+        def create_channel
+          template "channel.rb.tt", "app/channels/#{file_path}_channel.rb"
+        end
+
+        def create_controller
+          template "controller.js.tt", "app/javascript/controllers/#{file_path}_controller.js"
+        end
+
+        # Without an importmap there is no eager loader, so the manifest-style
+        # index.js must name every controller. Mirror the exact lines
+        # `stimulus:manifest:update` would emit for this file.
+        def register_controller
+          return if importmap?
+          return say_status :identical, INDEX_JS, :blue if wired?(INDEX_JS, %(register("#{identifier}")))
+          return manual_wiring(INDEX_JS, registration) unless exists?(INDEX_JS)
+
+          append_to_file INDEX_JS, "\n#{registration}"
+        end
+
+        def create_views
+          template "island.html.erb.tt", "app/views/#{view_dir}/_#{file_name}.html.erb"
+          template "display.html.erb.tt", "app/views/#{view_dir}/_#{file_name}_display.html.erb"
+        end
+
+        def post_install
+          say <<~MSG
+
+            Render it from any page:
+
+              <%= render "#{view_dir}/#{file_name}" %>
+
+          MSG
+        end
+
+        private
+
+        def view_dir = view_path.presence || file_path
+
+        # Stimulus::Manifest's class-name convention: Admin__CounterController.
+        def js_class_name = "#{name_parts.map(&:camelize).join('__')}Controller"
+
+        def registration
+          <<~JS
+            import #{js_class_name} from "./#{file_path}_controller"
+            application.register("#{identifier}", #{js_class_name})
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/generators/hibiki/rails/stimulus/templates/channel.rb.tt

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Generated by hibiki:rails:stimulus — a working mini-example: one state,
+# one derived, one action, one broadcasting effect. The concern owns the
+# actor, the root, the per-action batch, and the [channel_name, cid]
+# stream convention; this class is just the graph and its actions.
+class <%= class_name %>Channel < ApplicationCable::Channel
+  include Hibiki::Rails::Channel
+
+  def build_graph
+    @count = Hibiki::State.new(0)
+    doubled = Hibiki::Derived.new { @count.value * 2 }
+
+    Hibiki::Effect.new do
+      broadcast_replace target: "<%= display_dom_id %>",
+                        partial: "<%= view_dir %>/<%= file_name %>_display",
+                        locals: { count: @count.value, doubled: doubled.value }
+    end
+  end
+
+  # Public methods are client-invocable actions; keep helpers private.
+  def increment = @count.value += 1
+end

data/lib/generators/hibiki/rails/stimulus/templates/controller.js.tt

@@ -0,0 +1,16 @@
+import { ChannelController } from "hibiki-rails"
+
+// Drives <%= class_name %>Channel on the packaged ChannelController base.
+// Plain data-action tokens ("<%= identifier %>#increment") are
+// auto-forwarded as channel actions with no payload — declare a method
+// only when it must build a payload from the event:
+//
+//   setStep(event) {
+//     this.perform("set_step", { step: event.target.value })
+//   }
+export default class extends ChannelController {
+<% if nested? -%>
+  // The identifier "<%= identifier %>" cannot infer a namespaced channel.
+  static channel = "<%= class_name %>Channel"
+<% end -%>
+}

data/lib/generators/hibiki/rails/stimulus/templates/display.html.erb.tt

@@ -0,0 +1,5 @@
+<%%# The root id is the broadcast replacement key — keep it in sync with the
+    channel effect's target. %>
+<p id="<%= display_dom_id %>">
+  count: <strong><%%= count %></strong> &middot; doubled: <strong><%%= doubled %></strong>
+</p>

data/lib/generators/hibiki/rails/stimulus/templates/island.html.erb.tt

@@ -0,0 +1,11 @@
+<%% cid = local_assigns.fetch(:cid) { SecureRandom.uuid } %>
+<div data-controller="<%= identifier %>" data-<%= identifier %>-cid-value="<%%= cid %>">
+  <%%= turbo_stream_from "<%= stream_name %>", cid %>
+
+  <%%# Paint-avoidance placeholder only: the controller subscribes AFTER the
+      Turbo stream above confirms, so the graph's first broadcast replaces
+      this. %>
+  <%%= render "<%= view_dir %>/<%= file_name %>_display", count: 0, doubled: 0 %>
+
+  <p><button data-action="<%= identifier %>#increment">+1</button></p>
+</div>

data/lib/hibiki/rails/broadcasts.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hibiki
+  module Rails
+    # Rendering helpers for effects: thin wrappers over Turbo::StreamsChannel
+    # bound to the channel's #stream_name, so a render effect reads as
+    #
+    #   Hibiki::Effect.new do
+    #     broadcast_replace target: "count", partial: "counter/count",
+    #                       locals: { count: @count.value }
+    #   end
+    #
+    # All private — a public helper would become a client-invocable action
+    # (see the NOTE on Hibiki::Rails::Channel).
+    module Broadcasts
+      private
+
+      # Replace the element with DOM id `target` (accepts partial:/locals:,
+      # html:, or anything Turbo's renderer takes).
+      def broadcast_replace(target:, **rendering)
+        Turbo::StreamsChannel.broadcast_replace_to(*stream_name, target:, **rendering)
+      end
+
+      # Replace via Turbo 8 morphing (<turbo-stream action="replace"
+      # method="morph">): keeps focus/scroll where a plain replace resets.
+      def broadcast_morph(target:, **rendering)
+        Turbo::StreamsChannel.broadcast_replace_to(
+          *stream_name, target:, attributes: { method: :morph }, **rendering
+        )
+      end
+
+      # Tell the page to refresh itself (Turbo 8 morph-everything style).
+      # Pair with Debounce when many writes should mean one refresh.
+      def broadcast_refresh
+        Turbo::StreamsChannel.broadcast_refresh_to(*stream_name)
+      end
+
+      # The Morph-everything style as one call: an effect that tracks
+      # whatever `deps` reads and answers changes with a debounced page
+      # refresh — one refresh per burst of actions, not one per action.
+      # The initial (dependency-collecting) run broadcasts immediately, as
+      # every Effect.new does. Requires the channel context (graph_actor).
+      def broadcast_refresh_effect(wait: 0.25, &deps)
+        scheduler = Debounce.new(actor: graph_actor, wait:)
+        Hibiki::Effect.new(scheduler:) do
+          deps.call
+          broadcast_refresh
+        end
+      end
+    end
+  end
+end

data/lib/hibiki/rails/channel.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Hibiki
+  module Rails
+    # Include into an ActionCable channel to host one connection-scoped
+    # signal graph:
+    #
+    #   class CounterChannel < ApplicationCable::Channel
+    #     include Hibiki::Rails::Channel
+    #
+    #     def build_graph                # runs on the graph's own thread,
+    #       @count = Hibiki::State.new(0) # inside Hibiki.root
+    #       Hibiki::Effect.new { ... broadcast ... }
+    #     end
+    #
+    #     def increment = @count.value += 1  # actions are plain methods
+    #   end
+    #
+    # Lifecycle: `subscribed` rejects without a `cid` param, then builds the
+    # graph via #build_graph inside Hibiki.root on a dedicated GraphActor
+    # thread; every incoming action runs on that same thread inside one
+    # Hibiki.batch (N writes per action still mean one re-run per affected
+    # effect); `unsubscribed` disposes the root and stops the actor.
+    #
+    # A channel that overrides `subscribed`/`unsubscribed` itself must call
+    # `super`.
+    #
+    # NOTE: everything this module adds is private (except the
+    # #perform_action override, which ActionCable already exposes) — any
+    # other public method would be picked up by Channel#action_methods and
+    # become client-invocable.
+    module Channel
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(Broadcasts)
+      end
+
+      module ClassMethods
+        private
+
+        # #build_graph is a lifecycle hook, not a client-invocable action:
+        # keep it out of action_methods even when an app defines it public
+        # (a client performing "build_graph" would rebuild the graph and
+        # leak the old root).
+        def internal_methods = super + [:build_graph]
+      end
+
+      # ActionCable's single dispatch point for incoming actions. The whole
+      # action body is posted to the graph's thread and wrapped in one
+      # batch — cable threads never touch the graph. Spike-verified: batch
+      # per action is all the coalescing the replace-partial style needs.
+      #
+      # `rescue_from` handlers still run (dispatch_action applies them
+      # inside the job, now on the graph thread); what they don't handle
+      # propagates to the actor's on_error — ::Rails.error by default.
+      def perform_action(data)
+        # A nil actor means the subscription was rejected or already torn
+        # down; drop the action rather than blow up the cable thread.
+        @__hibiki_actor&.post { Hibiki.batch { super(data) } }
+      end
+
+      private
+
+      def subscribed
+        super
+        return reject if cid.blank?
+
+        @__hibiki_actor = build_graph_actor
+        # The block runs owned + untracked (Hibiki.root); the effects it
+        # creates do their dependency-collecting first run right here, on
+        # the graph thread.
+        @__hibiki_actor.post { @__hibiki_root = Hibiki.root { build_graph } }
+        Hibiki::Rails.registry.register(self)
+      end
+
+      # ActionCable calls this even after a rejected subscription — hence
+      # the guard. Queue#close inside GraphActor#stop lets the posted
+      # dispose drain before the worker exits.
+      def unsubscribed
+        super
+        return unless @__hibiki_actor
+
+        Hibiki::Rails.registry.unregister(self)
+        @__hibiki_actor.post { @__hibiki_root.dispose }
+        @__hibiki_actor.stop
+      end
+
+      # Build the signal graph: create states/deriveds/effects as instance
+      # variables so actions can reach them. Runs once, on the graph's
+      # thread, inside Hibiki.root.
+      def build_graph
+        raise NotImplementedError, "#{self.class} must implement #build_graph"
+      end
+
+      # Per-page-load graph identity, supplied by the page's subscription
+      # (each tab is its own graph). Override to derive identity elsewhere.
+      def cid = params[:cid]
+
+      # Streamables the channel broadcasts to, matching the page's
+      #   <%= turbo_stream_from channel_name, cid %>
+      # Override when the page uses different streamables.
+      def stream_name = [channel_name, cid]
+
+      # Seam for a future pooled executor with per-graph ordering; today,
+      # one worker thread per graph.
+      def build_graph_actor = GraphActor.new(name: "hibiki-#{channel_name}"[0, 15])
+
+      # The channel's graph executor, for helpers that schedule work back
+      # onto the graph thread (Broadcasts#broadcast_refresh_effect).
+      def graph_actor = @__hibiki_actor
+    end
+  end
+end

data/lib/hibiki/rails/debounce.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Hibiki
+  module Rails
+    # An Effect scheduler (Vue's ReactiveEffect scheduler; the core seam is
+    # pinned by the "scheduler:" group in hibiki's spec/effect_spec.rb) that
+    # coalesces invalidation bursts into at most one run per `wait` window —
+    # trailing edge, so the run sees then-current state.
+    #
+    # Hibiki.batch already coalesces the writes WITHIN one action; this is
+    # for the cross-action case, where many actions in quick succession
+    # should mean one re-run — Turbo 8's broadcast_refresh style wants one
+    # page refresh per burst, not one per action.
+    #
+    # Threading: the scheduler fires on the graph's actor thread (effects
+    # only re-run there), and the disarm+run is posted back to the same
+    # actor, so @armed needs no lock. The timer thread only sleeps. If the
+    # actor stops before the timer fires, post returns false and the run is
+    # dropped — teardown wins, same as Effect#run no-opping once disposed.
+    class Debounce
+      def initialize(actor:, wait:)
+        @actor = actor
+        @wait = wait
+        @armed = false
+      end
+
+      def call(effect)
+        return if @armed
+
+        @armed = true
+        Thread.new do
+          sleep @wait
+          @actor.post do
+            @armed = false
+            effect.run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hibiki/rails/engine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Railties leans on ActiveSupport's core extensions being loaded; require
+# them explicitly so hibiki_rails also loads outside a booted Rails app
+# (the gem's own unit specs, a console).
+require "active_support"
+require "active_support/core_ext"
+require "rails/engine"
+
+module Hibiki
+  module Rails
+    # An Engine (not a bare Railtie) so the vendored client rides Rails'
+    # own :append_assets_path initializer: app/assets/javascripts/hibiki.js
+    # lands on the host app's asset paths and Propshaft serves it like an
+    # app-local file — turbo-rails-style distribution, no install-time copy.
+    class Engine < ::Rails::Engine
+      # Dev reloading: before code reloads, dispose every live graph — its
+      # effects hold blocks from the stale class versions. Also fires once
+      # at boot, when the registry is empty (harmless no-op).
+      initializer "hibiki_rails.reloader" do |app|
+        app.config.to_prepare { Hibiki::Rails.registry.dispose_all }
+      end
+
+      # importmap-rails apps get the "hibiki-rails" pin with zero config (the
+      # guard keeps jsbundling/vite apps booting; they consume the npm
+      # package — or a manual copy — instead).
+      initializer "hibiki_rails.importmap", before: "importmap" do |app|
+        next unless app.config.respond_to?(:importmap)
+
+        app.config.importmap.paths << Engine.root.join("config/importmap.rb")
+      end
+    end
+  end
+end