weft 0.1.0 → 0.2.0

data/lib/weft/component.rb

@@ -1,7 +1,22 @@
 # frozen_string_literal: true
 
+require "arbre"
 require "uri"
+
+require "weft/context"
 require "weft/context/interception"
+require "weft/context/traversal"
+require "weft/dsl/actions"
+require "weft/dsl/containers"
+require "weft/dsl/inclusions"
+require "weft/dsl/params"
+require "weft/dsl/recoveries"
+require "weft/dsl/triggers"
+require "weft/dsl/updates"
+require "weft/error"
+require "weft/registry"
+require "weft/registry/eligibility"
+require "weft/router/streaming"
 
 module Weft
   # Base class for all Weft components. Extends Arbre::Component with:
@@ -11,13 +26,14 @@ module Weft
   class Component < Arbre::Component
     extend Weft::Registry::Eligibility
 
-    include Weft::DSL::Attributes
+    include Weft::DSL::Params
     include Weft::DSL::Recoveries
     include Weft::DSL::Triggers
     include Weft::DSL::Inclusions
     include Weft::DSL::Updates
     include Weft::DSL::Actions
     include Weft::DSL::Containers
+    include Weft::Context::Traversal
 
     class << self
       # Class-level path override (string or proc). Inherited by subclasses.
@@ -45,12 +61,12 @@ module Weft
       # Inferred routability from declared state, ignoring any explicit
       # override (see Weft::Registry::Eligibility#routable?). A component is
       # independently addressable when it declares interactive behavior —
-      # attributes, actions, refresh triggers, or push config. Pure
+      # params, actions, refresh triggers, or push config. Pure
       # presentational components (none of those) register but are never served.
       # Subclasses fall back to this when they have no override of their own, so
       # an abstract parent does not disable concrete children.
       def inferred_routable?
-        attributes.any? || actions.any? || refresh_triggers.any? || !push_config.nil?
+        params.any? || actions.any? || refresh_triggers.any? || !push_config.nil?
       end
 
       def inherited(subclass)
@@ -59,29 +75,42 @@ module Weft
       end
 
       # Render this component as an HTML string, outside any Arbre DSL context.
-      # Used by the Router for partial responses, and available to users for
-      # testing, REPL exploration, or any standalone rendering need.
+      # The kwargs are pseudo-wire: exactly what a request's query string
+      # would carry. Used by the Router for partial responses, and available
+      # to users for testing, REPL exploration, or any standalone rendering need.
       #
       #   StatCard.render(status: "shipped")  # => "<div id=\"...\">...</div>"
-      def render(**attributes)
+      def render(**wire_params)
         klass = self
-        Weft::Context.new({}, nil) do
-          insert_tag(klass, **attributes)
+        Weft::Context.new({}, nil, wire_params: wire_params) do
+          insert_tag(klass)
         end.to_s
       end
 
+      # Value classes whose instances may suffix a DOM id. An allowlist:
+      # arrays, hashes, and rich objects stringify to selector-hostile junk
+      # ("member-roster-[]" breaks querySelector), so only honest scalars ride.
+      SCALAR_ID_CLASSES = [String, Symbol, Numeric, TrueClass, FalseClass].freeze
+
       # Compute the would-be DOM ID for an instance of this class given a
-      # plain attrs hash, without instantiating. The Router uses this to
-      # populate the `:component_id` auto-injected attribute when a recovery
-      # target opts in. Single source of truth; the instance method delegates.
-      def weft_id_for(attrs = {})
+      # plain params hash, without instantiating. Single source of truth for
+      # the convention; the instance method delegates, and the Router falls
+      # back to this when it can't construct an instance to ask.
+      # The primary value suffixes only when it's a non-blank scalar — nil,
+      # "", and non-scalar values all derive the same bare class id, so a
+      # component's identity is stable across the ways "no value" arrives.
+      def weft_dom_id_for(params = {})
         base = name.underscore.tr("/", "-").tr("_", "-")
-        primary_value = attrs.respond_to?(:values) ? attrs.values.first : nil
-        primary_value ? "#{base}-#{primary_value}" : base
+        primary_value = params.respond_to?(:values) ? params.values.first : nil
+        identity_suffix?(primary_value) ? "#{base}-#{primary_value}" : base
       end
 
       private
 
