textus 0.22.0 → 0.26.0

data/lib/textus/hooks/builtin.rb

@@ -7,23 +7,23 @@ module Textus
   module Hooks
     module Builtin
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def self.register_all(bus)
-        bus.on(:resolve_intake, :json) do |store:, config:, args:|
-          _ = store
+      def self.register_all(events:, rpc:) # rubocop:disable Lint/UnusedMethodArgument
+        rpc.register(:resolve_intake, :json) do |caps:, config:, args:|
+          _ = caps
           _ = args
           data = JSON.parse(config["bytes"].to_s)
           { _meta: {}, body: YAML.dump(data) }
         end
 
-        bus.on(:resolve_intake, :csv) do |store:, config:, args:|
-          _ = store
+        rpc.register(:resolve_intake, :csv) do |caps:, config:, args:|
+          _ = caps
           _ = args
           rows = CSV.parse(config["bytes"].to_s, headers: true).map(&:to_h)
           { _meta: {}, body: YAML.dump(rows) }
         end
 
-        bus.on(:resolve_intake, :"markdown-links") do |store:, config:, args:|
-          _ = store
+        rpc.register(:resolve_intake, :"markdown-links") do |caps:, config:, args:|
+          _ = caps
           _ = args
           links = config["bytes"].to_s.scan(%r{\[([^\]]+)\]\((https?://[^)\s]+)\)}).map do |text, href|
             { "text" => text, "href" => href }
@@ -31,27 +31,27 @@ module Textus
           { _meta: {}, body: YAML.dump(links) }
         end
 
-        bus.on(:resolve_intake, :"ical-events") do |store:, config:, args:|
-          _ = store
+        rpc.register(:resolve_intake, :"ical-events") do |caps:, config:, args:|
+          _ = caps
           _ = args
-          events = []
+          events_list = []
           current = nil
           config["bytes"].to_s.each_line do |line|
             line = line.strip
             case line
             when "BEGIN:VEVENT" then current = {}
             when "END:VEVENT"
-              events << current if current
+              events_list << current if current
               current = nil
             when /\A(SUMMARY|DTSTART|DTEND|UID|LOCATION|DESCRIPTION):(.*)\z/
               current[Regexp.last_match(1).downcase] = Regexp.last_match(2) if current
             end
           end
-          { _meta: {}, body: YAML.dump(events) }
+          { _meta: {}, body: YAML.dump(events_list) }
         end
 
-        bus.on(:resolve_intake, :rss) do |store:, config:, args:|
-          _ = store
+        rpc.register(:resolve_intake, :rss) do |caps:, config:, args:|
+          _ = caps
           _ = args
           doc = REXML::Document.new(config["bytes"].to_s)
           items = doc.elements.to_a("//item").map do |item|

data/lib/textus/hooks/context.rb

@@ -3,31 +3,31 @@
 module Textus
   module Hooks
     # A narrow handle passed to user hooks in place of the raw Store.
-    # All writes route back through Operations so authorization, audit
+    # All writes route back through the Session so authorization, audit
     # logging, and schema validation always fire.
     class Context
       attr_reader :role, :correlation_id
 
-      def initialize(ops:)
-        @ops = ops
-        @role = ops.ctx.role
-        @correlation_id = ops.ctx.correlation_id
+      def initialize(session:)
+        @session = session
+        @role = session.ctx.role
+        @correlation_id = session.ctx.correlation_id
       end
 
       # read
-      def get(key)                = @ops.get(key)
-      def list(**)                = @ops.list(**)
-      def deps(key)               = @ops.deps(key)
-      def freshness(key)          = @ops.freshness(key)
+      def get(key)                = @session.get(key)
+      def list(**)                = @session.list(**)
+      def deps(key)               = @session.deps(key)
+      def freshness(key)          = @session.freshness(key)
 
       # write (authorized + audited)
-      def put(key, **)          = @ops.put(key, **)
-      def delete(key, **)       = @ops.delete(key, **)
-      def audit(verb, key:, **) = @ops.store.audit_log.append(role: @role, verb: verb, key: key, **)
+      def put(key, **)          = @session.put(key, **)
+      def delete(key, **)       = @session.delete(key, **)
+      def audit(verb, key:, **) = @session.write_caps.audit_log.append(role: @role, verb: verb, key: key, **)
 
       # fan-out
       def publish_followup(event, **)
-        @ops.store.bus.publish(event, ctx: self, **)
+        @session.write_caps.events.publish(event, ctx: self, **)
       end
 
       def inspect

data/lib/textus/hooks/error_log.rb

@@ -0,0 +1,32 @@
+module Textus
+  module Hooks
+    # Bounded in-memory ring buffer of recent hook failures (errored and
+    # timed_out). Each row carries the audit `seq` observed at the time of
+    # failure so pulse can filter "errors since cursor".
+    class ErrorLog
+      DEFAULT_CAPACITY = 256
+
+      def initialize(capacity: DEFAULT_CAPACITY)
+        @capacity = capacity
+        @rows = []
+        @mutex = Mutex.new
+      end
+
+      def record(seq:, event:, hook:, key:, error_class:, error_message:)
+        row = {
+          seq: seq, event: event, hook: hook, key: key,
+          error_class: error_class, error_message: error_message,
+          at: Time.now.utc.iso8601
+        }
+        @mutex.synchronize do
+          @rows << row
+          @rows.shift while @rows.size > @capacity
+        end
+      end
+
+      def since(seq)
+        @mutex.synchronize { @rows.select { |r| r[:seq] > seq }.dup }
+      end
+    end
+  end
+end

data/lib/textus/hooks/{bus.rb → event_bus.rb}

@@ -2,67 +2,55 @@
 
 module Textus
   module Hooks
-    class Bus
+    class EventBus
       HOOK_TIMEOUT_SECONDS = 2
 
       class HookTimeout < StandardError; end
 
       EVENTS = {
-        # RPC events — gem-internal, keep :store
-        resolve_intake: { mode: :rpc, args: %i[store config args] },
-        transform_rows: { mode: :rpc, args: %i[store rows config] },
-        validate: { mode: :rpc, args: %i[store] },
-
-        # Pubsub events — ship :ctx (Hooks::Context) instead of raw store
-        entry_put: { mode: :pubsub, args: %i[ctx key envelope] },
-        entry_deleted: { mode: :pubsub, args: %i[ctx key] },
-        entry_refreshed: { mode: :pubsub, args: %i[ctx key envelope change] },
-        entry_renamed: { mode: :pubsub, args: %i[ctx key from_key to_key envelope] },
-        build_completed: { mode: :pubsub, args: %i[ctx key envelope sources] },
-        proposal_accepted: { mode: :pubsub, args: %i[ctx key target_key] },
-        proposal_rejected: { mode: :pubsub, args: %i[ctx key target_key] },
-        file_published: { mode: :pubsub, args: %i[ctx key envelope source target] },
-        store_loaded: { mode: :pubsub, args: %i[ctx] },
-        refresh_started: { mode: :pubsub, args: %i[ctx key mode] },
-        refresh_failed: { mode: :pubsub, args: %i[ctx key error_class error_message] },
-        refresh_backgrounded: { mode: :pubsub, args: %i[ctx key started_at budget_ms] },
+        entry_put: %i[ctx key envelope],
+        entry_deleted: %i[ctx key],
+        entry_refreshed: %i[ctx key envelope change],
+        entry_renamed: %i[ctx key from_key to_key envelope],
+        build_completed: %i[ctx key envelope sources],
+        proposal_accepted: %i[ctx key target_key],
+        proposal_rejected: %i[ctx key target_key],
+        file_published: %i[ctx key envelope source target],
+        store_loaded: %i[ctx],
+        refresh_started: %i[ctx key mode],
+        refresh_failed: %i[ctx key error_class error_message],
+        refresh_backgrounded: %i[ctx key started_at budget_ms],
       }.freeze
 
-      def initialize
-        @rpc    = Hash.new { |h, k| h[k] = {} }
+      RPC_EVENTS = %i[resolve_intake transform_rows validate].freeze
+
+      def initialize(error_log: ErrorLog.new)
         @pubsub = Hash.new { |h, k| h[k] = [] }
         @error_handlers = []
+        @error_log = error_log
       end
 
+      attr_reader :error_log
+
       def on(event, name, keys: nil, &) = register(event, name, keys: keys, &)
 
       def register(event, name, keys: nil, &blk)
         event_sym = event.to_sym
-        spec = EVENTS[event_sym] or raise UsageError.new("unknown event: #{event}")
-        shape_check!(event_sym, spec, blk)
-        name = name.to_sym
-
-        case spec[:mode]
-        when :rpc
-          raise UsageError.new("#{event_sym} '#{name}' already registered") if @rpc[event_sym].key?(name)
+        raise UsageError.new("#{event_sym} is an RPC event; register on RpcRegistry") if RPC_EVENTS.include?(event_sym)
 
-          @rpc[event_sym][name] = blk
-        when :pubsub
-          raise UsageError.new("#{event_sym} hook '#{name}' already registered") if @pubsub[event_sym].any? { |h| h[:name] == name }
+        required = EVENTS[event_sym] or raise UsageError.new("unknown event: #{event}")
+        shape_check!(event_sym, required, blk)
+        name = name.to_sym
+        raise UsageError.new("#{event_sym} hook '#{name}' already registered") if @pubsub[event_sym].any? { |h| h[:name] == name }
 
-          @pubsub[event_sym] << { name: name, callable: blk, keys: keys }
-        end
+        @pubsub[event_sym] << { name: name, callable: blk, keys: keys }
       end
 
       def on_error(&block) = @error_handlers << block
 
-      def rpc_callable(event, name)
-        @rpc[event.to_sym][name.to_sym] or raise UsageError.new("unknown #{event}: #{name}")
-      end
+      def listeners(event, key:) = @pubsub[event.to_sym].select { |h| match?(h[:keys], key) }
 
-      def rpc_names(event)        = @rpc[event.to_sym].keys
-      def pubsub_handlers(event)  = @pubsub[event.to_sym]
-      def listeners(event, key:)  = @pubsub[event.to_sym].select { |h| h[:keys].nil? || matches_any?(h[:keys], key) }
+      def pubsub_handlers(event) = @pubsub[event.to_sym]
 
       def publish(event, strict: false, **kwargs)
         key = kwargs[:key] || "-"
@@ -93,29 +81,33 @@ module Textus
       def invoke(event, sub, key, kwargs)
         accepted = filter_kwargs(sub[:callable], kwargs)
         error = nil
-
         thread = Thread.new do
           sub[:callable].call(**accepted)
         rescue StandardError => e
           error = e
         end
-
         if thread.join(HOOK_TIMEOUT_SECONDS).nil?
           thread.kill
           err = HookTimeout.new("hook #{sub[:name]} exceeded #{HOOK_TIMEOUT_SECONDS}s on event #{event}")
           notify_error(event, sub, key, kwargs, err)
           return [:timed_out, err]
         end
-
         if error
           notify_error(event, sub, key, kwargs, error)
           return [:errored, error]
         end
-
         [:ok, nil]
       end
 
       def notify_error(event, sub, key, kwargs, error)
+        @error_log.record(
+          seq: kwargs[:_audit_seq] || -1,
+          event: event,
+          hook: sub[:name],
+          key: key,
+          error_class: error.class.name,
+          error_message: error.message,
+        )
         @error_handlers.each do |handler|
           handler.call(event: event, hook: sub[:name], key: key, kwargs: kwargs, error: error)
         rescue StandardError => e
@@ -127,18 +119,16 @@ module Textus
         params = callable.parameters
         return kwargs if params.any? { |type, _| type == :keyrest }
 
-        accepted = params.each_with_object([]) do |(type, name), acc|
-          acc << name if %i[key keyreq].include?(type)
-        end
+        accepted = params.each_with_object([]) { |(t, n), acc| acc << n if %i[key keyreq].include?(t) }
         kwargs.slice(*accepted)
       end
 
-      def shape_check!(event, spec, blk)
-        required = spec[:args]
+      def shape_check!(event, required, blk)
         provided = blk.parameters.select { |t, _| %i[keyreq key keyrest].include?(t) } # rubocop:disable Style/HashSlice
-        keyrest  = provided.any? { |t, _| t == :keyrest }
-        missing  = required - provided.map { |_, n| n }
-        return if keyrest || missing.empty?
+        return if provided.any? { |t, _| t == :keyrest }
+
+        missing = required - provided.map { |_, n| n }
+        return if missing.empty?
 
         raise UsageError.new("#{event} hooks must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})")
       end
@@ -148,8 +138,6 @@ module Textus
 
         Array(globs).any? { |g| File.fnmatch?(g, key.to_s, File::FNM_PATHNAME) }
       end
-
-      def matches_any?(globs, key) = match?(globs, key)
     end
   end
 end

data/lib/textus/hooks/loader.rb

@@ -1,8 +1,34 @@
 module Textus
   module Hooks
     class Loader
-      def initialize(bus:)
-        @bus = bus
+      # A small DSL object passed to user hook blocks. Routes `.on(...)` to the
+      # EventBus and `.rpc(...)` / `.register(...)` to the RpcRegistry.
+      class Dsl
+        def initialize(events:, rpc:)
+          @events = events
+          @rpc    = rpc
+        end
+
+        # Pubsub registration — delegates to EventBus.
+        # Also handles RPC event names by delegating to RpcRegistry.
+        def on(event, name, keys: nil, &)
+          if Hooks::RpcRegistry::EVENTS.key?(event.to_sym)
+            @rpc.register(event, name, &)
+          else
+            @events.register(event, name, keys: keys, &)
+          end
+        end
+
+        # Explicit RPC registration.
+        def register(event, name, &)
+          @rpc.register(event, name, &)
+        end
+      end
+
+      def initialize(events:, rpc:)
+        @events = events
+        @rpc    = rpc
+        @dsl    = Dsl.new(events: @events, rpc: @rpc)
       end
 
       def load_dir(dir)
@@ -18,7 +44,7 @@ module Textus
         end
 
         Textus.drain_hook_blocks.each do |blk|
-          blk.call(@bus)
+          blk.call(@dsl)
         rescue StandardError, ScriptError => e
           raise UsageError.new("failed registering hook: #{e.class}: #{e.message}")
         end

data/lib/textus/hooks/rpc_registry.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Textus
+  module Hooks
+    class RpcRegistry
+      EVENTS = {
+        resolve_intake: %i[caps config args],
+        transform_rows: %i[caps rows config],
+        validate: %i[caps],
+      }.freeze
+
+      PUBSUB_EVENTS = EventBus::EVENTS.keys.freeze
+
+      def initialize
+        @table = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def register(event, name, &blk)
+        event_sym = event.to_sym
+        raise UsageError.new("#{event_sym} is a pubsub event; register on EventBus") if PUBSUB_EVENTS.include?(event_sym)
+
+        required = EVENTS[event_sym] or raise UsageError.new("unknown RPC event: #{event}")
+        shape_check!(event_sym, required, blk)
+        name = name.to_sym
+        raise UsageError.new("#{event_sym} '#{name}' already registered") if @table[event_sym].key?(name)
+
+        @table[event_sym][name] = blk
+      end
+
+      def names(event) = @table[event.to_sym].keys
+
+      def callable(event, name)
+        @table[event.to_sym][name.to_sym] or raise UsageError.new("unknown #{event}: #{name}")
+      end
+
+      # Invoke a registered callable, injecting `caps:` under the kwarg name
+      # the callable declares. Legacy `store:` is rejected (no shim).
+      def invoke(event, name, caps:, **other)
+        blk = callable(event, name)
+        params = blk.parameters
+        accepts_keyrest = params.any? { |t, _| t == :keyrest }
+        declared = params.each_with_object([]) { |(t, n), acc| acc << n if %i[key keyreq].include?(t) }
+
+        if declared.include?(:store)
+          raise UsageError.new(
+            "RPC callable for #{event} '#{name}' declares legacy `store:`; rename to `caps:` " \
+            "(Textus::Application::ReadCaps / WriteCaps)",
+          )
+        end
+
+        kwargs = other.dup
+        kwargs[:caps] = caps if accepts_keyrest || declared.include?(:caps)
+        blk.call(**kwargs)
+      end
+
+      private
+
+      def shape_check!(event, required, blk)
+        provided = blk.parameters.select { |t, _| %i[keyreq key keyrest].include?(t) } # rubocop:disable Style/HashSlice
+        return if provided.any? { |t, _| t == :keyrest }
+
+        param_names = provided.map { |_, n| n }
+        # Allow `store:` as a stand-in for `caps:` so registration succeeds;
+        # invoke will raise UsageError when the callable is actually called.
+        effective_required = if param_names.include?(:store)
+                               required.map { |r| r == :caps ? :store : r }
+                             else
+                               required
+                             end
+        missing = effective_required - param_names
+        return if missing.empty?
+
+        raise UsageError.new("#{event} RPC must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})")
+      end
+    end
+  end
+end

data/lib/textus/infra/audit_subscriber.rb

@@ -3,18 +3,17 @@
 module Textus
   module Infra
     # Writes an "event_error" audit row when a user hook raises during
-    # Hooks::Bus publish. Attached at Store boot.
+    # Hooks::EventBus publish. Attached at Store boot.
     #
-    # Integration: uses Hooks::Bus#on_error callback (chosen over a
+    # Integration: uses Hooks::EventBus#on_error callback (chosen over a
     # synthetic :hook_error event because the bus already owns the
     # rescue and the failure is a bus-internal concern, not a domain
     # event subscribers should be able to filter by key glob).
     #
-    # NOTE (0.16 scope): lifecycle audit rows for verb: "put" / "delete" /
-    # "rename" are still written directly by Store::Writer and
-    # Application::Writes::Mv. Moving those into this subscriber requires
-    # event payloads to carry etag_before/etag_after across many write paths;
-    # that is properly a 0.18 port-extraction concern.
+    # Lifecycle audit rows for verb: "put" / "delete" / "rename" are written
+    # by Application::Envelope::Writer directly (it owns the
+    # audit-append-as-final-step invariant); this subscriber covers the
+    # hook-failure case the writer never sees.
     class AuditSubscriber
       def initialize(audit_log)
         @audit_log = audit_log

data/lib/textus/infra/refresh/detached.rb

@@ -21,7 +21,7 @@ module Textus
 
             begin
               store = Textus::Store.new(store_root)
-              Textus::Operations.for(store, role: "runner").refresh(key)
+              store.session(role: "runner").refresh(key)
             rescue StandardError
               # Already logged via :refresh_failed; exit cleanly.
             ensure

data/lib/textus/key/path.rb

@@ -4,12 +4,16 @@ module Textus
       # Returns the absolute filesystem path for a manifest entry (the leaf file,
       # not a nested directory). Adds the format's primary extension when the
       # manifest entry's `path:` is extensionless.
-      def self.resolve(manifest, mentry)
+      #
+      # The first argument is a Manifest::Data (or anything responding to .root);
+      # callers historically passed the whole Manifest but should now pass
+      # `manifest.data`.
+      def self.resolve(data, mentry)
         primary_ext = Entry.for_format(mentry.format).extensions.first
         if File.extname(mentry.path) == ""
-          File.join(manifest.root, "zones", mentry.path + primary_ext)
+          File.join(data.root, "zones", mentry.path + primary_ext)
         else
-          File.join(manifest.root, "zones", mentry.path)
+          File.join(data.root, "zones", mentry.path)
         end
       end
     end

data/lib/textus/manifest/data.rb

@@ -0,0 +1,78 @@
+require_relative "schema"
+require_relative "role_kinds"
+
+module Textus
+  class Manifest
+    # Immutable, parsed view of a manifest YAML document.
+    #
+    # Holds raw structural data (zones, entries, audit_config, role_mapping)
+    # but no behaviour beyond accessors. Behaviour (zone authority, key
+    # resolution, rules) lives on Manifest::Policy / Resolver / Rules.
+    class Data
+      AUDIT_DEFAULTS = { max_size: 10_485_760, keep: 5 }.freeze
+
+      attr_reader :raw, :root, :entries, :zones, :zone_readers, :audit_config, :role_mapping, :policy
+
+      def self.validate_key!(key)
+        raise UsageError.new("empty key") if key.nil? || key.empty?
+
+        Key::Grammar.validate!(key)
+      end
+
+      # Forwarder used by Resolver and Entry classes that received a Data
+      # but were written against the historical Manifest API.
+      def validate_key!(key) = self.class.validate_key!(key)
+
+      def self.parse(raw, root:)
+        raise BadFrontmatter.new(File.join(root.to_s, "manifest.yaml"), "manifest must declare zones:") if Array(raw["zones"]).empty?
+
+        Schema.validate!(raw)
+        new(raw: raw, root: root)
+      end
+
+      def initialize(raw:, root:)
+        @raw = raw
+        @root = root
+        @zones = Array(raw["zones"]).to_h { |z| [z["name"], Array(z["write_policy"])] }
+        @zone_readers = Array(raw["zones"]).to_h do |z|
+          rp = z["read_policy"]
+          [z["name"], rp.nil? ? :all : Array(rp)]
+        end
+        @audit_config = build_audit_config(raw)
+        @role_mapping = RoleKinds.resolve(raw["roles"])
+        # Policy is constructed before entries because Entry validators
+        # call `entry.in_generator_zone?` which routes through Policy.
+        @policy = Policy.new(self)
+        @entries = build_entries(raw)
+        validate_declared_keys!
+        freeze
+      end
+
+      private
+
+      def build_audit_config(raw)
+        a = raw["audit"] || {}
+        {
+          max_size: a["max_size"] || AUDIT_DEFAULTS[:max_size],
+          keep: a["keep"] || AUDIT_DEFAULTS[:keep],
+        }.freeze
+      end
+
+      def build_entries(raw)
+        Array(raw["entries"]).map do |e|
+          entry = Manifest::Entry::Parser.call(self, e)
+          Manifest::Entry::Validators.run_all(entry)
+          entry
+        end.freeze
+      end
+
+      def validate_declared_keys!
+        @entries.each do |e|
+          raise UsageError.new("empty key") if e.key.nil? || e.key.empty?
+
+          Key::Grammar.validate!(e.key)
+        end
+      end
+    end
+  end
+end

data/lib/textus/manifest/entry/base.rb

@@ -19,13 +19,13 @@ module Textus
         # rubocop:enable Metrics/ParameterLists, Lint/MissingSuper
 
         def zone_writers
-          @manifest.zone_writers(@zone)
+          @manifest.policy.zone_writers(@zone)
         rescue UsageError => e
           raise UsageError.new("entry '#{@key}': #{e.message}")
         end
 
-        def in_generator_zone? = @manifest.zone_kinds(@zone).include?(:generator)
-        def in_proposal_zone?  = @manifest.zone_kinds(@zone).include?(:proposer)
+        def in_generator_zone? = @manifest.policy.zone_kinds(@zone).include?(:generator)
+        def in_proposal_zone?  = @manifest.policy.zone_kinds(@zone).include?(:proposer)
 
         def nested?  = false
         def derived? = false
@@ -42,7 +42,7 @@ module Textus
         def index_filename = nil
 
         PublishContext = Struct.new(
-          :repo_root, :manifest, :file_store, :root, :store, :ctx, :bus, :hook_context,
+          :repo_root, :manifest, :file_store, :root, :caps, :rpc, :session, :ctx, :bus, :hook_context,
           :reader, :emit, # callables: reader.call(key) → envelope; emit.call(event, **payload)
           keyword_init: true
         )

data/lib/textus/manifest/entry/derived.rb

@@ -2,8 +2,8 @@ module Textus
   class Manifest
     class Entry
       class Derived < Base
-        Projection = Data.define(:select, :pluck, :sort_by, :transform)
-        External   = Data.define(:sources, :runner)
+        Projection = ::Data.define(:select, :pluck, :sort_by, :transform)
+        External   = ::Data.define(:sources, :runner)
 
         attr_reader :source, :template, :inject_boot, :events
 
@@ -22,9 +22,8 @@ module Textus
         def publish_via(pctx, prefix: nil) # rubocop:disable Lint/UnusedMethodArgument
           return nil unless in_generator_zone?
 
-          target_path = Textus::Application::Writes::Materializer.new(
-            ctx: pctx.ctx, manifest: pctx.manifest, file_store: pctx.file_store,
-            bus: pctx.bus, root: pctx.root, store: pctx.store
+          target_path = Textus::Application::Write::Materializer.new(
+            ctx: pctx.ctx, caps: pctx.caps, rpc: pctx.rpc, session: pctx.session,
           ).run(self)
 
           envelope = pctx.reader.call(@key)

data/lib/textus/manifest/entry/validators/events.rb

@@ -4,7 +4,7 @@ module Textus
       module Validators
         module Events
           def self.call(entry)
-            pubsub_events = Textus::Hooks::Bus::EVENTS.select { |_, s| s[:mode] == :pubsub }.keys
+            pubsub_events = Textus::Hooks::EventBus::EVENTS.keys
             events = entry.events
             events.each_key do |evt|
               next if pubsub_events.include?(evt.to_sym)