textus 0.52.0 → 0.53.0

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

@@ -2,14 +2,14 @@ module Textus
   class Manifest
     class Entry
       class Base < Entry
-        attr_reader :raw, :key, :path, :zone, :schema, :owner, :format, :publish_targets
+        attr_reader :raw, :key, :path, :lane, :schema, :owner, :format, :publish_targets
 
         # rubocop:disable Metrics/ParameterLists, Lint/MissingSuper
-        def initialize(raw:, key:, path:, zone:, schema:, owner:, format:, publish_targets: [])
+        def initialize(raw:, key:, path:, lane:, schema:, owner:, format:, publish_targets: [])
           @raw = raw
           @key = key
           @path = path
-          @zone = zone
+          @lane = lane
           @schema = schema
           @owner = owner
           @format = format
@@ -17,13 +17,14 @@ module Textus
         end
         # rubocop:enable Metrics/ParameterLists, Lint/MissingSuper
 
-        def zone_writers(policy)
-          policy.zone_writers(@zone)
+        def lane_writers(policy)
+          verb = policy.verb_for_lane(@lane)
+          policy.roles_with_capability(verb)
         rescue UsageError => e
           raise UsageError.new("entry '#{@key}': #{e.message}")
         end
 
-        def in_proposal_zone?(policy) = policy.queue_zone?(@zone)
+        def in_proposal_lane?(policy) = policy.queue_lane?(@lane)
 
         def nested?  = false
         def derived? = false
@@ -36,6 +37,9 @@ module Textus
         def external?   = false
         def projection? = false
 
+        alias zone lane
+        alias in_proposal_zone? in_proposal_lane?
+
         # Whether git should track this entry's file. Default true; an entry
         # marked `tracked: false` in the manifest stays protocol-readable but is
         # listed in the generated `.gitignore` (ADR 0043). Cross-cutting, so it
@@ -60,19 +64,19 @@ module Textus
         # Minimal context object passed into entry `publish_via` hooks.
         # Everything beyond the three primitives is derived. Data.define
         # instances are frozen, so we recompute per-call rather than
-        # memoizing — RoleScope/Hooks::Context construction is cheap.
+        # memoizing — RoleScope/Step::Context construction is cheap.
         PublishContext = ::Data.define(:container, :call, :reader) do
           def manifest   = container.manifest
           def root       = container.root
           def repo_root  = File.dirname(container.root)
-          def events     = container.events
+          def steps      = container.steps
 
           def hook_context
-            Textus::Hooks::Context.new(scope: scope_for_hooks)
+            Textus::Step::Context.new(scope: scope_for_hooks)
           end
 
           def emit(event, **payload)
-            events.publish(event, ctx: hook_context, **payload)
+            steps.publish(event, ctx: hook_context, **payload)
           end
 
           # Read a named template from the store's templates/ directory.
@@ -91,7 +95,7 @@ module Textus
           private
 
           def scope_for_hooks