+      def identity_suffix?(value)
+        SCALAR_ID_CLASSES.any? { |klass| value.is_a?(klass) } && !value.to_s.empty?
+      end
+
       # Gem-default name-based path derivation, plus the well-formedness guard.
       # Mirrors {Weft::Page.default_page_path}: a routable class whose demodulized
       # name has no usable stem (e.g. a bare +Component+ or +Foo::Component+)
@@ -110,35 +139,69 @@ module Weft
     recovers from: Weft::NotFound, with: :not_found_component
     recovers from: StandardError, with: :error_component
 
+    # Params resolve at construction, not build: the context (which carries
+    # the wire source and any staged hand-off) is the constructor's one
+    # argument, and resolving here makes `params` available even before
+    # `super` in user build bodies — the "compute chrome from params, then
+    # super" pattern needs that.
+    def initialize(*)
+      super
+      @params = assembled_params
+    end
+
     def build(attributes = {})
-      schema = self.class.attributes
-      @attrs = Weft::Attributes.extract_from(attributes, using: schema)
-      super(attributes.except(*schema.keys))
-      self.id = weft_id
+      apply_received_fallback(attributes) unless arbre_context.respond_to?(:take_received!)
+      warn_declared_chrome_collisions(attributes)
+      super
+      self.id = weft_dom_id
+      claim_dom_slot!
       apply_refresh_attrs
       apply_push_attrs
     end
 
-    # URL to this component's Weft route with current attrs as query params.
-    # Pass overrides to change specific attr values in the URL.
+    # URL to this component's Weft route with current params as query string.
+    # Pass overrides to change specific param values in the URL.
     #
     #   weft_url                          # => "/_components/orders_panel?status=shipped&page=1"
     #   weft_url(page: 2)                 # => "/_components/orders_panel?status=shipped&page=2"
     #   weft_url(status: nil, page: 1)    # => "/_components/orders_panel?page=1"
     def weft_url(**overrides)
       path = self.class.resolved_component_path
-      params = @attrs.to_h.merge(overrides).compact
-      params.empty? ? path : "#{path}?#{URI.encode_www_form(params)}"
+      query = serializable_params.merge(overrides).compact
+      query.empty? ? path : "#{path}?#{URI.encode_www_form(query)}"
     end
 
-    # Convention-based DOM ID: dasherized class name + primary attribute value.
-    def weft_id
-      self.class.weft_id_for(@attrs ? @attrs.to_h : {})
+    # Convention-based DOM ID: dasherized class name + primary wire-param value.
+    def weft_dom_id
+      self.class.weft_dom_id_for(serializable_params)
     end
 
     private
 
-    # URL to this component's Weft route with current attrs (no overrides).
+    # Speak for this fragment's DOM slot, or abandon the render.
+    #
+    # A response delivers at most one fragment per DOM id — that is simply how
+    # an out-of-band swap is addressed — so when a slot is already spoken for,
+    # continuing would be work thrown away. `super` has run by here but the
+    # component's own build body has not, and that body is where the cost is:
+    # the derivations it forces, the children it renders. Leaving now costs
+    # the caller nothing, because Arbre attaches a tag to its parent only
+    # after the build returns.
+    #
+    # Only roots arbitrate. Duplicate ids among a fragment's own descendants
+    # are that fragment's business, not the response's, and a response that
+    # has nothing to arbitrate carries no register at all.
+    def claim_dom_slot!
+      slots = arbre_context.respond_to?(:slots) && arbre_context.slots
+      return unless slots && parent.equal?(arbre_context)
+      return if slots.add?(id)
+
+      # Caught by Weft::Router::OOBIncludes#attempt_companion, which turns this
+      # into a warning naming both declarations.
+      throw Weft::Context::SLOT_TAKEN, id
+    end
+
+    # URL to this component's Weft route with current params (no overrides).
     # Used internally by apply_refresh_attrs.
     def refresh_url
       weft_url
@@ -155,22 +218,25 @@ module Weft
 
     # Apply SSE connection attributes for components declaring `pushes`.
     # Uses innerHTML swap — the wrapper element (holding the SSE connection)
-    # must persist across pushes.
+    # must persist across pushes. sse-close names the protocol event the
+    # Router emits when a stream exhausts its push attempts; on receiving it,
+    # htmx-ext-sse closes the EventSource instead of auto-reconnecting.
     def apply_push_attrs
       config = self.class.push_config
       return unless config&.key?(:every)
 
       set_attribute "hx-ext", "sse"
       set_attribute "sse-connect", stream_url
