phlex-reactive 0.12.1 → 0.12.3

data/lib/phlex/reactive/component/dsl.rb

@@ -450,6 +450,71 @@ module Phlex
             Registry.resolve_hash(self, :computes, :reactive_computes)
           end
 
+          # A fresh client-op chain at CLASS level (issue #226), so a
+          # reactive_on_complete declaration reads like its on_client sibling:
+          #
+          #   reactive_on_complete if: { code: { length: 6 } },
+          #     run: js.dispatch("code:complete")
+          #
+          # The instance helper (Component::Helpers#js) is unchanged.
+          def js
+            Phlex::Reactive::JS.new
+          end
+
+          # Declarative completion binding (issue #226): when the declared
+          # conditions FIRST become true — evaluated client-side over the owned
+          # fields on input/change — run a chain of client DOM ops. The
+          # conditions are the SAME if:/if_any:/unless: kwargs reactive_show
+          # takes (the ONE ShowConditions language, including the length: form);
+          # `run:` is a js chain or a raw [[op, args], …] list (allowlist
+          # re-checked, like every raw-ops escape hatch).
+          #
+          #   reactive_on_complete if: { code: { length: 6 } },
+          #     run: js.dispatch("code:complete")
+          #   reactive_on_complete :commit, if: { code: { length: 6 } }, run: js.submit
+          #
+          # RISING-EDGE, actor-gesture semantics on the client: ops fire once on
+          # the flip to true, re-arm when the conditions go false, and the
+          # connect/morph pass arms WITHOUT firing (a re-render with already-
+          # satisfied conditions never self-fires). The optional NAME (default
+          # :default) keys the registry so a component can declare several
+          # independent bindings; redeclaring a name overrides it (inheritance
+          # follows the Registry rules, like reactive_compute).
+          def reactive_on_complete(name = :default, run:, **conditions)
+            groups = Phlex::Reactive::ShowConditions.normalize(**conditions)
+            Registry.write_entry(
+              self, :on_completes, name.to_sym,
+              OnCompleteDefinition.new(
+                name: name.to_sym, conditions: groups,
+                ops: normalize_on_complete_ops(name, run)
+              )
+            )
+          end
+
+          def reactive_on_completes
+            Registry.resolve_hash(self, :on_completes, :reactive_on_completes)
+          end
+
+          # The wire JSON for the root's data-reactive-on-complete attr — a
+          # frozen array of { any:, ops: } bindings, or nil when undeclared
+          # (byte-stable wire). Memoized per class against the registry
+          # generation (one integer compare) because reactive_attrs is the
+          # token-signing hot path — the reactive_effect_attrs precedent.
+          def reactive_on_complete_attr
+            registry_gen = Registry.generation
+            return @reactive_on_complete_attr if @reactive_on_complete_attr_gen == registry_gen
+
+            bindings = reactive_on_completes
+            @reactive_on_complete_attr =
+              if bindings.empty?
+                nil
+              else
+                bindings.values.map { { "any" => it.conditions, "ops" => it.ops } }.to_json.freeze
+              end
+            @reactive_on_complete_attr_gen = registry_gen
+            @reactive_on_complete_attr
+          end
+
           # Fetch one compute definition — the reader form matching
           # reactive_collection_def (issue #115). The bare reactive_compute(name)
           # getter above is a PERMANENT documented alias (it shipped in the same
@@ -480,6 +545,25 @@ module Phlex
           #     nil types, so the array-form wire stays byte-identical and the client
           #     keeps its numeric coercion.
           #
+          # Validate + normalize a reactive_on_complete run: chain (issue #226)
+          # to the raw [[op, args], …] pairs. A js chain is already validated at
+          # build time; a raw list re-runs the attr allowlist — the same
+          # defense-in-depth every raw-ops escape hatch gets (js([...]) /
+          # broadcast_to(js: [...])). Loud on anything else — a dead or hostile
+          # binding must fail at class load, never no-op in the browser.
+          def normalize_on_complete_ops(name, run)
+            pairs = run.is_a?(Phlex::Reactive::JS) ? run.ops : run
+            unless pairs.is_a?(Array)
+              raise ArgumentError,
+                "reactive_on_complete #{name.inspect} run: takes a js chain " \
+                "(js.dispatch(\"code:complete\")) or a raw [[op, args], ...] list, got #{run.class}"
+            end
+            raise ArgumentError, "reactive_on_complete #{name.inspect} got no ops — a dead binding" if pairs.empty?
+
+            Phlex::Reactive::JS.assert_ops_allowed!(pairs) unless run.is_a?(Phlex::Reactive::JS)
+            pairs
+          end
+
           # Named after the shape it normalizes.
           def normalize_compute_inputs(inputs)
             return normalize_typed_compute_inputs(inputs) if inputs.is_a?(Hash)

