phlex-reactive 0.9.5 → 0.10.0

data/lib/phlex/reactive/component.rb

@@ -57,13 +57,24 @@ module Phlex
     #     end
     #   end
     #
-    # Assembled from three cohesive concerns (issue #115) — one include, zero
-    # public API change:
-    #   * Component::DSL      — the five declaration registries (via
-    #     Component::Registry) + from_identity
-    #   * Component::Identity — reactive_token + the hot-path ivar precomputation
-    #   * Component::Helpers  — reply/js, reactive_attrs/root, on/on_client,
-    #     the field/select/text bindings, and the nested-attributes helpers
+    # Assembled from cohesive concerns (issue #115, restructured in #180) — one
+    # include, zero public API change. The include stack, in order:
+    #   * Phlex::Reactive::Streamable — the render/broadcast/#id surface (mixed in
+    #     first, so its methods sit below the component's own).
+    #   * Phlex::Reactive::ClientBindings — the CLIENT-ONLY surface (issue #180),
+    #     itself Component::DSL (the declaration registries via Component::Registry
+    #     + from_identity) + Component::Helpers (reply/js, reactive_attrs/root,
+    #     on/on_client, the field/select/text bindings, reactive_show/filter/
+    #     compute, and the nested-attributes helpers). ClientBindings is the ONE
+    #     implementation of that surface, shared with the standalone client-only
+    #     include; it carries NO token machinery.
+    #   * Component::Identity — reactive_token + the hot-path ivar precomputation.
+    #     Its presence is what makes the server-action macros (action/
+    #     reactive_record/reactive_state) legal here — they raise on a
+    #     ClientBindings-only class that lacks it.
+    #   * Component::Lazy — reactive_lazy (deferred initial mount, issue #165).
+    # So a full, token-bearing reactive component is a SUPERSET of a client-only
+    # one, not a fork.
     module Component
       extend ActiveSupport::Concern
       include Phlex::Reactive::Streamable
@@ -111,9 +122,12 @@ module Phlex
         end
       end
 
-      include DSL
+      # ClientBindings (issue #180) is the client-only surface (DSL + Helpers),
+      # tokenless and Streamable-free. Component includes it as the ONE
+      # implementation, then layers Identity + Lazy (and Streamable, above) on
+      # top — a token-bearing root is a superset of the client-only one.
+      include ClientBindings
       include Identity
-      include Helpers
       include Lazy
     end
   end

