phlex-reactive 0.14.4 → 0.15.1

data/lib/phlex/reactive/presence/transport.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Phlex
+  module Reactive
+    module Presence
+      # Every pgbus touchpoint of presence (issue #358), in one place. The
+      # transport half lives in pgbus (zoolutions/pgbus#515): presence rows keyed
+      # by SSE connection, each with the tab's seat and a state jsonb, a change
+      # hook, and a heartbeat that expires silent rows. Nothing else in the gem
+      # names a pgbus presence constant or configuration key.
+      #
+      # pgbus stays optional: the capability is a probe of the real method
+      # signatures, never a version string, and without it nothing here runs —
+      # reactive_presence raises a ConfigurationError at render instead.
+      module Transport
+        # Every presence stream's name ends in ":presence:<name>" — the parts
+        # [record, :presence, name] joined by pgbus/Turbo. Registered with the
+        # transport at boot so a subscription to one joins on connect and leaves
+        # on disconnect, with no controller code.
+        PATTERN = /:presence:[^:]+\z/
+        # Hex characters of the subject's digest that start a presence key.
+        DIGEST_LENGTH = 16
+        # What joins the digest and the presence name.
+        SEPARATOR = ":presence:"
+
+        # pgbus's default streams_heartbeat_interval (seconds), used when pgbus
+        # is absent or does not expose the setting.
+        DEFAULT_HEARTBEAT = 15
+
+        # The change hook install! sets: the app's own hook (if any) first, then
+        # presence's. Its class is how a second install! knows it is in place.
+        ChainedHook = Data.define(:previous, :on_change) do
+          def call(stream_name, change)
+            previous&.call(stream_name, change)
+            on_change.call(stream_name, change)
+          end
+        end
+
+        class << self
+          # The code is there: pgbus with reactive Streams AND presence keyed by
+          # connection (a join that takes connection_id:, a set_state,
+          # seats_supported?), a change hook and a ttl setting, and ActiveJob
+          # (the roster re-renders off the hook's thread). Signatures only, no
+          # query: boot and class load gate on this, and both run before a
+          # database exists (`rails db:create`, `assets:precompile`). What it
+          # gates is configuration, harmless on an unmigrated table.
+          def wired?
+            return false unless Phlex::Reactive.pgbus_streams?
+            return false unless defined?(::Pgbus::Streams::Presence) && defined?(::ActiveJob::Base)
+
+            presence = ::Pgbus::Streams::Presence
+            join_keys = presence.instance_method(:join).parameters.map(&:last)
+            return false unless join_keys.include?(:connection_id) && presence.method_defined?(:set_state)
+            return false unless presence.respond_to?(:seats_supported?)
+
+            # streams_authorize= marks pgbus 0.18 (#524), which also fires
+            # pgbus:connected only after the seat joined (#523) and drops a
+            # closed tab at once (#520); neither of those has a signature.
+            config = ::Pgbus.configuration
+            %i[streams_presence_on_change= streams_presence_ttl streams_presence_patterns streams_authorize=].all? do
+              config.respond_to?(it)
+            end
+          rescue ::NameError
+            false
+          end
+
+          # Wired AND the seat table is migrated. seats_supported? is a query
+          # (pgbus memoizes a success), so only a render and the render job ask.
+          # A database error propagates: answering false would hide it.
+          def capable?
+            wired? && ::Pgbus::Streams::Presence.seats_supported?
+          end
+
+          # How often the transport's heartbeat touches a live tab (seconds):
+          # configuration only, no query, so a declaration can read it at
+          # class load.
+          def heartbeat_interval
+            config = ::Pgbus.configuration if Phlex::Reactive.pgbus? && ::Pgbus.respond_to?(:configuration)
+            interval = config.streams_heartbeat_interval if config.respond_to?(:streams_heartbeat_interval)
+            interval.is_a?(Numeric) ? interval : DEFAULT_HEARTBEAT
+          end
+
+          # The stream name the transport (and every Turbo broadcast) uses for
+          # these parts.
+          # "<16 hex of the subject>:presence:<name>": the subject (the record,
+          # or a record-less roster's key) becomes a fixed-length digest of its
+          # stream name, so the key fits pgbus's queue-name budget (41 chars by
+          # default) whatever the model is called — the raw gid form, or pgbus's
+          # own "<param_key>_<digest>" fragment, overflows it for Document,
+          # Conversation, ProjectBoard, …. Leaves 15 chars for the presence
+          # name; ":presence:<name>" stays the suffix the patterns match. Not
+          # reversible: the render job finds the record through the row's note.
+          # pgbus raises ArgumentError when it still does not fit.
+          def stream_name(parts)
+            *subject, presence, name = parts
+            digest = Digest::SHA256.hexdigest(::Pgbus::Streams::Stream.name_from(subject))[0, DIGEST_LENGTH]
+            ::Pgbus.stream_key!("#{digest}:#{presence}:#{name}")
+          end
+
+          def stream_name_budget = ::Pgbus.stream_name_budget
+
+          # Whether a presence name fits the key: pure configuration (the queue
+          # prefix), no database, so the declaration can check it.
+          def fits?(name) = DIGEST_LENGTH + SEPARATOR.length + name.to_s.length <= stream_name_budget
+
+          def over_budget_message(klass, name, detail = nil)
+            "#{klass.name}: the presence stream for reactive_presence :#{name} does not fit pgbus's " \
+              "stream-name budget of #{stream_name_budget} chars (a #{DIGEST_LENGTH}-char digest of the record, " \
+              "\":presence:\" and the name). Use a shorter presence name.#{" (#{detail})" if detail}"
+          end
+
+          # The signed SSE URL a <pgbus-stream-source> subscribes with.
+          def source_src(stream_name) = Phlex::Reactive::Defer.stream_src(stream_name)
+
+          # The rows of a stream: Hashes with "id" (the member), "connection_id",
+          # "seat", "state", "metadata" and "joined_at".
+          def members(stream_name) = ::Pgbus.stream(stream_name).presence.members
+
+          # Writes the state of ONE connection's row on the stream (pgbus
+          # shallow-merges it into what the row had).
+          def set_state(stream_name, connection_id:, state:)
+            ::Pgbus.stream(stream_name).presence.set_state(connection_id:, state:)
+          end
+
+          # At boot: auto-join presence streams, and hear their changes. An
+          # app's own change hook keeps running (chained, first).
+          def install!(on_change)
+            config = ::Pgbus.configuration
+            patterns = config.streams_presence_patterns
+            patterns << PATTERN unless patterns.include?(PATTERN)
+            previous = config.streams_presence_on_change
+            return if previous.is_a?(ChainedHook)
+
+            config.streams_presence_on_change = ChainedHook.new(previous:, on_change:)
+          end
+
+          # A component's ttl: — seconds a silent seat survives — keyed by its
+          # presence name, which every stream of that component ends with.
+          # pgbus takes an Integer (every stream) or a Hash of stream name /
+          # pattern => seconds with a :default; an Integer becomes the Hash's
+          # default so the app's own setting still covers every other stream.
+          def register_ttl(name, seconds)
+            config = ::Pgbus.configuration
+            ttl = config.streams_presence_ttl
+            config.streams_presence_ttl = ttl = { default: ttl } unless ttl.is_a?(Hash)
+            ttl.store(/:presence:#{Regexp.escape(name.to_s)}\z/, seconds)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlex/reactive/presence.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    # Presence (issue #358): who is viewing a stream, one SEAT per browser tab,
+    # each with an ephemeral, declared state (the item it has selected), and a
+    # roster component that re-renders itself in every viewer's tab on join,
+    # leave, expiry and state change.
+    #
+    #   class Boards::Viewers < Phlex::HTML
+    #     include Phlex::Reactive::Component
+    #
+    #     reactive_record :board
+    #     reactive_presence :viewers, state: { selected: :integer }, ttl: 45
+    #
+    #     def view_template
+    #       div(**reactive_root) do
+    #         presence.members.each do |member|
+    #           span(**reactive_presence_member(member)) { member.metadata["name"] }
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # The transport does the membership (pgbus, zoolutions/pgbus#515): an SSE
+    # connection to a presence stream joins on connect and leaves on
+    # disconnect, a silent one expires after the stream's ttl, and each change
+    # calls the hook this module installs. The hook enqueues
+    # PresenceRenderJob, which re-renders the roster for everyone.
+    #
+    # Every pgbus call is in Presence::Transport. Without a capable transport
+    # (no pgbus, an older one, Action Cable) a presence root raises
+    # Phlex::Reactive::ConfigurationError at render: there is no degraded mode.
+    module Presence
+      # The reverse note a presence write leaves in the seat's state: the class
+      # that wrote it and the record it renders. A stream name cannot be turned
+      # back into a record (pgbus digests long names), so the render job reads
+      # this from any seat still on the stream. Never shown to the app: Peer#state
+      # holds only the declared keys.
+      NOTE_KEY = "_rp"
+
+      # A silent seat survives this many seconds (the transport's heartbeat,
+      # 15 s by default, keeps a live one fresh: two missed beats).
+      DEFAULT_TTL = 45
+
+      # Roster broadcasts coalesce: a page reload is a leave and a join within
+      # milliseconds, and a burst of selections is one morph per window.
+      COALESCE_MS = 150
+
+      # The client sends its presence source's connection id in this header, so
+      # a write lands on the row of THIS tab's presence connection — not on the
+      # first <pgbus-stream-source> on the page (X-Pgbus-Connection).
+      HEADER = "X-Reactive-Presence"
+
+      # What reactive_presence declared: the presence name, the state schema,
+      # the ttl, and the raw stream key parts of a record-less component.
+      Declaration = Data.define(:name, :state, :ttl, :key)
+
+      # One tab on the stream. `seat` is the tab's id (opaque; rendered by
+      # reactive_presence_peer so the client can find "me"), `state` the
+      # declared keys only. No connection id: it is the bearer key for writing
+      # the tab's row, so it stays inside the Roster.
+      Peer = Data.define(:seat, :member_id, :metadata, :state, :joined_at)
+
+      # One person: their seats, the newest one's metadata and state.
+      Member = Data.define(:id, :metadata, :seats) do
+        def state = seats.last&.state || {}
+      end
+
+      class << self
+        # Wired and migrated (a query: render time only). See Transport.
+        def capable? = Transport.capable?
+
+        # The actor's presence connection during an action (the HEADER), or nil.
+        def connection_id
+          Thread.current[:phlex_reactive_presence_connection]
+        end
+
+        def with_connection_id(connection_id)
+          previous = Thread.current[:phlex_reactive_presence_connection]
+          Thread.current[:phlex_reactive_presence_connection] = connection_id.presence
+          yield
+        ensure
+          Thread.current[:phlex_reactive_presence_connection] = previous
+        end
+
+        # Raise unless the transport can carry presence — at first render of a
+        # presence root, naming what is missing.
+        def require_capable!(klass)
+          return if capable?
+
+          raise Phlex::Reactive::ConfigurationError,
+            "#{klass.name} declares reactive_presence, which needs pgbus >= 0.18.1 (presence keyed by " \
+            "SSE connection, config.streams_authorize) with its presence table created or migrated " \
+            "(`rails g pgbus:add_presence`, `rails g pgbus:add_presence_seats`, or `rails pgbus:update`), " \
+            "and ActiveJob. Action Cable has no connection identity, so there is no fallback."
+        end
+
+        # Boot (the engine's after_initialize): register the presence stream
+        # pattern and the change hook. Gated on the signatures alone, never a
+        # query — boot runs before a database exists. Nothing is touched
+        # without them: an app on Action Cable boots exactly as before.
+        def install!
+          Transport.install!(method(:changed)) if Transport.wired?
+        end
+
+        # The transport's change hook (it runs on the SSE dispatcher thread):
+        # enqueue a roster render for a presence stream, nothing else.
+        def changed(stream_name, _change)
+          return unless Transport::PATTERN.match?(stream_name.to_s)
+
+          Phlex::Reactive::PresenceRenderJob.perform_later(stream_name.to_s)
+        end
+
+        # The job's body: rebuild every roster component a seat on the stream
+        # names, render it as the table is NOW, and morph it into every viewer's
+        # tab (the joiner included: its first paint ran before its connection
+        # existed). Nobody left, or a gone record, renders nothing.
+        def render_roster(stream_name)
+          return unless capable?
+
+          # One render per class and record. A roster's reactive_state is shared
+          # markup under one id, the same for every viewer, so the state any
+          # note carries will do; per-viewer state belongs in presence state.
+          notes = Transport.members(stream_name).filter_map { it["state"]&.[](NOTE_KEY) }
+          notes.uniq { [it["c"], it["gid"]] }.each do
+            component = build(it, stream_name)
+            broadcast(component, exclude: nil) if component
+          end
+        end
+
+        # Morph `component`'s roster into its stream's viewers.
+        def broadcast(component, exclude:)
+          Phlex::Reactive::Streamable.broadcast_component(
+            component.class, :replace, component, component, [component.reactive_presence_stream_name],
+            morph: true, target: nil, exclude:, visible_to: nil, coalesce: COALESCE_MS
+          )
+        end
+
+        # A roster component rebuilt from a note: the named class, only when it
+        # declares presence, with its record re-found (nil when it is gone).
+        def build(note, stream_name)
+          klass = note["c"].to_s.safe_constantize
+          return unless klass.respond_to?(:reactive_presence_declaration) && klass.reactive_presence_declaration
+
+          klass.from_identity(note.slice("gid", "s"))
+        rescue ::ActiveRecord::RecordNotFound
+          # The record is gone: there is nothing left to render.
+          nil
+        rescue Phlex::Reactive::Error => e
+          # The note cannot rebuild the component (no gid for one that needs
+          # its record): render nothing rather than fail the job on every retry.
+          Phlex::Reactive.send(:default_logger)&.warn(
+            "[phlex-reactive] presence stream #{stream_name}: cannot rebuild #{note["c"]} from its note " \
+            "(#{e.message}); its roster is not re-rendered"
+          )
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/phlex/reactive/presence_render_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    # A presence stream changed (issue #358): a tab joined, left, or expired.
+    # Re-render the roster as the table is when the job runs — not the change
+    # it was enqueued for — and morph it into every viewer's tab. A page
+    # reload (a leave, then a join within milliseconds) therefore renders the
+    # seat present, and coalescing folds the pair into one morph.
+    #
+    # Enqueued by Phlex::Reactive::Presence.changed, the transport's change
+    # hook, which runs on the SSE dispatcher thread: rendering there would hold
+    # it up. On defer_job_queue, like the push lane's render job.
+    #
+    # NOT eager-loaded (see the loader config in phlex/reactive.rb): the class
+    # body needs ActiveJob::Base, which isn't a gem dependency — the constant
+    # is only referenced behind Phlex::Reactive::Presence.capable?.
+    class PresenceRenderJob < ::ActiveJob::Base
+      queue_as { Phlex::Reactive.defer_job_queue }
+
+      def perform(stream_name)
+        Phlex::Reactive::Presence.render_roster(stream_name)
+      end
+    end
+  end
+end

data/lib/phlex/reactive/shortcut.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    # A page-level keyboard shortcut (issue #357), the value behind
+    # `on(..., shortcut:)` and `on_client(:keydown, ..., shortcut:)`.
+    #
+    #   Shortcut.parse("mod+z")                          # String form
+    #   Shortcut.parse({ keys: "esc", in_editable: true }) # Hash form
+    #
+    # `mod` is meta on Apple platforms and ctrl elsewhere. Stimulus has no
+    # "either" modifier (its key filter compares all four modifier flags
+    # exactly), so a `mod` chord renders TWO descriptors, a meta twin and a ctrl
+    # twin, and the client runs only the twin for its platform. Stimulus keeps
+    # the key filtering; the client adds the platform check, the editable-target
+    # guard and preventDefault. The exception is a key Stimulus's default map
+    # lacks (delete, backspace — issue #366): it binds a bare window keydown,
+    # no twins, and the client matches the whole chord.
+    #
+    # Validation is loud, at render: Stimulus reports an unknown key token by
+    # throwing at keypress time, which is too late to notice.
+    class Shortcut
+      MODIFIERS = %w[mod meta ctrl alt shift].freeze
+      # Stimulus's default keyMappings: the named keys plus a-z and 0-9.
+      STIMULUS_KEYS = %w[enter tab esc space up down left right home end page_up page_down].freeze
+      # Keys Stimulus's default map lacks (issue #366): a key filter naming one
+      # makes Stimulus throw at keypress, so such a chord renders a bare
+      # `keydown@window` and the client alone matches it.
+      LIBRARY_KEYS = %w[delete backspace].freeze
+      NAMED_KEYS = (STIMULUS_KEYS + LIBRARY_KEYS).freeze
+      HASH_KEYS = %i[keys in_editable].freeze
+
+      private_constant :MODIFIERS, :STIMULUS_KEYS, :LIBRARY_KEYS, :NAMED_KEYS, :HASH_KEYS
+
+      attr_reader :keys
+
+      def self.parse(spec)
+        case spec
+        when String then new(spec, in_editable: false)
+        when Hash then from_hash(spec)
+        else
+          raise ArgumentError,
+            "shortcut: takes a String (\"mod+z\") or a Hash ({ keys: \"esc\", in_editable: true }), " \
+            "got #{spec.inspect}"
+        end
+      end
+
+      def self.from_hash(spec)
+        keys = spec[:keys]
+        in_editable = spec.fetch(:in_editable, false)
+        unless (spec.keys - HASH_KEYS).empty? && keys.is_a?(String)
+          raise ArgumentError,
+            "shortcut: as a Hash takes keys: (a String, e.g. \"esc\") and an optional " \
+            "in_editable: (true/false), got #{spec.inspect}"
+        end
+        unless [true, false].include?(in_editable)
+          raise ArgumentError, "shortcut: in_editable: is true or false, got #{in_editable.inspect}"
+        end
+
+        new(keys, in_editable:)
+      end
+      private_class_method :from_hash
+
+      def initialize(keys, in_editable:)
+        tokens = keys.downcase.split("+").map(&:strip)
+        @in_editable = in_editable
+        @keys = canonical(keys, tokens).freeze
+        freeze
+      end
+
+      # False for a chord whose key Stimulus's default map lacks (delete,
+      # backspace): it binds without a key filter and without twins — the
+      # client's shortcut check matches the key and picks the platform's `mod`.
+      def stimulus_filterable? = !LIBRARY_KEYS.include?(@keys.split("+").last)
+
+      # The Stimulus key filters to bind: the meta and ctrl twins for a `mod`
+      # chord, else the chord itself.
+      def filters
+        return [@keys] unless @keys.start_with?("mod+")
+
+        %w[meta ctrl].map { @keys.sub("mod", it) }
+      end
+
+      # The wire form the client reads (data-reactive-shortcut-param, or the
+      # on_client record's "shortcut"): the canonical String, or the Hash form
+      # when the shortcut also fires inside editable targets.
+      def param = @in_editable ? { "keys" => @keys, "inEditable" => true } : @keys
+
+      private
+
+      def canonical(source, tokens)
+        mods = tokens.select { MODIFIERS.include?(it) }
+        key = tokens - MODIFIERS
+        validate!(source, mods, key)
+        [*MODIFIERS.select { mods.include?(it) }, key.first].join("+")
+      end
+
+      def validate!(source, mods, key)
+        raise ArgumentError, "shortcut: #{source.inspect} must name exactly one key (e.g. \"mod+z\")" unless key.size == 1
+        raise ArgumentError, "shortcut: #{source.inspect} repeats a modifier" unless mods.uniq.size == mods.size
+        if mods.include?("mod") && mods.intersect?(%w[meta ctrl])
+          raise ArgumentError,
+            "shortcut: #{source.inspect} combines mod with meta/ctrl — mod already is meta on Apple " \
+            "platforms and ctrl elsewhere"
+        end
+        return if known_key?(key.first)
+
+        raise ArgumentError,
+          "shortcut: #{source.inspect} has an unknown key #{key.first.inspect} — use a letter, a digit, " \
+          "or one of #{NAMED_KEYS.join(", ")} (Stimulus's default key map, plus delete and backspace, " \
+          "which the library matches itself; custom keyMappings are not known on the server, bind " \
+          "those with event: and window: instead)"
+      end
+
+      def known_key?(key) = NAMED_KEYS.include?(key) || key.match?(/\A[a-z0-9]\z/)
+    end
+  end
+end

data/lib/phlex/reactive/streamable.rb

@@ -37,10 +37,16 @@ module Phlex
       # Focus ops steal focus in every subscriber's tab (issue #96); submit
       # (issue #226) would force-submit every subscriber's form; paste_into
       # (issue #228) would read every subscriber's clipboard; check_group
-      # (issue #342) would tick or clear every subscriber's selection. They
+      # (issue #342) would tick or clear every subscriber's selection; presence
+      # (issue #358) would write every subscriber's presence state; show_modal
+      # and close_dialog (issue #365) would open or close a modal, and move
+      # focus, on every screen at once. They
       # 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 paste_into persist_state persist_clear check_group].freeze
+      BROADCAST_REFUSED_OPS = %w[
+        focus focus_first submit paste_into persist_state persist_clear check_group presence
+        show_modal close_dialog
+      ].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
@@ -193,7 +199,10 @@ module Phlex
               "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; broadcasting paste_into reads every subscriber's clipboard; " \
-              "broadcasting check_group ticks or clears every subscriber's selection. " \
+              "broadcasting check_group ticks or clears every subscriber's selection; " \
+              "broadcasting presence writes every subscriber's presence state; " \
+              "broadcasting show_modal or close_dialog opens or closes a modal (and moves focus) on " \
+              "every screen — render the dialog open or closed, with data: { reactive_modal: true }, instead." \
               "These are actor concerns (reply.js / on_client / $ops)."
           end
 

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.14.4"
+    VERSION = "0.15.1"
   end
 end

data/lib/phlex/reactive.rb

@@ -66,6 +66,12 @@ module Phlex
     # authorization method / mark_authorized! / declare skip_verify_authorized).
     class AuthorizationNotVerified < Error; end
 
+    # Raised when a feature needs a transport capability the app does not have
+    # (issue #358: reactive_presence without a pgbus that keys presence by
+    # connection). Loud at first render, with the requirement in the message —
+    # there is no degraded mode to fall back to.
+    class ConfigurationError < Error; end
+
     # Purpose string bound into every identity token's signature so a token
     # minted for phlex-reactive can't be replayed against another verifier use.
     IDENTITY_PURPOSE = "phlex-reactive/identity"
@@ -1283,6 +1289,10 @@ loader.do_not_eager_load("#{__dir__}/reactive/engine.rb")
 # boot. The constant autoloads on first reference, which only happens behind
 # Phlex::Reactive.defer_push_capable? (that gate requires ActiveJob::Base).
 loader.do_not_eager_load("#{__dir__}/reactive/deferred_render_job.rb")
+# The presence roster's render job (issue #358), for the same reason: it is
+# only referenced behind Phlex::Reactive::Presence.capable? (which requires
+# ActiveJob::Base).
+loader.do_not_eager_load("#{__dir__}/reactive/presence_render_job.rb")
 loader.setup
 
 require "phlex/reactive/engine" if defined?(Rails::Engine)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.14.4
+  version: 0.15.1
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -158,6 +158,9 @@ files:
 - app/javascript/phlex/reactive/features/persist.js
 - app/javascript/phlex/reactive/features/persist.min.js
 - app/javascript/phlex/reactive/features/persist.min.js.map
+- app/javascript/phlex/reactive/features/presence.js
+- app/javascript/phlex/reactive/features/presence.min.js
+- app/javascript/phlex/reactive/features/presence.min.js.map
 - app/javascript/phlex/reactive/features/sortable.js
 - app/javascript/phlex/reactive/features/sortable.min.js
 - app/javascript/phlex/reactive/features/sortable.min.js.map
@@ -195,6 +198,7 @@ files:
 - lib/phlex/reactive/component/helpers.rb
 - lib/phlex/reactive/component/identity.rb
 - lib/phlex/reactive/component/lazy.rb
+- lib/phlex/reactive/component/presence_declaration.rb
 - lib/phlex/reactive/component/registry.rb
 - lib/phlex/reactive/component/selection.rb
 - lib/phlex/reactive/component/sortable.rb
@@ -222,10 +226,16 @@ files:
 - lib/phlex/reactive/param_schema.rb
 - lib/phlex/reactive/pending.rb
 - lib/phlex/reactive/pending/markup.rb
+- lib/phlex/reactive/presence.rb
+- lib/phlex/reactive/presence/component_methods.rb
+- lib/phlex/reactive/presence/roster.rb
+- lib/phlex/reactive/presence/transport.rb
+- lib/phlex/reactive/presence_render_job.rb
 - lib/phlex/reactive/reply.rb
 - lib/phlex/reactive/response.rb
 - lib/phlex/reactive/settle.rb
 - lib/phlex/reactive/settles.rb
+- lib/phlex/reactive/shortcut.rb
 - lib/phlex/reactive/show_conditions.rb
 - lib/phlex/reactive/stream.rb
 - lib/phlex/reactive/streamable.rb