-      set_attribute "sse-swap", weft_id
+      set_attribute "sse-swap", weft_dom_id
+      set_attribute "sse-close", Weft::Router::Streaming::CLOSE_EVENT
       set_attribute "hx-swap", "innerHTML"
     end
 
-    # URL to this component's SSE stream endpoint with current attrs.
+    # URL to this component's SSE stream endpoint with current wire params.
     def stream_url
       path = "#{self.class.resolved_component_path}/#{Weft.configuration.stream_suffix}"
-      params = @attrs.to_h.compact
-      params.empty? ? path : "#{path}?#{URI.encode_www_form(params)}"
+      query = serializable_params.compact
+      query.empty? ? path : "#{path}?#{URI.encode_www_form(query)}"
     end
   end
 end

data/lib/weft/configuration.rb

@@ -2,19 +2,23 @@
 
 require "logger"
 
+require "active_support/core_ext/string/inflections"
+
 module Weft
   class Configuration
     DEFAULT_COMPONENT_PATH = ->(klass) { "/_components/#{klass.name.to_s.delete_suffix('Component').underscore}" }
     VALID_HTMX_ERRORS = %i[fragment redirect].freeze
     VALID_INCLUDE_SSE_EXT = [:auto, true, false].freeze
+    CLASS_KNOBS = %i[error_component error_page not_found_page not_found_component].freeze
     LOG_LEVELS = {
       debug: Logger::DEBUG, info: Logger::INFO, warn: Logger::WARN,
       error: Logger::ERROR, fatal: Logger::FATAL, unknown: Logger::UNKNOWN
     }.freeze
-    private_constant :DEFAULT_COMPONENT_PATH, :VALID_HTMX_ERRORS, :VALID_INCLUDE_SSE_EXT, :LOG_LEVELS
+    private_constant :DEFAULT_COMPONENT_PATH, :VALID_HTMX_ERRORS, :VALID_INCLUDE_SSE_EXT,
+                     :CLASS_KNOBS, :LOG_LEVELS
 
-    attr_reader :component_path, :htmx_errors, :include_sse_ext, :log_level, :stream_suffix
-    attr_accessor :include_htmx, :auto_reload, :reload_paths, :verbose_error_pages, :router_logging
+    attr_reader :component_path, :htmx_errors, :include_sse_ext, :log_level, :push_attempts, :stream_suffix
+    attr_accessor :include_htmx, :verbose_error_pages, :router_logging
     attr_writer :error_component, :error_page, :not_found_page, :not_found_component
 
     # @api private
@@ -24,12 +28,11 @@ module Weft
       @component_path = DEFAULT_COMPONENT_PATH
       @include_htmx = true
       @include_sse_ext = :auto
-      @auto_reload = false
-      @reload_paths = []
       @router_logging = false
       @verbose_error_pages = true
       @htmx_errors = :fragment
       @log_level = :info
+      @push_attempts = 3
       @stream_suffix = "_stream"
       @static_assets = {}
     end
@@ -70,6 +73,18 @@ module Weft
       @log_level = value
     end
 
+    # Consecutive failed pushes tolerated on an SSE stream before the Router
+    # closes it (the last failure's recovery frame renders with
+    # attempts_remaining 0, then the close event fires). Gem-wide default;
+    # override per component via `pushes every:, attempts:`.
+    def push_attempts=(value)
+      unless value.is_a?(Integer) && value >= 1
+        raise ArgumentError, "push_attempts must be an integer >= 1, got #{value.inspect}"
+      end
+
+      @push_attempts = value
+    end
+
     # The path segment that marks a component's SSE stream endpoint. The leading
     # slash is supplied by Weft, so set the bare segment (e.g. "stream", "sse").
     # It's appended as "<component_path>/<stream_suffix>" on both sides: the
@@ -134,6 +149,23 @@ module Weft
       @not_found_component ||= Weft::Defaults::NotFoundComponent
     end
 
+    # Re-resolve the class-valued knobs after a code reload. A knob assigned at
+    # boot holds that moment's class object; a reloader that redefines the
+    # constant would otherwise leave the knob serving the stale definition until
+    # restart. The configure_autoloading reload hook calls this after each
+    # reload; hand-rolled reloaders should call it from their own hook. A knob
+    # whose constant no longer resolves (mid-unload, or the class was deleted)
+    # keeps its last-known class.
+    def refresh_stale_classes!
+      CLASS_KNOBS.each do |knob|
+        klass = instance_variable_get(:"@#{knob}")
+        next unless klass.is_a?(Class) && klass.name
+
+        current = klass.name.safe_constantize
+        instance_variable_set(:"@#{knob}", current) if current.is_a?(Class) && !current.equal?(klass)
+      end
+    end
+
     private
 
     def register_static_assets_bundle(name:, root:, from:)