data/lib/phlex/reactive/show_conditions.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    # The ONE conditions language behind reactive_show / reactive_show_targets
+    # (issue #180 Phase A). It compiles Ruby-native values into a DNF wire shape
+    # and evaluates that shape in Ruby with semantics identical to the client —
+    # so first-paint `hidden:` (server) and live toggling (client) can never
+    # drift (the shared spec/fixtures/show_predicate_vectors.json proves it).
+    #
+    # THE VALUE LANGUAGE (used by every if:/if_any:/unless: term):
+    #   String/Symbol/Integer/Float  -> equals (stringified)
+    #   true / false                 -> equals "true"/"false" (checkbox state)
+    #   nil                          -> equals "" (blank)
+    #   Array                        -> in (each stringified; empty raises)
+    #   (10..)                       -> gte 10
+    #   (..10)                       -> lte 10
+    #   (...10)                      -> lt 10
+    #   (10..20)                     -> gte 10 AND lte 20 (two terms, one group)
+    # Under unless: each term is NEGATED (De Morgan):
+    #   scalar -> not; Array -> ∉ (AND of nots); Range -> the complement
+    #   predicate (¬gte→lt, ¬lte→gt, ¬lt→gte), and a BOUNDED range complements
+    #   to a disjunction (x<a ∨ x>b) that splits the group.
+    #
+    # THE WIRE (DNF): an ARRAY OF GROUPS. Terms AND within a group; groups OR.
+    #   [[{ "field"=>"a", "equals"=>"1" }], [{ "field"=>"b", "gte"=>10 }]]
+    # A single if: compiles to one group; if_any: to one group per hash; unless:
+    # distributes its negated terms into every group (multiplying groups when a
+    # bounded-range complement splits). There is NO expression surface: every
+    # term is a declared literal predicate — the pre-#180 default-deny posture.
+    module ShowConditions
+      module_function
+
+      # Compile if:/if_any:/unless: into DNF groups. Loud validation at render
+      # (the pre-#180 posture) — empty conditions, empty Array/group values, a
+      # non-Numeric Range endpoint, and if:+if_any: together all raise here so a
+      # dead binding fails at render, never silently in the browser.
+      def normalize(**kwargs)
+        positive = kwargs.slice(:if, :if_any)
+        negative = kwargs[:unless]
+
+        if positive.key?(:if) && positive.key?(:if_any)
+          raise ArgumentError,
+            "reactive_show: exactly one of if:/if_any: (unless: composes with either), " \
+            "got both"
+        end
+        raise ArgumentError, "reactive_show needs if:, if_any:, or unless:" unless positive.any? || negative
+
+        groups = base_groups(positive)
+        groups = apply_unless(groups, negative) if negative
+        groups
+      end
+
+      # Evaluate DNF groups against a { field => value(String) } map — true when
+      # ANY group's EVERY term matches. Mirrors the client fold exactly; a
+      # referenced field absent from `values` reads as "" (fail-closed, same as
+      # a blank field).
+      # rubocop:disable Style/ItBlockParameter -- nested blocks: `it` would shadow ambiguously
+      def match?(groups, values)
+        groups.any? { |group| group.all? { |term| term_matches?(term, values) } }
+      end
+
+      # Every field named across all groups/terms — drives reactive_values
+      # coverage (server first paint only fires when every field is provided).
+      def fields(groups)
+        groups.flat_map { |group| group.map { |term| term.fetch("field") } }.uniq
+      end
+      # rubocop:enable Style/ItBlockParameter
+
+      # --- normalization internals -------------------------------------------
+
+      # The positive base: if: -> one group; if_any: -> a group per hash; neither
+      # (unless: only) -> a single empty "all true" group that unless: negates
+      # into.
+      def base_groups(positive)
+        if positive.key?(:if)
+          [group_terms(:if, positive.fetch(:if))]
+        elsif positive.key?(:if_any)
+          any = positive.fetch(:if_any)
+          unless any.is_a?(Array) && any.any?
+            raise ArgumentError, "reactive_show if_any: needs at least one group (an Array of hashes)"
+          end
+
+          any.map { group_terms(:if_any, it) }
+        else
+          [[]] # unless: only — one empty group; unless distributes its nots in
+        end
+      end
+
+      # One hash -> its ANDed positive terms.
+      def group_terms(context, hash)
+        unless hash.is_a?(Hash) && hash.any?
+          label = context == :if_any ? "each if_any: group needs at least one field" : "if: needs at least one field"
+          raise ArgumentError, "reactive_show: #{label} (a Hash of field => value), got #{hash.inspect}"
+        end
+
+        hash.flat_map { |field, value| positive_terms(field, value) }
+      end
+
+      # Distribute the negated unless: over every base group, obeying De Morgan.
+      # `unless:` negates the AND of its whole hash — ¬(a ∧ b) = ¬a ∨ ¬b — so the
+      # negation is a DISJUNCTION: the UNION of each field's alternative
+      # term-lists, never their cartesian product. Each field contributes 1
+      # alternative (a scalar `not`, or an Array's ∉ = AND-of-nots, or an endless
+      # range complement) or 2 (a bounded range, itself a disjunction); those
+      # alternatives OR across fields. Distributing that ORed set over the base
+      # groups multiplies them: |base| × |alternatives| groups, each base group
+      # ANDed with exactly one alternative.
+      def apply_unless(groups, negative)
+        unless negative.is_a?(Hash) && negative.any?
+          raise ArgumentError, "reactive_show unless: needs a Hash of field => value, got #{negative.inspect}"
+        end
+
+        alternatives = negative.flat_map { |field, value| negative_alternatives(field, value) }
+        # rubocop:disable Style/ItBlockParameter -- nested block: `it` would shadow `group`
+        groups.flat_map do |group|
+          alternatives.map { |extra| group + extra }
+        end
+        # rubocop:enable Style/ItBlockParameter
+      end
+
+      # --- the value language (positive) -------------------------------------
+
+      # A field => value under if:/if_any: -> a list of ANDed terms (one, or two
+      # for a bounded range).
+      def positive_terms(field, value)
+        name = field.to_s
+        case value
+        when Range then range_terms(name, value)
+        when Array then [membership_term(name, value)]
+        else [{ "field" => name, "equals" => equals_literal(value) }]
+        end
+      end
+
+      def equals_literal(value)
+        return "" if value.nil?
+
+        value.to_s
+      end
+
+      def membership_term(name, array)
+        list = array.map(&:to_s)
+        raise ArgumentError, "reactive_show: #{name.inspect} Array needs at least one value" if list.empty?
+
+        { "field" => name, "in" => list }
+      end
+
+      # A Range -> gte / lte / lt terms. Endless -> one term; bounded -> two
+      # (gte + lte/lt) in the SAME group. Endpoints must be numbers (a literal
+      # numeric threshold, never an expression).
+      def range_terms(name, range)
+        first = range.begin
+        last = range.end
+        validate_range_endpoints!(name, first, last)
+
+        terms = []
+        terms << { "field" => name, "gte" => first } unless first.nil?
+        if last
+          terms << { "field" => name, (range.exclude_end? ? "lt" : "lte") => last }
+        end
+        terms
+      end
+
+      def validate_range_endpoints!(name, first, last)
+        [first, last].compact.each do
+          next if it.is_a?(Numeric)
+
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} Range endpoints must be numbers " \
+            "(an ordered threshold), got #{it.inspect}"
+        end
+      end
+
+      # --- the value language (negated, under unless:) -----------------------
+
+      # A field => value under unless: -> a LIST of alternative term-lists.
+      # Scalar/Array negate to a single conjunctive alternative (an Array is
+      # ¬(x ∈ set) = AND of nots); a bounded Range complements to TWO
+      # alternatives (the disjunction x<a ∨ x>b). An empty Array raises, exactly
+      # like the positive membership path (a dead binding must fail at render).
+      def negative_alternatives(field, value)
+        name = field.to_s
+        case value
+        when Range then range_complement(name, value)
+        when Array
+          list = value.map(&:to_s)
+          raise ArgumentError, "reactive_show: #{name.inspect} Array needs at least one value" if list.empty?
+
+          [list.map { { "field" => name, "not" => it } }]
+        else [[{ "field" => name, "not" => equals_literal(value) }]]
+        end
+      end
+
+      # The complement of a range predicate. Endless ranges complement to a
+      # single opposite threshold (¬gte→lt, ¬lte→gt, ¬lt→gte) — itself a positive
+      # numeric predicate, so a blank/NaN field stays FALSE (fail-closed: the
+      # complement never flips a blank to visible). A bounded range complements
+      # to two alternatives.
+      def range_complement(name, range)
+        first = range.begin
+        last = range.end
+        validate_range_endpoints!(name, first, last)
+
+        low = first.nil? ? nil : [{ "field" => name, "lt" => first }]
+        high =
+          if last.nil?
+            nil
+          elsif range.exclude_end?
+            [{ "field" => name, "gte" => last }]
+          else
+            [{ "field" => name, "gt" => last }]
+          end
+
+        [low, high].compact
+      end
+
+      # --- evaluation (mirrors the client) -----------------------------------
+
+      def term_matches?(term, values)
+        field = term.fetch("field")
+        value = values.fetch(field, "")
+
+        if term.key?("equals") then value == term["equals"]
+        elsif term.key?("not") then value != term["not"]
+        elsif term.key?("in") then term["in"].include?(value)
+        else numeric_term_matches?(term, value)
+        end
+      end
+
+      # gte/gt/lte/lt — coerce the field value to a number; a blank/non-numeric
+      # value is fail-closed (never matches). Mirrors the client's
+      # numericPredicateMatches (blank/whitespace -> NaN -> false).
+      def numeric_term_matches?(term, value)
+        trimmed = value.to_s.strip
+        return false if trimmed.empty?
+
+        number = Float(trimmed, exception: false)
+        return false if number.nil?
+
+        if term.key?("gte") then number >= term["gte"]
+        elsif term.key?("gt") then number > term["gt"]
+        elsif term.key?("lte") then number <= term["lte"]
+        elsif term.key?("lt") then number < term["lt"]
+        else false
+        end
+      end
+    end
+  end
+end