-            Textus::RoleScope.new(
+            Textus::Surfaces::RoleScope.new(
               container: container, role: call.role, dry_run: call.dry_run,
             )
           end

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

@@ -5,7 +5,7 @@ module Textus
         def self.call(raw)
           key = raw["key"] or raise UsageError.new("manifest entry missing key")
           path = raw["path"] or raise UsageError.new("manifest entry '#{key}' missing path")
-          zone = raw["zone"] or raise UsageError.new("manifest entry '#{key}' missing zone")
+          lane = raw["lane"] or raise UsageError.new("manifest entry '#{key}' missing lane")
 
           raw_kind = raw["kind"] or raise BadManifest.new("entry '#{key}' missing required `kind:` (#{Entry::REGISTRY.keys.join("|")})")
           kind = raw_kind.to_sym
@@ -19,7 +19,7 @@ module Textus
 
           common = {
             raw: raw,
-            key: key, path: path, zone: zone,
+            key: key, path: path, lane: lane,
             schema: raw["schema"], owner: raw["owner"],
             format: format,
             publish_targets: publish_targets(raw)
@@ -31,12 +31,12 @@ module Textus
         end
 
         # ADR 0093: an entry's production block is the unified `source:`. Returns a
-        # Domain::Policy::Source; kind (intake/derived) is read from source.from.
+        # Manifest::Policy::Source; kind (intake/derived) is read from source.from.
         def self.parse_source(raw, key)
           block = raw["source"] or
-            raise BadManifest.new("entry '#{key}' requires a source: { from: project|handler|command, ... }")
+            raise BadManifest.new("entry '#{key}' requires a source: { from: derive|fetch|external, ... }")
 
-          Textus::Domain::Policy::Source.new(block)
+          Textus::Manifest::Policy::Source.new(block)
         end
 
         # ADR 0094: `publish:` is a LIST of target objects — to-targets
@@ -52,7 +52,7 @@ module Textus
               "[{to:, template:?} | {tree:}] (ADR 0094); the `publish: { … }` map form was retired",
             )
           end
-          block.map { |t| Textus::Domain::Policy::PublishTarget.new(t) }
+          block.map { |t| Textus::Manifest::Policy::PublishTarget.new(t) }
         end
 
         def self.resolve_format(raw, path)

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

@@ -17,6 +17,8 @@ module Textus
         def derived?    = @source.kind == :derived
         def external?   = @source.external?
         def projection? = @source.projection?
+        def fetch?      = @source.fetch?
+        def derive?     = @source.derive?
         def nested?     = !!@raw["nested"]
         def handler     = @source.handler
         def config      = @source.config
@@ -33,11 +35,10 @@ module Textus
         def publish_via(pctx, prefix: nil)
           built = false
           if projection?
-            Textus::Produce::Acquire::Projection.new(container: pctx.container, call: pctx.call).run(self)
+            Textus::Pipeline::Acquire::Projection.new(container: pctx.container, call: pctx.call).run(self)
             built = true
             pctx.emit(:entry_produced, key: @key, envelope: pctx.reader.call(@key), sources: Array(@source.select).compact)
           end
-
           emitted = publish_mode.publish(pctx, prefix: prefix)
           return emitted if emitted
           return nil unless built

data/lib/textus/manifest/entry/publish/mode.rb

@@ -36,7 +36,7 @@ module Textus
 
           # Store-side directory this entry's tree lives under.
           def store_base(pctx)
-            File.join(pctx.root, "zones", entry.path)
+            File.join(pctx.root, Textus::Key::Path.normalize_relative_path(entry.path))
           end
         end
       end

data/lib/textus/manifest/entry/publish/to_paths.rb

@@ -16,11 +16,12 @@ module Textus
 
           def publish(pctx, prefix: nil) # rubocop:disable Lint/UnusedMethodArgument,Metrics/AbcSize
             targets = entry.publish_targets.select(&:to_target?)
+
             return nil if targets.empty?
 
             data_path = pctx.manifest.resolver.resolve(entry.key).path
             envelope  = pctx.reader.call(entry.key)
-            renderer  = Textus::Produce::Render.new(template_loader: ->(n) { pctx.read_template(n) })
+            renderer  = Textus::Pipeline::Render.new(template_loader: ->(n) { pctx.read_template(n) })
             content = nil # parsed lazily; the data's `content` (always _meta-free)
 
             targets.each do |t|

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

@@ -4,7 +4,7 @@ module Textus
       module Validators
         module Events
           def self.call(entry, policy: nil) # rubocop:disable Lint/UnusedMethodArgument
-            pubsub_events = Textus::Hooks::Catalog::PUBSUB.keys
+            pubsub_events = Textus::Step::Catalog::PUBSUB.keys
             events = entry.events
             events.each_key do |evt|
               next if pubsub_events.include?(evt.to_sym)

data/lib/textus/{domain/policy/handler_allowlist.rb → manifest/policy/handler_permit.rb}

@@ -1,14 +1,14 @@
 module Textus
-  module Domain
-    module Policy
-      class HandlerAllowlist
+  class Manifest
+    class Policy
+      class HandlerPermit
         attr_reader :handlers
 
         def initialize(handlers:)
           @handlers = Array(handlers).map(&:to_s).freeze
         end
 
-        def allows?(handler)
+        def permits?(handler)
           @handlers.include?(handler.to_s)
         end
       end

data/lib/textus/{domain → manifest}/policy/matcher.rb

@@ -1,6 +1,6 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       module Matcher
         module_function
 

data/lib/textus/{domain → manifest}/policy/publish_target.rb

@@ -1,6 +1,6 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       # One publish destination (ADR 0094). Exactly one of:
       #   to-target   { to:, template:?, inject_boot:? }  — render data through a
       #               template, or copy verbatim when no template

data/lib/textus/manifest/policy/react.rb

@@ -0,0 +1,30 @@
+module Textus
+  class Manifest
+    class Policy
+      class React
+        ALLOWED_KEYS = %w[on when do scope budget idempotency observe priority].freeze
+
+        attr_reader :raw
+
+        def initialize(raw:)
+          raise Textus::BadManifest.new("react: must be a map") unless raw.is_a?(Hash)
+
+          raw = raw.each_with_object({}) do |(key, value), out|
+            normalized = key == true ? "on" : key.to_s
+            out[normalized] = value
+          end
+          raise Textus::BadManifest.new("react.ttl is invalid; ttl belongs only to source.ttl or retention.ttl") if raw.key?("ttl")
+
+          unknown = raw.keys - ALLOWED_KEYS
+          raise Textus::BadManifest.new("react: unknown key(s): #{unknown.join(", ")}") unless unknown.empty?
+
+          @raw = raw
+        end
+
+        def to_h
+          @raw
+        end
+      end
+    end
+  end
+end

data/lib/textus/{domain → manifest}/policy/retention.rb

@@ -1,6 +1,6 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       # Garbage collection (ADR 0093). A glob-matched rule slot: when an entry
       # ages past `ttl`, retire it. Destructive only — runs on the full
       # `converge` pass, never on a write (ADR 0079's invariant). Orthogonal to
@@ -21,7 +21,7 @@ module Textus
           raise Textus::BadManifest.new("retention action must be one of #{ACTIONS.join("|")}, got #{raw["action"].inspect}")
         end
 
-        def ttl_seconds = Textus::Domain::Duration.seconds(@ttl)
+        def ttl_seconds = Textus::Core::Duration.seconds(@ttl)
         def destructive? = true
       end
     end

data/lib/textus/{domain → manifest}/policy/source.rb

@@ -1,17 +1,17 @@
 module Textus
-  module Domain
-    module Policy
+  class Manifest
+    class Policy
       # An entry's data-acquisition declaration (ADR 0094). `source:` says HOW the
       # entry's data is acquired; rendering is a publish concern, so there are no
       # template/render fields here. `from` is the acquire + staleness axis:
-      #   from: project -> derived  (internal projection; observable -> rdeps staleness)
-      #   from: handler -> intake   (external fetch; unobservable -> ttl staleness)
-      #   from: command -> external (out-of-band runner; staleness only, textus never runs it)
+      #   from: derive -> derived   (internal projection; observable -> rdeps staleness)
+      #   from: fetch -> intake     (external fetch; unobservable -> ttl staleness)
+      #   from: external -> external (out-of-band runner; staleness only, textus never runs it)
       # Materialization is async-only (job-queue model): a write enqueues a
       # `materialize` job, converged by a worker. There is no per-entry write
       # trigger knob.
       class Source
-        FROMS = %w[project handler command].freeze
+        FROMS = %w[fetch derive external].freeze
 
         attr_reader :from, :handler, :config, :command, :sources
 
@@ -25,16 +25,21 @@ module Textus
           @projection = {}
 
           case @from
-          when "project" then init_project(raw)
-          when "handler" then init_handler(raw)
-          when "command" then init_command(raw)
+          when "fetch" then init_fetch(raw)
+          when "derive" then init_derive(raw)
+          when "external" then init_external(raw)
           end
         end
 
-        def kind        = @from == "handler" ? :intake : :derived
-        def external?   = @from == "command"
-        def projection? = @from == "project"
-        def ttl_seconds = @ttl.nil? ? nil : Textus::Domain::Duration.seconds(@ttl)
+        def kind
+          { "fetch" => :intake, "derive" => :derived, "external" => :external }.fetch(@from)
+        end
+
+        def fetch?      = @from == "fetch"
+        def derive?     = @from == "derive"
+        def external?   = @from == "external"
+        def projection? = derive?
+        def ttl_seconds = @ttl.nil? ? nil : Textus::Core::Duration.seconds(@ttl)
 
         # Flattened projection accessors (ADR 0094) — read directly off the source
         # block; nil when absent or not a projection source.
@@ -49,22 +54,22 @@ module Textus
 
         private
 
-        def init_project(raw)
+        def init_derive(raw)
           %w[select pluck sort_by transform].each { |f| @projection[f] = raw[f] if raw.key?(f) }
           return unless @projection["select"].nil? && @projection["transform"].nil?
 
-          raise Textus::BadManifest.new("source (from: project) requires `select:` and/or `transform:`")
+          raise Textus::BadManifest.new("source (from: derive) requires `select:` and/or `transform:`")
         end
 
-        def init_handler(raw)
+        def init_fetch(raw)
           @handler = raw["handler"] or
-            raise Textus::BadManifest.new("source (from: handler) requires a `handler:` field")
+            raise Textus::BadManifest.new("source (from: fetch) requires a `handler:` field")
           @config = raw["config"] || {}
         end
 
-        def init_command(raw)
+        def init_external(raw)
           @command = raw["command"] or
-            raise Textus::BadManifest.new("source (from: command) requires a `command:` field")
+            raise Textus::BadManifest.new("source (from: external) requires a `command:` field")
           @sources = raw["sources"] || []
         end
       end

data/lib/textus/manifest/policy.rb

@@ -1,23 +1,23 @@
 module Textus
   class Manifest
-    # Authority over zones and roles derived from a Manifest::Data snapshot.
+    # Authority over lanes and roles derived from a Manifest::Data snapshot.
     # Encapsulates the lookups previously living on Manifest itself
-    # (zone_writers, permission_for). Write authority is derived from
-    # capabilities × zone-kind (ADR 0030): each zone-kind requires one verb
-    # (Schema::KIND_REQUIRES_VERB) and a role may write a zone iff its caps
-    # include that verb (verb_for_zone, roles_with_capability). Derived /
+    # (lane_writers, permission_for). Write authority is derived from
+    # capabilities x lane-kind (ADR 0030): each lane-kind requires one verb
+    # (Schema::KIND_REQUIRES_VERB) and a role may write a lane iff its caps
+    # include that verb (verb_for_lane, roles_with_capability). Derived /
     # proposal-queue status is authoritative via the declared-kind family
-    # (declared_kind, derived_entry?, queue_zone?, queue_zone).
+    # (declared_kind, derived_entry?, queue_lane?, queue_lane).
     class Policy
       def initialize(data)
         @data = data
       end
 
-      # The capability a zone's kind requires to be written, or nil if the
-      # zone declares no kind. declared_kind returns a Symbol; the table is
+      # The capability a lane's kind requires to be written, or nil if the
+      # lane declares no kind. declared_kind returns a Symbol; the table is
       # keyed by String.
-      def verb_for_zone(zone_name)
-        kind = declared_kind(zone_name)
+      def verb_for_lane(lane_name)
+        kind = declared_kind(lane_name)
         kind && Schema::KIND_REQUIRES_VERB[kind.to_s]
       end
 
@@ -41,39 +41,24 @@ module Textus
         roles_with_capability(verb).first
       end
 
-      # The roles authorized to write `zone_name`: those holding the verb its
-      # kind requires. Raises on an undeclared zone.
-      def zone_writers(zone_name)
-        raise UsageError.new("undeclared zone '#{zone_name}'") unless @data.declared_zone_kinds.key?(zone_name)
-
-        roles_with_capability(verb_for_zone(zone_name))
-      end
-
-      def permission_for(zone_name)
-        Textus::Domain::Permission.new(
-          zone: zone_name,
-          writers: zone_writers(zone_name),
-        )
+      # The kind declared on a lane in the manifest, or nil if undeclared.
+      def declared_kind(lane_name)
+        @data.declared_lane_kinds[lane_name]
       end
 
-      # The kind declared on a zone in the manifest, or nil if undeclared.
-      def declared_kind(zone_name)
-        @data.declared_zone_kinds[zone_name]
+      # Lane names declaring `kind` (a Symbol), in manifest order. Lets callers
+      # (boot) name a kind's live lane instance(s) instead of hardcoding names.
+      def lanes_of_kind(kind)
+        @data.declared_lane_kinds.select { |_name, k| k == kind }.keys
       end
 
-      # Zone names declaring `kind` (a Symbol), in manifest order. Lets callers
-      # (boot) name a kind's live zone instance(s) instead of hardcoding names.
-      def zones_of_kind(kind)
-        @data.declared_zone_kinds.select { |_name, k| k == kind }.keys
+      # The single lane declaring `kind: queue`, or nil. Schema guarantees <=1.
+      def queue_lane
+        @data.declared_lane_kinds.key(:queue)
       end
 
-      # The single zone declaring `kind: queue`, or nil. Schema guarantees <=1.
-      def queue_zone
-        @data.declared_zone_kinds.key(:queue)
-      end
-
-      # ADR 0091: derived-ness is a property of the ENTRY, not its zone (one
-      # machine zone holds both intake and derived entries). Resolve the entry
+      # ADR 0091: derived-ness is a property of the ENTRY, not its lane (one
+      # machine lane holds both intake and derived entries). Resolve the entry
       # and ask it directly. Returns false if entries are not yet built
       # (validator phase during Data#initialize) — validators must not rely on
       # cross-entry state during construction.
@@ -84,24 +69,27 @@ module Textus
         entry.derived?
       end
 
-      # The single zone declaring kind: machine, or nil.
-      def machine_zone
-        @data.declared_zone_kinds.key(:machine)
+      # The single lane declaring kind: machine, or nil.
+      def machine_lane
+        @data.declared_lane_kinds.key(:machine)
       end
 
-      # A zone is a proposal queue iff it declares kind: queue.
-      def queue_zone?(zone_name)
-        declared_kind(zone_name) == :queue
+      # A lane is a proposal queue iff it declares kind: queue.
+      def queue_lane?(lane_name)
+        declared_kind(lane_name) == :queue
       end
 
-      # The zone a proposer role writes proposals into: the single zone that
+      # The lane a proposer role writes proposals into: the single lane that
       # declares kind: queue, when the role can write it. Returns nil if there
-      # is no queue zone or the role cannot write it.
-      def propose_zone_for(role)
+      # is no queue lane or the role cannot write it.
+      def propose_lane_for(role)
         return nil if role.nil?
 
-        q = queue_zone
-        return nil unless q && zone_writers(q).include?(role)
+        q = queue_lane
+        return nil unless q
+
+        q_verb = verb_for_lane(q)
+        return nil unless roles_with_capability(q_verb).include?(role)
 
         q
       end

data/lib/textus/manifest/resolver.rb

@@ -54,7 +54,8 @@ module Textus
           raise UnknownKey.new(key, suggestions: suggestions_for(key)) unless nested_entry?(entry)
 
           primary_ext = Textus::Entry.for_format(entry.format).extensions.first
-          path = File.join(@data.root, "zones", entry.path, *remaining) + primary_ext
+          base = Textus::Key::Path.normalize_relative_path(entry.path)
+          path = File.join(@data.root, base, *remaining) + primary_ext
           Resolution.new(entry: entry, path: path, remaining: remaining)
         end
       end
@@ -73,7 +74,7 @@ module Textus
         # addressable store keys in the public `list` surface.
         return [] if entry.publish_mode.keyless? && !include_keyless
 
-        base = File.join(@data.root, "zones", entry.path)
+        base = File.join(@data.root, Textus::Key::Path.normalize_relative_path(entry.path))
         return [] unless File.directory?(base)
 
         Dir.glob(File.join(base, nested_glob(entry.format)))

data/lib/textus/manifest/rules.rb

@@ -22,7 +22,7 @@ module Textus
       def for(key)
         slots = PICK_FIELDS.to_h { |f| [f, []] }
         @blocks.each do |b|
-          next unless Textus::Domain::Policy::Matcher.matches?(b.match, key)
+          next unless Textus::Manifest::Policy::Matcher.matches?(b.match, key)
 
           slots.each_key { |slot| slots[slot] << b if b.public_send(slot) }
         end
@@ -30,7 +30,7 @@ module Textus
       end
 
       def explain(key)
-        @blocks.select { |b| Textus::Domain::Policy::Matcher.matches?(b.match, key) }
+        @blocks.select { |b| Textus::Manifest::Policy::Matcher.matches?(b.match, key) }
       end
 
       private
@@ -39,7 +39,7 @@ module Textus
         return nil if blocks.empty?
 
         globs = blocks.map(&:match)
-        winning = Textus::Domain::Policy::Matcher.pick_most_specific(globs, key: key)
+        winning = Textus::Manifest::Policy::Matcher.pick_most_specific(globs, key: key)
         blocks.find { |b| b.match == winning }&.public_send(slot)
       end
 
@@ -57,7 +57,7 @@ module Textus
 
         # One dispatch over the registry, replacing the four bespoke parse_*
         # methods. :deferred carries the raw Hash after a shape check (its
-        # contents validate later — guard predicates at GuardFactory build time,
+        # contents validate later — guard predicates at Dispatch::Auth check time,
         # ADR 0031); :immediate instantiates the policy class now. :tagged passes
         # the raw Hash straight to a policy class that is a tagged union and
         # dispatches on its discriminator field (e.g. upkeep's on:). A mapping

data/lib/textus/manifest/schema/keys.rb

@@ -4,11 +4,11 @@ module Textus
       # The manifest's key whitelists and the rule-field registry — the schema's
       # data tables (ADR 0109; the vocabulary lives in Schema::Vocabulary).
       module Keys
-        ROOT_KEYS  = %w[version roles zones entries rules audit].freeze
+        ROOT_KEYS  = %w[version roles lanes entries rules audit].freeze
         ROLE_KEYS  = %w[name can].freeze
-        ZONE_KEYS  = %w[name kind owner desc].freeze
+        LANE_KEYS  = %w[name kind owner desc].freeze
         ENTRY_KEYS = %w[
-          key path zone kind schema owner nested format
+          key path lane kind schema owner nested format
           source publish
           events ignore tracked
         ].freeze
@@ -40,12 +40,11 @@ module Textus
         #     (in_rule_list / in_rule_explain)
         #
         # Per field:
-        #   yaml_key     manifest key (handler_allowlist's intake_ prefix
-        #                disambiguates from entry-level intake:, ADR 0059)
-        #   policy_class the Domain::Policy backing the field (nil = raw value)
+        #   yaml_key     manifest key used in a rule block
+        #   policy_class the Manifest::Policy backing the field (nil = raw value)
         #   validation   :immediate (instantiate the policy at parse, surfacing
         #                shape errors eagerly), :deferred (shape-check + carry
-        #                the raw Hash; guard predicates validate at GuardFactory
+        #                the raw Hash; guard predicates validate at Dispatch::Auth
         #                build time, ADR 0031), or :tagged (pass the raw Hash to a
         #                tagged-union policy that dispatches on its discriminator
         #                field, e.g. upkeep's on:)
@@ -61,9 +60,9 @@ module Textus
         # Key order here fixes the order of RULE_KEYS (after match), the slots,
         # the RuleSet members, and the doctor SLOTS.
         FIELD_REGISTRY = {
-          handler_allowlist: {
-            yaml_key: "intake_handler_allowlist",
-            policy_class: Textus::Domain::Policy::HandlerAllowlist,
+          handler_permit: {
+            yaml_key: "handler_permit",
+            policy_class: Textus::Manifest::Policy::HandlerPermit,
             validation: :immediate, sub_keys: nil, arg_key: :handlers,
             in_pick: true, in_ambiguity: true,
             in_rule_list: true, in_rule_explain: %i[detail]
@@ -77,11 +76,18 @@ module Textus
           },
           retention: {
             yaml_key: "retention",
-            policy_class: Textus::Domain::Policy::Retention,
+            policy_class: Textus::Manifest::Policy::Retention,
             validation: :tagged, sub_keys: RETENTION_KEYS, arg_key: nil,
             in_pick: true, in_ambiguity: true,
             in_rule_list: true, in_rule_explain: %i[lean detail]
           },
+          react: {
+            yaml_key: "react",
+            policy_class: Textus::Manifest::Policy::React,
+            validation: :immediate, sub_keys: nil, arg_key: :raw,
+            in_pick: true, in_ambiguity: true,
+            in_rule_list: true, in_rule_explain: %i[lean detail]
+          },
         }.freeze
 
         RULE_KEYS = (["match"] + FIELD_REGISTRY.values.map { |m| m[:yaml_key] }).freeze