data/lib/weft/context/expansion.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "arbre"
+require "uri"
+
+require "weft/action"
+require "weft/context/modifiers"
+require "weft/error"
+
+module Weft
+  class Context < Arbre::Context
+    # The element-kwarg expansion engine: turns Weft kwargs on any element
+    # into htmx attributes. Mixed into Weft::Context; Interception#insert_tag
+    # invokes it on the root context (via +arbre_context+).
+    #
+    # This module owns the INTERACTION rank of the kwarg grammar — the kwargs
+    # that generate request wiring, first match wins: `action:` (Symbol),
+    # `navigate:` (Hash), `loads:` (Class), or a registered preset name
+    # (Class or URL String). Value shape is the claim — a String action:
+    # stays honest form HTML — and a claimed kwarg that cannot resolve
+    # raises Weft::InvalidUsage rather than leaking into the HTML. The
+    # MODIFIER rank (trigger:/push_url:/confirm:/swap:/target:) lives in
+    # Context::Modifiers; the hx-* builders and tree lookups the expanders
+    # assemble from live in Context::Wiring.
+    module Expansion
+      # @api private
+      def expand_weft_attrs(attrs, for_class: nil)
+        attrs = attrs.dup
+        mods = Modifiers::MODIFIER_KEYS.to_h { |k| [k, attrs.delete(k)] }
+        validate_with_ownership!(attrs)
+        expanded = expand_action(attrs, for_class: for_class) || expand_navigate(attrs) ||
+                   expand_loads(attrs, mods) || expand_preset(attrs, mods)
+        expanded ? overlay_modifiers(expanded, mods) : passthrough_modifiers(attrs, mods)
+      end
+
+      # @api private
+      # Whether an attrs hash carries any Weft kwarg.
+      def weft_kwarg?(hash) = interaction_kwarg?(hash) || modifier_kwarg?(hash) || claimed?(hash, :with)
+
+      private
+
+      def interaction_kwarg?(hash)
+        hash[:action].is_a?(Symbol) || claimed?(hash, :navigate) ||
+          claimed?(hash, :loads) || find_preset_kwarg(hash)
+      end
+
+      def modifier_kwarg?(hash) = Modifiers::CLAIMING_MODIFIER_KEYS.any? { |k| hash.key?(k) }
+
+      # A nil value means absent — the conditional-call-site idiom
+      # (`tooltip: maybe_class`), mirroring Arbre's nil-attribute omission.
+      def claimed?(hash, key) = hash.key?(key) && !hash[key].nil?
+
+      # with: belongs to loads:/preset expansion; anywhere else it would
+      # silently ride into the HTML as junk chrome.
+      def validate_with_ownership!(attrs)
+        return unless claimed?(attrs, :with)
+        return if claimed?(attrs, :loads) || find_preset_kwarg(attrs)
+
+        raise Weft::InvalidUsage,
+              "with: supplies wire params to a loads:/preset target — it needs one of those kwargs alongside it"
+      end
+
+      def expand_action(attrs, for_class: nil)
+        action_name = attrs[:action]
+        return unless action_name.is_a?(Symbol)
+
+        component = find_action_context(action_name)
+        unless component
+          raise Weft::InvalidUsage, "action: #{action_name.inspect} matches no action declared by an " \
+                                    "enclosing component — check the name against its performs/transfers declarations"
+        end
+
+        action = component.class.action_for(action_name)
+        htmx = action.to_htmx_attrs(component)
+        expanded = attrs.except(:action).merge(htmx)
+        return augment_for_form(expanded, action, htmx) if for_class && for_class <= Arbre::HTML::Form
+
+        expanded
+      end
+
+      def expand_navigate(attrs)
+        return unless claimed?(attrs, :navigate)
+
+        overrides = attrs[:navigate]
+        unless overrides.is_a?(Hash)
+          raise Weft::InvalidUsage, "navigate: expects a Hash of wire-param overrides, got #{overrides.inspect}"
+        end
+
+        component = navigation_component!
+        validate_navigate_keys!(component, overrides)
+        attrs.except(:navigate).merge(navigate_attrs(component, overrides))
+      end
+
+      # The enclosing component navigate: re-fetches — present and routable,
+      # or the wiring could only 404.
+      def navigation_component!
+        component = find_nearest_component
+        raise Weft::InvalidUsage, "navigate: has no enclosing component whose route it could re-fetch" if component.nil?
+
+        unless component.class.routable?
+          raise Weft::InvalidUsage,
+                "navigate: re-fetches #{component.class.name}, which is not routable — its URL can only 404. " \
+                "Drop the class's abstract!/dependent! marking, or reach a routable ancestor with enclosing + loads:"
+        end
+
+        component
+      end
+
+      # navigate: re-fetches the component's own route, and the resulting
+      # render is standalone — only the component's own declared wire params
+      # survive that request. Anything else would silently vanish.
+      def validate_navigate_keys!(component, overrides)
+        bad = overrides.keys.reject { |k| component.class.params.key?(k) }
+        return if bad.empty?
+
+        raise Weft::InvalidUsage,
+              "navigate: #{bad.map(&:inspect).join(', ')} not declared as wire params of #{component.class} — " \
+              "only its own declared params survive the standalone re-fetch " \
+              "(declare `param #{bad.first.inspect}` on it, or reach an ancestor with enclosing + loads:)"
+      end
+
+      def expand_loads(attrs, mods)
+        return unless claimed?(attrs, :loads)
+
+        target_class = attrs[:loads]
+        unless target_class.is_a?(Class)
+          raise Weft::InvalidUsage, "loads: expects a component Class, got #{target_class.inspect}"
+        end
+
+        ensure_routable_target!(target_class, :loads)
+        validate_loads_kwargs!(mods)
+        remaining = attrs.except(:loads, :with)
+        remaining.merge(loads_attrs(target_class, resolve_with(attrs), mods[:swap], mods[:target]))
+      end
+
+      def expand_preset(attrs, mods)
+        preset_key, target_class = find_preset_kwarg(attrs)
+        return unless preset_key
+
+        build_preset_attrs(attrs, mods, preset_key, target_class, Weft.preset(preset_key))
+      end
+
+      # A preset value is either a target Class (derive the URL from it) or a
+      # ready-made URL String (retry-style — the caller already has the URL).
+      def find_preset_kwarg(attrs)
+        attrs.find do |k, v|
+          next false if v.nil? || !Weft.preset(k)
+          raise Weft::InvalidUsage, "#{k}: expects a component Class or a URL String, got #{v.inspect}" unless
+            v.is_a?(Class) || v.is_a?(String)
+
+          true
+        end
+      end
+
+      def build_preset_attrs(attrs, mods, preset_key, target_or_url, preset)
+        ensure_routable_target!(target_or_url, preset_key) if target_or_url.is_a?(Class)
+        target = mods[:target] || preset[:target]
+        raise Weft::InvalidUsage, "#{preset_key}: requires target: (e.g., target: :self)" unless target
+
+        htmx = preset_wiring(attrs, target_or_url, preset, mods[:swap] || preset[:swap], target)
+        attrs.except(preset_key, :with).merge(htmx)
+      end
+
+      def resolve_with(attrs) = attrs[:with] || find_nearest_component&.serializable_params || {}
+
+      def validate_loads_kwargs!(mods)
+        raise Weft::InvalidUsage, "loads: requires swap: (e.g., swap: :fill)" unless mods[:swap]
+        raise Weft::InvalidUsage, "loads: requires target: (e.g., target: :self)" unless mods[:target]
+      end
+
+      # A load target is fetched over the wire at click time — a non-routable
+      # class wires a URL that can only 404, silently. Raise at render instead.
+      # String URLs (retry-style presets) are unverifiable and pass through;
+      # transfers to: is exempt by design (a render target, not a route).
+      def ensure_routable_target!(target_class, kwarg)
+        return if target_class.routable?
+
+        raise Weft::InvalidUsage,
+              "#{kwarg}: targets #{target_class.name}, which is not routable — the generated URL can only 404. " \
+              "Mark it routable! (or drop its abstract!/dependent! marking) so it can serve standalone fetches"
+      end
+    end
+  end
+end