data/lib/phlex/reactive/streamable.rb

@@ -246,11 +246,11 @@ module Phlex
         # transports (Action Cable AND pgbus): it wraps this class-method body,
         # which is the same on either, so pgbus optionality is preserved.
         def broadcast_replace_to(*streamables, model: nil, exclude: nil, visible_to: nil, morph: false, **options)
-          instrument_broadcast("replace", streamables) do
+          instrument_broadcast("replace", streamables, exclude:, visible_to:) do
             component = build(model, options)
             ::Turbo::StreamsChannel.broadcast_replace_to(
               *streamables, target: component.id, html: render_component(component),
-              **morph_attributes(morph), **broadcast_transport_opts(exclude:, visible_to:)
+              **morph_attributes(morph)
             )
           end
         end
@@ -261,41 +261,38 @@ module Phlex
         # flag, it rides through `attributes:` (the broadcast path has no
         # `method:` kwarg) via morph_attributes.
         def broadcast_update_to(*streamables, model: nil, exclude: nil, visible_to: nil, morph: false, **options)
-          instrument_broadcast("update", streamables) do
+          instrument_broadcast("update", streamables, exclude:, visible_to:) do
             component = build(model, options)
             ::Turbo::StreamsChannel.broadcast_update_to(
               *streamables, target: component.id, html: render_component(component),
-              **morph_attributes(morph), **broadcast_transport_opts(exclude:, visible_to:)
+              **morph_attributes(morph)
             )
           end
         end
 
         def broadcast_append_to(*streamables, target:, model: nil, exclude: nil, visible_to: nil, **options)