data/lib/phlex/reactive/component/helpers.rb

@@ -98,6 +98,14 @@ module Phlex
           if self.class.respond_to?(:reactive_effect_attrs) && (effects = self.class.reactive_effect_attrs)
             data.merge!(effects)
           end
+          # Completion bindings (issue #226): the declared reactive_on_complete
+          # bindings ride the root as ONE JSON attr the client evaluates over
+          # the owned fields (rising edge → run the ops). nil when undeclared —
+          # no key, byte-stable wire. Per-class memo (one integer compare).
+          if self.class.respond_to?(:reactive_on_complete_attr) &&
+             (on_complete = self.class.reactive_on_complete_attr)
+            data[:reactive_on_complete] = on_complete
+          end
           { data: }
         end
 
@@ -381,6 +389,14 @@ module Phlex
           raise ArgumentError, "on_client(#{event.inspect}) got no ops — a dead trigger" if ops.empty?
 
           event = event.to_s
+          # Issue #226: requestSubmit dispatches the very `submit` event this
+          # trigger would be bound to — an infinite loop. Loud at render.
+          if event == "submit" && ops.ops.any? { |name, _| name == "submit" }
+            raise ArgumentError,
+              "on_client(:submit, js.submit) would re-fire itself — requestSubmit dispatches the " \
+              "submit event this trigger is bound to. Bind the submit op to another event " \
+              "(change/input), or gate it behind a reducer's $ops / reactive_on_complete."
+          end
           window_bound = window || outside
           attrs = {
             data: {
@@ -601,20 +617,35 @@ module Phlex
         # hidden options) and each option's own on(:select, …) trigger —
         # selection still round-trips as a signed action; only FILTERING is
         # local. Blank selectors raise: a dead binding must fail at render.
-        def reactive_filter(field = nil, input: :__removed, option: nil, group: nil, empty: nil)
-          # Issue #186: the four-selector kwarg form is removed — name the FIELD that
-          # drives the filter instead. A leftover input: means the old call shape.
-          unless input == :__removed
+        #
+        # Issue #224: `input:` is the ESCAPE HATCH — a raw CSS selector for the
+        # one driving input the field form can't express: a deliberately
+        # NAME-LESS query input inside a real POST form (a named input would
+        # submit a stray param), targeted by id. A form builder (phlex-forms'
+        # tag_field) computes that id per instance. Verbatim, never re-scoped;
+        # exactly one of field/input: per call — the field form stays the
+        # blessed default:
+        #   reactive_filter(input: "#user_tags_query")
+        def reactive_filter(field = nil, input: nil, option: nil, group: nil, empty: nil)
+          # nil-presence, NOT truthiness: `input: cond && "#sel"` with cond false
+          # must fail loudly in filter_selector! below (a boolean is never a
+          # selector), never slip into the field branch and emit a dead binding.
+          if field && !input.nil?
             raise ArgumentError,
-              "reactive_filter(input:) was removed in issue #186 — name the driving field: " \
-              "reactive_filter(:q) (compiles to [name=\"q\"], scope-aware; option defaults to [role=option])."
+              "reactive_filter takes ONE driving-input form — a field name (reactive_filter(:q), " \
+              "scope-aware) OR input: (a raw CSS selector for a name-less input), not both"
+          end
+          if field.nil? && input.nil?
+            raise ArgumentError,
+              "reactive_filter needs a field name — reactive_filter(:q) — or the input: " \
+              "escape hatch (a raw CSS selector, e.g. input: \"#tags_query\")"
           end
-          raise ArgumentError, "reactive_filter needs a field name — reactive_filter(:q)" if field.nil?
 
           data = {
             # Compile the field to a scoped [name="…"] selector (same scope convention
-            # reactive_field uses, so the filter input aligns with its own field).
-            reactive_filter_input: %([name="#{scoped_field_name(field)}"]),
+            # reactive_field uses, so the filter input aligns with its own field) — or
+            # take the input: selector verbatim (issue #224).
+            reactive_filter_input: input.nil? ? %([name="#{scoped_field_name(field)}"]) : filter_selector!(:input, input),
             # option defaults to the [role=option] convention; a kwarg overrides it.
             reactive_filter_option: option ? filter_selector!(:option, option) : "[role=option]"
           }
@@ -680,9 +711,30 @@ module Phlex
         # and reactive_listnav (Arrow/Enter/Escape; Enter picks the highlighted
         # option via its own tagsPick trigger, and reactive_tags_add only adds
         # the TYPED text when nothing is highlighted — no double add).
-        def reactive_tags(field = nil)
+        #
+        # Issue #224: `name:` is the ESCAPE HATCH for an instance-dynamic wire
+        # name — a form builder (phlex-forms' tag_field) computes "user[tags]"
+        # per instance, which the class-level reactive_scope compile can't
+        # express. Verbatim, NEVER re-scoped (reactive_field's explicit-name
+        # precedent); exactly one of field/name: per call:
+        #   reactive_tags(name: "user[tags]")
+        def reactive_tags(field = nil, name: nil)
+          # nil-presence, NOT truthiness: `name: cond && "user[tags]"` with cond
+          # false must fail loudly in verbatim_name_selector!, never silently
+          # fall through to the field branch.
+          unless name.nil?
+            if field
+              raise ArgumentError,
+                "reactive_tags takes ONE field form — a field name (reactive_tags(:tags), scope-aware) " \
+                "OR name: (a verbatim wire name, never re-scoped), not both"
+            end
+            return { data: { reactive_tags_field: verbatim_name_selector!(:reactive_tags, name) } }
+          end
+
           if field.nil? || field.to_s.strip.empty?
-            raise ArgumentError, "reactive_tags needs a field name — reactive_tags(:tags)"
+            raise ArgumentError,
+              "reactive_tags needs a field name — reactive_tags(:tags) — or the name: " \
+              "escape hatch (a verbatim wire name, e.g. name: \"user[tags]\")"
           end
 
           # Compile the field to a scoped [name="…"] selector, the reactive_filter
@@ -785,7 +837,15 @@ module Phlex
         # a `reactive_scope :order` component emits
         # order[line_items_attributes][3][quantity] (never a nested-bracket
         # corruption of the scope wrap).
-        def nested_field_name(association, field, index: NESTED_NEW_ROW)
+        #
+        # Issue #224: `scope:` is the per-call ESCAPE HATCH — a form builder's
+        # object name is per-instance ("order", or itself bracketed for a
+        # nested fieldset: "user[profile]"), which the class-level
+        # reactive_scope can't express. Used verbatim as the wrap and WINS over
+        # reactive_scope:
+        #   nested_field_name(:line_items, :quantity, scope: "order")
+        #   # => order[line_items_attributes][NEW_ROW][quantity]
+        def nested_field_name(association, field, index: NESTED_NEW_ROW, scope: nil)
           nested_identifier!(:nested_field_name, :association, association)
           nested_identifier!(:nested_field_name, :field, field)
           unless index.to_s == NESTED_NEW_ROW || index.to_s.match?(/\A\d+\z/)
@@ -794,7 +854,9 @@ module Phlex
               "got #{index.inspect} — anything else corrupts the bracketed wire name"
           end
 
-          "#{scoped_field_name(:"#{association}_attributes")}[#{index}][#{field}]"
+          base = :"#{association}_attributes"
+          prefix = scope.nil? ? scoped_field_name(base) : "#{nested_scope!(scope)}[#{base}]"
+          "#{prefix}[#{index}][#{field}]"
         end
 
         # The container cloned rows land in — one per association, inside the
@@ -810,10 +872,23 @@ module Phlex
         # naming the hidden field the client mirrors the rows into on every
         # add/remove/input. The default (:attributes) is unchanged — the plain
         # accepts_nested_attributes_for wire.
-        def reactive_nested_list(association, as: :attributes)
-          name = nested_identifier!(:reactive_nested_list, :association, association)
-          data = { reactive_nested_list: name }
-          return { data: } if as == :attributes
+        #
+        # Issue #224: `name:` is the verbatim ESCAPE HATCH for that hidden
+        # field's wire name — a form builder's "order[todos]" the class-level
+        # reactive_scope compile can't express. JSON-mode only (the
+        # :attributes mode has no field to name); never re-scoped:
+        #   reactive_nested_list(:todos, as: :json, name: "order[todos]")
+        def reactive_nested_list(association, as: :attributes, name: nil)
+          assoc = nested_identifier!(:reactive_nested_list, :association, association)
+          data = { reactive_nested_list: assoc }
+          if as == :attributes
+            unless name.nil?
+              raise ArgumentError,
+                "reactive_nested_list(name:) only applies to as: :json — it names the hidden JSON " \
+                "sync field; the :attributes mode has no field to name"
+            end
+            return { data: }
+          end
 
           unless as == :json
             raise ArgumentError,
@@ -824,9 +899,17 @@ module Phlex
           # JSON mode: mark the container and name the hidden field the client
           # keeps in sync — a scope-aware [name="…"] selector, the same
           # convention reactive_tags/reactive_filter use so the field resolves
-          # under reactive_scope too.
-          data[:reactive_nested_json] = name
-          data[:reactive_nested_json_field] = %([name="#{scoped_field_name(association)}"])
+          # under reactive_scope too. name: takes the wire name verbatim
+          # (issue #224).
+          data[:reactive_nested_json] = assoc
+          # nil-presence, NOT truthiness (the reactive_tags rationale): a falsy
+          # non-nil name: must fail loudly in verbatim_name_selector!.
+          data[:reactive_nested_json_field] =
+            if name.nil?
+              %([name="#{scoped_field_name(association)}"])
+            else
+              verbatim_name_selector!(:reactive_nested_list, name)
+            end
           { data: }
         end
 
@@ -1109,10 +1192,12 @@ module Phlex
         # A reactive_filter/reactive_listnav selector, validated non-blank and
         # stringified (issue #163). A blank selector is a dead binding — the
         # client would silently match nothing — so it fails loudly at render,
-        # like reactive_show's predicate validation.
+        # like reactive_show's predicate validation. A boolean is rejected too
+        # (issue #224): `input: cond && "#sel"` with cond false would otherwise
+        # stringify to the plausible-looking dead selector "false".
         def filter_selector!(name, value)
           selector = value.to_s
-          if selector.strip.empty?
+          if value == true || value == false || selector.strip.empty?
             raise ArgumentError,
               "reactive_filter/reactive_listnav #{name}: needs a CSS selector, got #{value.inspect}"
           end
@@ -1135,6 +1220,54 @@ module Phlex
           value
         end
 
+        # A verbatim wire name for the name:-form escape hatches (issue #224) —
+        # an instance-dynamic name (a form builder's "user[tags]") used exactly
+        # as given, never re-scoped. The name is interpolated into a
+        # double-quoted [name="…"] attribute selector the CLIENT passes to
+        # querySelectorAll, so anything that breaks a CSS string breaks the
+        # binding IN THE BROWSER: a `"` ends the string early, a `\` CSS-escapes
+        # (a trailing one swallows the closing quote — the selector silently
+        # matches the wrong name), and a raw control character (newline) makes
+        # querySelectorAll THROW, aborting the controller's connect. All fail
+        # loudly here at render instead. Booleans are rejected with the blank
+        # check: `name: cond && "user[tags]"` with cond false must never
+        # compile the plausible-looking [name="false"].
+        def verbatim_name_selector!(helper, name)
+          value = name.to_s
+          if name == true || name == false || value.strip.empty?
+            raise ArgumentError,
+              "#{helper} name: needs a non-blank wire name (e.g. name: \"user[tags]\"), got #{name.inspect}"
+          end
+          if value.match?(/["\\\x00-\x1f]/)
+            raise ArgumentError,
+              "#{helper} name: can't contain a double quote, backslash, or control character — " \
+              "the name is compiled into a [name=\"…\"] selector the client queries with, " \
+              "got #{name.inspect}"
+          end
+
+          %([name="#{value}"])
+        end
+
+        # The per-call scope: override for nested_field_name (issue #224) — a
+        # form builder's parent prefix, possibly itself bracketed
+        # ("user[profile]"), validated non-blank. Used verbatim as the wrap.
+        # String/Symbol only: `scope: cond && "order"` with cond false would
+        # otherwise stringify to the silently-corrupting "false[…]" wire name.
+        def nested_scope!(scope)
+          unless scope.is_a?(String) || scope.is_a?(Symbol)
+            raise ArgumentError,
+              "nested_field_name scope: needs a String or Symbol parent prefix " \
+              "(e.g. scope: \"order\"), got #{scope.inspect}"
+          end
+
+          value = scope.to_s
+          return value unless value.strip.empty?
+
+          raise ArgumentError,
+            "nested_field_name scope: needs a non-blank parent prefix (e.g. scope: \"order\"), " \
+            "got #{scope.inspect}"
+        end
+
         # An association/field name for the nested-rows wire (issue #208),
         # validated to a plain Ruby identifier at render — it becomes an
         # attribute value, a CSS selector fragment, AND a bracketed param name,

data/lib/phlex/reactive/component/registry.rb

@@ -50,6 +50,8 @@ module Phlex
           state_keys: :@reactive_own_state_keys,
           collections: :@reactive_own_collections,
           computes: :@reactive_own_computes,
+          # Completion bindings — reactive_on_complete (issue #226).
+          on_completes: :@reactive_own_on_completes,
           record_key: :@reactive_own_record_key,
           # Form-field namespace — reactive_scope (issue #180).
           scope: :@reactive_own_scope,

data/lib/phlex/reactive/component.rb

@@ -104,6 +104,15 @@ module Phlex
       # default-deny; the client interpreter re-checks the shape).
       ComputeDefinition = Data.define(:name, :inputs, :outputs, :reducer, :input_types, :mirror)
 
+      # A declared completion binding (issue #226): `conditions` are the
+      # pre-compiled ShowConditions DNF groups (the ONE conditions language,
+      # including the #226 length: form); `ops` is the validated [[op, args],…]
+      # client-op chain. The generic controller evaluates the conditions over
+      # the owned fields on input/change and runs the ops on the RISING EDGE —
+      # the conditions' first flip to true — through the same frozen CLIENT_OPS
+      # whitelist as on_client. The connect/morph pass arms without firing.
+      OnCompleteDefinition = Data.define(:name, :conditions, :ops)
+
       # A declared add/remove-row collection (issue #35): the list contract tied
       # into one unit — the per-row item component, the container DOM id rows
       # live in, an optional companion count id, an optional empty-state

data/lib/phlex/reactive/js.rb

@@ -170,6 +170,21 @@ module Phlex
         append("focus_first", target_args(to, global:))
       end
 
+      # --- Submit (issue #226) ---
+      #
+      # submit(to = :root) — requestSubmit() the TARGET'S OWN form: the target
+      # itself when it IS a form, else its form owner (input.form, honoring a
+      # form= attribute), else the nearest ancestor form. requestSubmit runs
+      # constraint validation and fires a REAL cancelable `submit` event, so it
+      # composes with both a native/Turbo form and an on(:action, event:
+      # "submit") interception. ACTOR-ONLY like focus: allowed from on_client /
+      # reply.js / a reducer's $ops, refused in broadcast_to(js:) — a broadcast
+      # submit would force-submit every subscriber's form.
+
+      def submit(to = :root, global: false)
+        append("submit", target_args(to, global:))
+      end
+
       # --- Text content (issue #159) ---
       #
       # text(to, value) — set the target's textContent (stringified; nil clears).

data/lib/phlex/reactive/show_conditions.rb

@@ -17,6 +17,9 @@ module Phlex
     #   (..10)                       -> lte 10
     #   (...10)                      -> lt 10
     #   (10..20)                     -> gte 10 AND lte 20 (two terms, one group)
+    #   { length: 6 }                -> len_eq 6 (issue #226 — the value's
+    #   { length: 6.. } / (4..8)        CODEPOINT count; Integer Ranges reuse
+    #                                   the threshold vocabulary as len_*)
     # 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
@@ -29,6 +32,12 @@ module Phlex
     # bounded-range complement splits). There is NO expression surface: every
     # term is a declared literal predicate — the pre-#180 default-deny posture.
     module ShowConditions
+      # The length-predicate wire keys (issue #226) — the Ruby half; the client
+      # mirrors them in SHOW_LENGTH_KEYS. Length is counted in CODEPOINTS
+      # (String#length here, [...value].length there) so multibyte values agree
+      # — the shared fixture's emoji vector proves it.
+      LENGTH_KEYS = %w[len_eq len_gte len_gt len_lte len_lt].freeze
+
       module_function
 
       # Compile if:/if_any:/unless: into DNF groups. Loud validation at render
@@ -128,6 +137,7 @@ module Phlex
         case value
         when Range then range_terms(name, value)
         when Array then [membership_term(name, value)]
+        when Hash then length_terms(name, value)
         else [{ "field" => name, "equals" => equals_literal(value) }]
         end
       end
@@ -171,6 +181,93 @@ module Phlex
         end
       end
 
+      # --- the length predicate (issue #226) ----------------------------------
+
+      # A Hash value names a STRUCTURAL predicate — today only length:. Exact
+      # Integer -> one len_eq term; an Integer Range -> len_gte/len_lte/len_lt
+      # terms exactly like range_terms. Length is a total function over the
+      # value's codepoints (blank/absent -> 0), so { length: 0 } legitimately
+      # matches a blank field.
+      def length_terms(name, hash)
+        value = length_value!(name, hash)
+        case value
+        when Integer
+          validate_length_literal!(name, value)
+          [{ "field" => name, "len_eq" => value }]
+        when Range then length_range_terms(name, value)
+        else raise_length_kind(name, value)
+        end
+      end
+
+      def length_range_terms(name, range)
+        first = range.begin
+        last = range.end
+        raise_length_kind(name, range) if first.nil? && last.nil?
+        [first, last].compact.each { validate_length_literal!(name, it) }
+
+        terms = []
+        terms << { "field" => name, "len_gte" => first } unless first.nil?
+        if last
+          terms << { "field" => name, (range.exclude_end? ? "len_lt" : "len_lte") => last }
+        end
+        terms
+      end
+
+      # The complement of a length predicate, under unless:. Exact length
+      # negates to the outside disjunction (len < n OR len > n) — two
+      # alternatives, like a bounded numeric range; ranges complement each leg
+      # (not-gte -> lt, not-lte -> gt, not-lt -> gte). Length is total, so
+      # unlike the numeric complements there is no blank/NaN fail-closed
+      # asymmetry — the complement is exact.
+      def length_complement(name, hash)
+        value = length_value!(name, hash)
+        case value
+        when Integer
+          validate_length_literal!(name, value)
+          [[{ "field" => name, "len_lt" => value }], [{ "field" => name, "len_gt" => value }]]
+        when Range
+          first = value.begin
+          last = value.end
+          raise_length_kind(name, value) if first.nil? && last.nil?
+          [first, last].compact.each { validate_length_literal!(name, it) }
+
+          low = first.nil? ? nil : [{ "field" => name, "len_lt" => first }]
+          high =
+            if last.nil? then nil
+            elsif value.exclude_end? then [{ "field" => name, "len_gte" => last }]
+            else [{ "field" => name, "len_gt" => last }]
+            end
+          [low, high].compact
+        else raise_length_kind(name, value)
+        end
+      end
+
+      # The one Hash key must be length: — anything else is a typo'd predicate
+      # that must fail at render, never silently in the browser.
+      def length_value!(name, hash)
+        unless hash.size == 1 && hash.keys.first.to_s == "length"
+          raise ArgumentError,
+            "reactive_show: #{name.inspect} Hash value supports only length: " \
+            "(got #{hash.keys.inspect})"
+        end
+
+        hash.values.first
+      end
+
+      def validate_length_literal!(name, value)
+        return if value.is_a?(Integer) && value >= 0
+
+        raise ArgumentError,
+          "reactive_show: #{name.inspect} length: takes a non-negative Integer " \
+          "(a codepoint count), got #{value.inspect}"
+      end
+
+      def raise_length_kind(name, value)
+        raise ArgumentError,
+          "reactive_show: #{name.inspect} length: takes a non-negative Integer " \
+          "or an Integer Range, got #{value.inspect}"
+      end
+
       # --- the value language (negated, under unless:) -----------------------
 
       # A field => value under unless: -> a LIST of alternative term-lists.
@@ -182,6 +279,7 @@ module Phlex
         name = field.to_s
         case value
         when Range then range_complement(name, value)
+        when Hash then length_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?
@@ -223,10 +321,28 @@ module Phlex
         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)
+        elsif (key = LENGTH_KEYS.find { term.key?(it) }) then length_term_matches?(key, term[key], value)
         else numeric_term_matches?(term, value)
         end
       end
 
+      # len_* — compare the value's CODEPOINT count (String#length) against the
+      # Integer literal. Length is total (blank/absent -> 0), so every value is
+      # decidable; a malformed non-Integer literal (a hand-built term) is
+      # fail-closed, mirroring the client's warn-skip.
+      def length_term_matches?(key, literal, value)
+        return false unless literal.is_a?(Integer)
+
+        length = value.to_s.length
+        case key
+        when "len_eq" then length == literal
+        when "len_gte" then length >= literal
+        when "len_gt" then length > literal
+        when "len_lte" then length <= literal
+        when "len_lt" then length < literal
+        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).

data/lib/phlex/reactive/streamable.rb

@@ -33,9 +33,12 @@ module Phlex
       # up without ever sharing a mutable context across threads.
       ThreadViewContext = Struct.new(:view_context, :builder, :renderer, :generation)
 
-      # Focus ops are actor-only (they steal focus): a js broadcast rejects a
-      # broadcast that carries one. Names mirror Phlex::Reactive::JS's focus verbs.
-      BROADCAST_REFUSED_OPS = %w[focus focus_first].freeze
+      # Actor-only ops: a js broadcast rejects a broadcast that carries one.
+      # Focus ops steal focus in every subscriber's tab (issue #96); submit
+      # (issue #226) would force-submit every subscriber's form. Both belong to
+      # the actor's own reply (reply.js) or gesture (on_client / a reducer's
+      # $ops), never a broadcast. Names mirror Phlex::Reactive::JS's verbs.
+      BROADCAST_REFUSED_OPS = %w[focus focus_first submit].freeze
 
       # The broadcast_to verb kwargs (issue #185) → their Turbo stream action.
       # SELF-TARGETING verbs derive the target from the component's #id (require a
@@ -516,16 +519,18 @@ module Phlex
         # instrumentation + pgbus-threading path for the class-level and module-level
         # broadcast_to, so the transport logic has exactly one spelling.)
 
-        # Validate + serialize broadcast ops: reject focus-class ops (they steal
-        # focus in every tab) and an empty chain (a dead broadcast), then return
-        # the JSON wire form. Works on a JS chain (inspect .ops) and a raw array.
+        # Validate + serialize broadcast ops: reject actor-only ops (focus steals
+        # focus in every tab; submit force-submits every subscriber's form) and an
+        # empty chain (a dead broadcast), then return the JSON wire form. Works on
+        # a JS chain (inspect .ops) and a raw array.
         def broadcast_js_ops_json(ops)
           pairs = ops.is_a?(Phlex::Reactive::JS) ? ops.ops : Array(ops)
           refused = pairs.map { |name, _| name.to_s } & Phlex::Reactive::Streamable::BROADCAST_REFUSED_OPS
           unless refused.empty?
             raise ArgumentError,
-              "broadcast_js_to refuses focus op(s) #{refused.join(", ")} — broadcasting focus " \
-              "steals it in every subscriber's tab. Focus is an actor-reply concern (reply.js)."
+              "broadcast_to(js:) refuses actor-only op(s) #{refused.join(", ")} — broadcasting focus " \
+              "steals it in every subscriber's tab; broadcasting submit force-submits every " \
+              "subscriber's form. These are actor concerns (reply.js / on_client / $ops)."
           end
 
           Phlex::Reactive::Response.js_ops_json(ops)

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.12.1"
+    VERSION = "0.12.3"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.12.3
 platform: ruby
 authors:
 - Mikael Henriksson