data/lib/weft/context/interception.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "arbre"
+
 module Weft
   class Context < Arbre::Context
     # Mixin for Arbre elements that need to forward Weft kwargs
@@ -12,11 +14,29 @@ module Weft
     module Interception
       def insert_tag(klass, *args, &)
         h = args.last
-        if h.is_a?(Hash) && arbre_context.is_a?(Weft::Context) && arbre_context.weft_kwarg?(h)
-          args[-1] = arbre_context.expand_weft_attrs(h, for_class: klass)
+        if h.is_a?(Hash) && arbre_context.is_a?(Weft::Context)
+          h = stage_received_kwargs(klass, h)
+          h = arbre_context.expand_weft_attrs(h, for_class: klass) if arbre_context.weft_kwarg?(h)
+          args[-1] = h
         end
         super
       end
+
+      private
+
+      # Kwargs naming a target's declared `receives` keys are hand-offs, not
+      # chrome: pull them out before Arbre sees them and stage them on the
+      # context register for the instance about to be constructed.
+      def stage_received_kwargs(klass, attrs)
+        return attrs unless klass.respond_to?(:received_params)
+
+        keys = klass.received_params.keys & attrs.keys
+        return attrs if keys.empty?
+
+        attrs = attrs.dup
+        arbre_context.stage_received(klass, keys.to_h { |k| [k, attrs.delete(k)] })
+        attrs
+      end
     end
   end
 end