-          instrument_broadcast("append", streamables) do
+          instrument_broadcast("append", streamables, exclude:, visible_to:) do
             component = build(model, options)
             ::Turbo::StreamsChannel.broadcast_append_to(
-              *streamables, target:, html: render_component(component),
-              **broadcast_transport_opts(exclude:, visible_to:)
+              *streamables, target:, html: render_component(component)
             )
           end
         end
 
         def broadcast_prepend_to(*streamables, target:, model: nil, exclude: nil, visible_to: nil, **options)
-          instrument_broadcast("prepend", streamables) do
+          instrument_broadcast("prepend", streamables, exclude:, visible_to:) do
             component = build(model, options)
             ::Turbo::StreamsChannel.broadcast_prepend_to(
-              *streamables, target:, html: render_component(component),
-              **broadcast_transport_opts(exclude:, visible_to:)
+              *streamables, target:, html: render_component(component)
             )
           end
         end
 
         def broadcast_remove_to(*streamables, model: nil, exclude: nil, visible_to: nil, **options)
-          instrument_broadcast("remove", streamables) do
+          instrument_broadcast("remove", streamables, exclude:, visible_to:) do
             component = build(model, options)
             ::Turbo::StreamsChannel.broadcast_remove_to(
-              *streamables, target: component.id,
-              **broadcast_transport_opts(exclude:, visible_to:)
+              *streamables, target: component.id
             )
           end
         end
@@ -303,8 +300,8 @@ module Phlex
         # Push server-side client DOM ops to EVERY subscriber of a stream (issue
         # #97) — the broadcast sibling of Response#js. Rides a `reactive:js`
         # custom stream action over Turbo::StreamsChannel, so it works on Action
-        # Cable AND pgbus (transport opts pass through broadcast_transport_opts
-        # exactly like every other broadcast):
+        # Cable AND pgbus (exclude:/visible_to: thread to pgbus via
+        # instrument_broadcast exactly like every other broadcast):
         #
         #   Notifications::Badge.broadcast_js_to(user, :alerts,
         #     js.add_class("#bell", "has-unread"), exclude: reactive_connection_id)
@@ -320,15 +317,14 @@ module Phlex
         # actor-reply concern only (Response#js), so it raises ArgumentError here
         # rather than silently shipping a hostile-feeling broadcast.
         def broadcast_js_to(*streamables, ops, exclude: nil, visible_to: nil, target: nil)
-          instrument_broadcast("reactive:js", streamables) do
+          instrument_broadcast("reactive:js", streamables, exclude:, visible_to:) do
             json = broadcast_js_ops_json(ops)
             ::Turbo::StreamsChannel.broadcast_action_to(
               *streamables,
               action: "reactive:js",
               target: target,
               attributes: { data: { reactive_ops: json } },
-              render: false,
-              **broadcast_transport_opts(exclude:, visible_to:)
+              render: false
             )
           end
         end
@@ -356,49 +352,45 @@ module Phlex
         # render-per-viewer by definition and can't be shared. This fan-out is
         # for the same payload to many keys.
         def broadcast_replace_to_each(stream_keys, model: nil, exclude: nil, visible_to: nil, morph: false, **options)
-          instrument_broadcast("replace", stream_keys) do
+          instrument_broadcast("replace", stream_keys, exclude:, visible_to:) do
             component = build(model, options)
             html = render_component(component)
-            transport = broadcast_transport_opts(exclude:, visible_to:)
             stream_keys.each do
               ::Turbo::StreamsChannel.broadcast_replace_to(
-                *Array(it), target: component.id, html:, **morph_attributes(morph), **transport
+                *Array(it), target: component.id, html:, **morph_attributes(morph)
               )
             end
           end
         end
 
         def broadcast_update_to_each(stream_keys, model: nil, exclude: nil, visible_to: nil, morph: false, **options)
-          instrument_broadcast("update", stream_keys) do
+          instrument_broadcast("update", stream_keys, exclude:, visible_to:) do
             component = build(model, options)
             html = render_component(component)
-            transport = broadcast_transport_opts(exclude:, visible_to:)
             stream_keys.each do
               ::Turbo::StreamsChannel.broadcast_update_to(
-                *Array(it), target: component.id, html:, **morph_attributes(morph), **transport
+                *Array(it), target: component.id, html:, **morph_attributes(morph)
               )
             end
           end
         end
 
         def broadcast_append_to_each(stream_keys, target:, model: nil, exclude: nil, visible_to: nil, **options)
-          instrument_broadcast("append", stream_keys) do
+          instrument_broadcast("append", stream_keys, exclude:, visible_to:) do
             component = build(model, options)
             html = render_component(component)
-            transport = broadcast_transport_opts(exclude:, visible_to:)
             stream_keys.each do
-              ::Turbo::StreamsChannel.broadcast_append_to(*Array(it), target:, html:, **transport)
+              ::Turbo::StreamsChannel.broadcast_append_to(*Array(it), target:, html:)
             end
           end
         end
 
         def broadcast_prepend_to_each(stream_keys, target:, model: nil, exclude: nil, visible_to: nil, **options)
-          instrument_broadcast("prepend", stream_keys) do
+          instrument_broadcast("prepend", stream_keys, exclude:, visible_to:) do
             component = build(model, options)
             html = render_component(component)
-            transport = broadcast_transport_opts(exclude:, visible_to:)
             stream_keys.each do
-              ::Turbo::StreamsChannel.broadcast_prepend_to(*Array(it), target:, html:, **transport)
+              ::Turbo::StreamsChannel.broadcast_prepend_to(*Array(it), target:, html:)
             end
           end
         end
@@ -406,11 +398,10 @@ module Phlex
         # remove has no body — nothing to render. It still builds ONCE to read
         # the component's #id (the target), then loops the cheap channel call.
         def broadcast_remove_to_each(stream_keys, model: nil, exclude: nil, visible_to: nil, **options)
-          instrument_broadcast("remove", stream_keys) do
+          instrument_broadcast("remove", stream_keys, exclude:, visible_to:) do
             component = build(model, options)
-            transport = broadcast_transport_opts(exclude:, visible_to:)
             stream_keys.each do
-              ::Turbo::StreamsChannel.broadcast_remove_to(*Array(it), target: component.id, **transport)
+              ::Turbo::StreamsChannel.broadcast_remove_to(*Array(it), target: component.id)
             end
           end
         end
@@ -418,16 +409,46 @@ module Phlex
         private
 
         # Wrap a broadcast_*_to body in a broadcast.phlex_reactive event (issue