data/lib/weft/context/modifiers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "arbre"
+
+require "weft/action"
+
+module Weft
+  class Context < Arbre::Context
+    # The modifier rank of the element-kwarg grammar: kwargs that adjust
+    # whatever htmx wiring the interaction rank generated, applied as
+    # call-site overrides after expansion. swap:/target: revert to plain
+    # chrome when no interaction kwarg claims the element (target: is real
+    # HTML — <a target="_blank">); trigger:/push_url:/confirm: map
+    # standalone (all inherit down the DOM in htmx).
+    module Modifiers
+      MODIFIER_KEYS = %i[trigger push_url confirm swap target].freeze
+
+      # Modifier kwargs that pull an element into expansion on their own.
+      # :target is deliberately absent — bare target: stays honest HTML
+      # chrome, untouched.
+      CLAIMING_MODIFIER_KEYS = (MODIFIER_KEYS - [:target]).freeze
+
+      # Warn-once registry for standalone swap: kwargs, keyed by the nearest
+      # component class (nil outside any component).
+      def self.warned_standalone_swaps
+        @warned_standalone_swaps ||= Set.new
+      end
+
+      private
+
+      # Call-site modifiers win over whatever the interaction expander
+      # generated (an action's declared target, a preset's default swap, ...).
+      def overlay_modifiers(expanded, mods)
+        expanded["hx-swap"] = Action.resolve_swap(mods[:swap]) if mods[:swap]
+        expanded["hx-target"] = resolve_target(mods[:target]) if mods[:target]
+        apply_universal_modifiers(expanded, mods)
+      end
+
+      # No interaction kwarg claimed the element: swap:/target: revert to
+      # chrome — swap with a warning, since swapping nothing is suspect but
+      # not wrong — while the universal modifiers still map.
+      def passthrough_modifiers(attrs, mods)
+        warn_standalone_swap(mods[:swap]) if mods[:swap]
+        attrs[:swap] = mods[:swap] if mods[:swap]
+        attrs[:target] = mods[:target] if mods[:target]
+        apply_universal_modifiers(attrs, mods)
+      end
+
+      def apply_universal_modifiers(attrs, mods)
+        attrs["hx-trigger"] = resolve_trigger(mods[:trigger]) if mods[:trigger]
+        attrs["hx-push-url"] = mods[:push_url].to_s if mods[:push_url]
+        attrs["hx-confirm"] = mods[:confirm] if mods[:confirm]
+        attrs
+      end
+
+      def warn_standalone_swap(value)
+        klass = find_nearest_component&.class
+        return unless Modifiers.warned_standalone_swaps.add?(klass)
+
+        Weft.logger.warn "swap: #{value.inspect} has no effect without an interaction kwarg " \
+                         "(action:, navigate:, loads:, or a preset)#{" in #{klass}" if klass} — " \
+                         "passing it through as an HTML attribute"
+      end
+
+      def resolve_target(target)
+        case target
+        when :self then "this"
+        when String then target
+        else
+          # Arbre element reference — extract #id
+          target.respond_to?(:id) ? "##{target.id}" : target.to_s
+        end
+      end
+
+      def resolve_trigger(value) = Action.resolve_trigger(value)
+    end
+  end
+end