-        # #107). Payload: the component NAME, the Turbo stream action, and the
-        # streamables COUNT — never the model/state. Fires on both transports
-        # because it wraps the shared class-method body. Returns the block's value
-        # (the broadcast result) so callers are unaffected.
-        def instrument_broadcast(stream_action, streamables, &)
+        # #107) AND thread the pgbus transport opts (issue #187). Payload: the
+        # component NAME, the Turbo stream action, and the streamables COUNT —
+        # never the model/state. Fires on both transports because it wraps the
+        # shared class-method body. Returns the block's value (the broadcast
+        # result) so callers are unaffected.
+        #
+        # exclude:/visible_to: (issue #187): pgbus reads these from thread-locals
+        # (Thread.current[:pgbus_broadcast_exclude]/_visible_to), which its
+        # Turbo::StreamsChannel#broadcast_stream_to patch consults — NOT from the
+        # broadcast_*_to kwargs (turbo-rails swallows unknown kwargs into its
+        # render locals, so passing exclude: as a kwarg to StreamsChannel silently
+        # drops it: the actor-echo suppression never fired on pgbus). We set the
+        # thread-locals around the broadcast (capability-gated on pgbus_streams?)
+        # and clear them in ensure. On Action Cable there is no such thread-local
+        # reader, so this is a no-op there — pgbus optionality preserved.
+        def instrument_broadcast(stream_action, streamables, exclude: nil, visible_to: nil, &)
           Phlex::Reactive.instrument(
             "broadcast",
-            { component: name, stream_action: stream_action, streamables: streamables.size },
-            &
-          )
+            { component: name, stream_action: stream_action, streamables: streamables.size }
+          ) { with_pgbus_broadcast_opts(exclude:, visible_to:, &) }
+        end
+
+        # Set the pgbus broadcast thread-locals for the duration of the block,
+        # ONLY when streams-capable pgbus is present (the capability gate — an old
+        # pgbus / Action Cable never reads these keys, so we skip the work and the
+        # ensure entirely). Cleared in ensure so a broadcast never leaks its
+        # exclude into a later one on the same thread.
+        def with_pgbus_broadcast_opts(exclude:, visible_to:)
+          return yield unless Phlex::Reactive.pgbus_streams?
+
+          prev_exclude = Thread.current[:pgbus_broadcast_exclude]
+          prev_visible = Thread.current[:pgbus_broadcast_visible_to]
+          Thread.current[:pgbus_broadcast_exclude] = exclude
+          Thread.current[:pgbus_broadcast_visible_to] = visible_to
+          yield
+        ensure
+          if Phlex::Reactive.pgbus_streams?
+            Thread.current[:pgbus_broadcast_exclude] = prev_exclude
+            Thread.current[:pgbus_broadcast_visible_to] = prev_visible
+          end
         end
 
         # Validate + serialize broadcast ops: reject focus-class ops (they steal
@@ -463,15 +484,6 @@ module Phlex
           morph ? { attributes: { method: "morph" } } : {}
         end
 
-        # Only include transport opts that were actually given, so on Action
-        # Cable (which doesn't accept them) the common no-opts call is unchanged.
-        def broadcast_transport_opts(exclude:, visible_to:)
-          opts = {}
-          opts[:exclude] = exclude unless exclude.nil?
-          opts[:visible_to] = visible_to unless visible_to.nil?
-          opts
-        end
-
         def renderer
           Phlex::Reactive.renderer
         end

data/lib/phlex/reactive/test_helpers.rb

@@ -276,7 +276,15 @@ module Phlex
           end
 
           if @response.render_self? && streams.none? { it.include?("data-reactive-token-value") }
-            streams = [@component.to_stream_replace, *streams]
+            # Mirror the endpoint (issue #180): a self-render reply gets the full
+            # replace; a companion-only reply.with (no subject_component) gets a
+            # token-only refresh instead.
+            streams =
+              if @response.subject_component
+                [@component.to_stream_replace, *streams]
+              else
+                [*streams, @component.to_stream_token]
+              end
           end
           streams
         end

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.9.5"
+    VERSION = "0.10.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.10.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -142,6 +142,7 @@ files:
 - lib/phlex/reactive.rb
 - lib/phlex/reactive/authorization.rb
 - lib/phlex/reactive/claude/skills/phlex-reactive-debugging/SKILL.md
+- lib/phlex/reactive/client_bindings.rb
 - lib/phlex/reactive/component.rb
 - lib/phlex/reactive/component/dsl.rb
 - lib/phlex/reactive/component/helpers.rb
@@ -168,6 +169,7 @@ files:
 - lib/phlex/reactive/param_schema.rb
 - lib/phlex/reactive/reply.rb
 - lib/phlex/reactive/response.rb
+- lib/phlex/reactive/show_conditions.rb
 - lib/phlex/reactive/stream.rb
 - lib/phlex/reactive/streamable.rb
 - lib/phlex/reactive/test_helpers.rb