textus 0.4.0 → 0.8.0

data/lib/textus/manifest/entry.rb

@@ -0,0 +1,199 @@
+module Textus
+  class Manifest
+    class Entry
+      PUBLISH_EACH_VARS = %w[leaf basename key ext].freeze
+      PUBLISH_EACH_VAR_RE = /\{([a-z]+)\}/
+
+      attr_reader :key, :path, :zone, :schema, :owner, :nested, :generator, :raw, :format,
+                  :projection, :template, :publish_to, :publish_each, :fetch, :fetch_config, :ttl, :events,
+                  :inject_intro
+
+      def initialize(manifest, raw)
+        @manifest = manifest
+        @raw = 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")
+        @schema = raw["schema"]
+        @owner = raw["owner"]
+        @nested = raw["nested"] == true
+        @generator = raw["generator"]
+        @projection = raw["projection"]
+        @template = raw["template"]
+        @publish_to = Array(raw["publish_to"])
+        @publish_each = raw["publish_each"]
+        @events = raw["events"] || {}
+        @inject_intro = raw["inject_intro"] == true
+        @format = resolve_format!(raw["format"])
+
+        validate_events!
+        parse_source!(raw["source"])
+        reject_legacy_projection_keys!
+        validate_format_matrix!
+        validate_publish_each!
+        validate_inject_intro!
+      end
+
+      # Resolves the per-leaf target path (relative to repo root) for a full
+      # dotted key under this entry's prefix. Returns nil if this entry has no
+      # publish_each template.
+      def publish_target_for(full_key)
+        return nil if @publish_each.nil?
+
+        entry_segs = @key.split(".")
+        key_segs = full_key.split(".")
+        raise UsageError.new("key '#{full_key}' is not under entry '#{@key}'") unless key_segs[0, entry_segs.length] == entry_segs
+
+        remaining = key_segs[entry_segs.length..] || []
+        leaf = remaining.join("/")
+        basename = remaining.last || ""
+        ext = Textus::Entry.for_format(@format).extensions.first.to_s.sub(/^\./, "")
+
+        vars = { "leaf" => leaf, "basename" => basename, "key" => full_key, "ext" => ext }
+        @publish_each.gsub(PUBLISH_EACH_VAR_RE) { vars.fetch(::Regexp.last_match(1)) }
+      end
+
+      def derived?
+        writers = @manifest.zone_writers(@zone)
+        writers.include?("build")
+      rescue UsageError => e
+        raise UsageError.new("entry '#{@key}': #{e.message}")
+      end
+
+      private
+
+      def validate_inject_intro!
+        return unless @inject_intro
+
+        unless derived?
+          raise UsageError.new(
+            "entry '#{@key}': inject_intro: is only valid on derived entries",
+          )
+        end
+        return unless @template.nil?
+
+        raise UsageError.new(
+          "entry '#{@key}': inject_intro: requires a template:",
+        )
+      end
+
+      def validate_publish_each!
+        return if @publish_each.nil?
+
+        raise UsageError.new("entry '#{@key}': publish_each requires nested: true") unless @nested
+        raise UsageError.new("entry '#{@key}': publish_to and publish_each are mutually exclusive") unless @publish_to.empty?
+        raise UsageError.new("entry '#{@key}': publish_each must be a string") unless @publish_each.is_a?(String)
+
+        used_vars = @publish_each.scan(PUBLISH_EACH_VAR_RE).flatten
+        unknown = used_vars - PUBLISH_EACH_VARS
+        unless unknown.empty?
+          raise UsageError.new(
+            "entry '#{@key}': publish_each uses unknown template variable(s) " \
+            "#{unknown.map { |v| "{#{v}}" }.join(", ")}. Known: #{PUBLISH_EACH_VARS.map { |v| "{#{v}}" }.join(", ")}.",
+          )
+        end
+
+        required = %w[leaf basename key]
+        return if used_vars.any? { |v| required.include?(v) }
+
+        raise UsageError.new(
+          "entry '#{@key}': publish_each must reference at least one of {leaf}, {basename}, or {key} " \
+          "(else every leaf would clobber the same target).",
+        )
+      end
+
+      def resolve_format!(declared)
+        ext = File.extname(@path)
+        inferred = Manifest::EXT_TO_FORMAT[ext]
+
+        if declared.nil?
+          return inferred if inferred
+          # No extension: nested defaults to markdown, leaf with no ext also markdown.
+          return "markdown" if ext == "" && @nested
+          return "markdown" if ext == ""
+        else
+          unless Manifest::EXT_TO_FORMAT.values.include?(declared)
+            raise UsageError.new("entry '#{@key}': unknown format #{declared.inspect}")
+          end
+          # If the path has an extension, the declared format must match.
+          if ext != "" && inferred && inferred != declared
+            raise UsageError.new(
+              "entry '#{@key}': path extension #{ext.inspect} does not match declared format #{declared.inspect}",
+            )
+          end
+          return declared
+        end
+
+        "markdown"
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def validate_format_matrix!
+        ext = File.extname(@path)
+
+        case @format
+        when "markdown"
+          # .md, or no extension (will be appended). Anything else is a mismatch caught above.
+          raise UsageError.new("entry '#{@key}': markdown format requires '.md' path (got #{ext.inspect})") if ext != "" && ext != ".md"
+        when "json"
+          if @nested
+            # nested json: path is a directory; ext must be empty.
+            raise UsageError.new("entry '#{@key}': nested json path must not have an extension") if ext != ""
+          elsif ext != ".json"
+            raise UsageError.new("entry '#{@key}': json format requires '.json' path (got #{ext.inspect})")
+          end
+        when "yaml"
+          if @nested
+            raise UsageError.new("entry '#{@key}': nested yaml path must not have an extension") if ext != ""
+          elsif ext != ".yaml" && ext != ".yml"
+            raise UsageError.new("entry '#{@key}': yaml format requires '.yaml' or '.yml' path (got #{ext.inspect})")
+          end
+        when "text"
+          if @nested
+            raise UsageError.new("entry '#{@key}': nested text path must not have an extension") if ext != ""
+          elsif ext != ".txt" && ext != ""
+            raise UsageError.new("entry '#{@key}': text format requires '.txt' or no extension (got #{ext.inspect})")
+          end
+        end
+
+        # Schema rules.
+        raise UsageError.new("entry '#{@key}': text format must not declare a schema") if @format == "text" && !@schema.nil?
+
+        # Template-required-for-derived rules. Skipped for entries materialized by an
+        # external generator: command (those produce the bytes themselves).
+        if derived? && @template.nil? && @generator.nil? &&
+           (@format == "markdown" || @format == "text") && !@nested
+          raise UsageError.new("entry '#{@key}': derived #{@format} entries require a template")
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def parse_source!(src)
+        src ||= {}
+        raise UsageError.new("entry '#{@key}': source.action renamed to source.fetch in 0.6") if src.key?("action")
+
+        @fetch = src["fetch"]
+        @fetch_config = src["config"] || {}
+        @ttl = src["ttl"]
+      end
+
+      def reject_legacy_projection_keys!
+        return unless @projection.is_a?(Hash) && @projection.key?("reducer")
+
+        raise UsageError.new("entry '#{@key}': projection.reducer renamed to projection.reduce in 0.6")
+      end
+
+      def validate_events!
+        pubsub_events = Hooks::Registry::EVENTS.select { |_, s| s[:mode] == :pubsub }.keys
+        @events.each_key do |evt|
+          next if pubsub_events.include?(evt.to_sym)
+
+          raise UsageError.new(
+            "entry '#{@key}': unknown event '#{evt}' in events: block. " \
+            "Known events: #{pubsub_events.join(", ")}.",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/textus/manifest.rb

@@ -2,11 +2,6 @@ require "yaml"
 
 module Textus
   class Manifest
-    # New stricter grammar: lowercase + digits + internal hyphens. No underscores.
-    KEY_SEGMENT = /\A[a-z0-9][a-z0-9-]*\z/
-    MAX_SEGMENTS = 8
-    MAX_SEGMENT_LEN = 64
-
     EXT_TO_FORMAT = {
       ".md" => "markdown",
       ".json" => "json",
@@ -17,23 +12,8 @@ module Textus
 
     attr_reader :root, :entries, :raw
 
-    LEGACY_ZONES = {
-      "fixed" => ["human"],
-      "state" => %w[human ai script],
-      "derived" => ["build"],
-    }.freeze
-
     def zones
-      @zones ||= begin
-        declared = Array(@raw["zones"])
-        if declared.empty?
-          LEGACY_ZONES.transform_values(&:dup)
-        else
-          declared.to_h do |z|
-            [z["name"], Array(z["writable_by"])]
-          end
-        end
-      end
+      @zones ||= Array(@raw["zones"]).to_h { |z| [z["name"], Array(z["writable_by"])] }
     end
 
     def zone_writers(zone_name)
@@ -45,7 +25,14 @@ module Textus
       raise IoError.new("manifest not found: #{manifest_path}") unless File.exist?(manifest_path)
 
       raw = YAML.safe_load_file(manifest_path, aliases: false)
-      raise BadFrontmatter.new(manifest_path, "unsupported manifest version #{raw["version"].inspect}") unless raw["version"] == PROTOCOL
+      unless raw["version"] == PROTOCOL
+        msg = if raw["version"] == "textus/1"
+                "manifest is textus/1; edit manifest.yaml: change 'version: textus/1' to 'version: #{PROTOCOL}'"
+              else
+                "unsupported manifest version #{raw["version"].inspect}"
+              end
+        raise BadFrontmatter.new(manifest_path, msg)
+      end
 
       new(root, raw)
     end
@@ -53,11 +40,13 @@ module Textus
     def initialize(root, raw)
       @root = root
       @raw = raw
-      @entries = Array(raw["entries"]).map { |e| ManifestEntry.new(self, e) }
+      raise BadFrontmatter.new(File.join(root, "manifest.yaml"), "manifest must declare zones:") if Array(raw["zones"]).empty?
+
+      @entries = Array(raw["entries"]).map { |e| Manifest::Entry.new(self, e) }
       validate_declared_keys!
     end
 
-    # Returns [ManifestEntry, resolved_path, remaining_segments]
+    # Returns [Manifest::Entry, resolved_path, remaining_segments]
     def resolve(key)
       validate_key!(key)
       segments = key.split(".")
@@ -76,7 +65,7 @@ module Textus
       else
         raise UnknownKey.new(key, suggestions: suggestions_for(key)) unless entry.nested
 
-        primary_ext = Entry.for_format(entry.format).extensions.first
+        primary_ext = Textus::Entry.for_format(entry.format).extensions.first
         path = File.join(@root, "zones", entry.path, *remaining) + primary_ext
         [entry, path, remaining]
       end
@@ -89,7 +78,7 @@ module Textus
       # Include declared (non-nested) entry keys even if file is missing.
       candidates.concat(@entries.reject(&:nested).map(&:key))
       candidates.uniq!
-      KeyDistance.suggest(key, candidates, limit: 5)
+      Key::Distance.suggest(key, candidates, limit: 5)
     rescue StandardError
       []
     end
@@ -113,7 +102,7 @@ module Textus
 
             illegal = segs.find { |s| !valid_segment?(s) }
             if illegal
-              warn("textus: skipping illegal key segment '#{illegal}' at #{fp} — run 'textus migrate-keys --dry-run'")
+              warn("textus: skipping illegal key segment '#{illegal}' at #{fp} — run 'textus key migrate --dry-run'")
               next
             end
 
@@ -144,30 +133,16 @@ module Textus
     def validate_key!(key)
       raise UsageError.new("empty key") if key.nil? || key.empty?
 
-      segs = key.split(".")
-      raise UsageError.new("key '#{key}' has #{segs.length} segments (max #{MAX_SEGMENTS})") if segs.length > MAX_SEGMENTS
-
-      segs.each do |seg|
-        if seg.empty?
-          raise UsageError.new("empty segment in key '#{key}'")
-        elsif seg.length > MAX_SEGMENT_LEN
-          raise UsageError.new("segment '#{seg}' in key '#{key}' exceeds #{MAX_SEGMENT_LEN} chars")
-        elsif !seg.match?(KEY_SEGMENT)
-          raise UsageError.new(
-            "invalid key segment '#{seg}' in '#{key}': must match [a-z0-9][a-z0-9-]* " \
-            "(lowercase, digits, hyphens; no underscores or uppercase)",
-          )
-        end
-      end
+      Key::Grammar.validate!(key)
     end
 
     private
 
     def valid_segment?(seg)
       return false if seg.nil? || seg.empty?
-      return false if seg.length > MAX_SEGMENT_LEN
+      return false if seg.length > Key::Grammar::MAX_SEGMENT_LEN
 
-      seg.match?(KEY_SEGMENT)
+      seg.match?(Key::Grammar::SEGMENT)
     end
 
     def validate_declared_keys!
@@ -175,12 +150,7 @@ module Textus
     end
 
     def resolve_leaf_path(entry)
-      primary_ext = Entry.for_format(entry.format).extensions.first
-      if File.extname(entry.path) == ""
-        File.join(@root, "zones", entry.path + primary_ext)
-      else
-        File.join(@root, "zones", entry.path)
-      end
+      Textus::Key::Path.resolve(self, entry)
     end
 
     def nested_glob(format)
@@ -193,208 +163,4 @@ module Textus
       end
     end
   end
-
-  class ManifestEntry
-    PUBLISH_EACH_VARS = %w[leaf basename key ext].freeze
-    PUBLISH_EACH_VAR_RE = /\{([a-z]+)\}/
-
-    attr_reader :key, :path, :zone, :schema, :owner, :nested, :generator, :raw, :format,
-                :projection, :template, :publish_to, :publish_each, :action, :action_config, :ttl, :events,
-                :inject_intro
-
-    def initialize(manifest, raw)
-      @manifest = manifest
-      @raw = 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")
-      @schema = raw["schema"]
-      @owner = raw["owner"]
-      @nested = raw["nested"] == true
-      @generator = raw["generator"]
-      @projection = raw["projection"]
-      @template = raw["template"]
-      @publish_to = Array(raw["publish_to"])
-      @publish_each = raw["publish_each"]
-      @events = raw["events"] || {}
-      @inject_intro = raw["inject_intro"] == true
-      @format = resolve_format!(raw["format"])
-
-      reject_legacy!(raw)
-      parse_source!(raw["source"])
-      validate_format_matrix!
-      validate_publish_each!
-      validate_inject_intro!
-    end
-
-    # Resolves the per-leaf target path (relative to repo root) for a full
-    # dotted key under this entry's prefix. Returns nil if this entry has no
-    # publish_each template.
-    def publish_target_for(full_key)
-      return nil if @publish_each.nil?
-
-      entry_segs = @key.split(".")
-      key_segs = full_key.split(".")
-      raise UsageError.new("key '#{full_key}' is not under entry '#{@key}'") unless key_segs[0, entry_segs.length] == entry_segs
-
-      remaining = key_segs[entry_segs.length..] || []
-      leaf = remaining.join("/")
-      basename = remaining.last || ""
-      ext = Entry.for_format(@format).extensions.first.to_s.sub(/^\./, "")
-
-      vars = { "leaf" => leaf, "basename" => basename, "key" => full_key, "ext" => ext }
-      @publish_each.gsub(PUBLISH_EACH_VAR_RE) { vars.fetch(::Regexp.last_match(1)) }
-    end
-
-    def derived?
-      writers = @manifest.zone_writers(@zone)
-      writers.include?("build")
-    rescue UsageError => e
-      raise UsageError.new("entry '#{@key}': #{e.message}")
-    end
-
-    private
-
-    def validate_inject_intro!
-      return unless @inject_intro
-
-      unless derived?
-        raise UsageError.new(
-          "entry '#{@key}': inject_intro: is only valid on derived entries",
-        )
-      end
-      return unless @template.nil?
-
-      raise UsageError.new(
-        "entry '#{@key}': inject_intro: requires a template:",
-      )
-    end
-
-    def validate_publish_each!
-      return if @publish_each.nil?
-
-      raise UsageError.new("entry '#{@key}': publish_each requires nested: true") unless @nested
-      raise UsageError.new("entry '#{@key}': publish_to and publish_each are mutually exclusive") unless @publish_to.empty?
-      raise UsageError.new("entry '#{@key}': publish_each must be a string") unless @publish_each.is_a?(String)
-
-      used_vars = @publish_each.scan(PUBLISH_EACH_VAR_RE).flatten
-      unknown = used_vars - PUBLISH_EACH_VARS
-      unless unknown.empty?
-        raise UsageError.new(
-          "entry '#{@key}': publish_each uses unknown template variable(s) " \
-          "#{unknown.map { |v| "{#{v}}" }.join(", ")}. Known: #{PUBLISH_EACH_VARS.map { |v| "{#{v}}" }.join(", ")}.",
-        )
-      end
-
-      required = %w[leaf basename key]
-      return if used_vars.any? { |v| required.include?(v) }
-
-      raise UsageError.new(
-        "entry '#{@key}': publish_each must reference at least one of {leaf}, {basename}, or {key} " \
-        "(else every leaf would clobber the same target).",
-      )
-    end
-
-    def resolve_format!(declared)
-      ext = File.extname(@path)
-      inferred = Manifest::EXT_TO_FORMAT[ext]
-
-      if declared.nil?
-        return inferred if inferred
-        # No extension: nested defaults to markdown, leaf with no ext also markdown.
-        return "markdown" if ext == "" && @nested
-        return "markdown" if ext == ""
-      else
-        raise UsageError.new("entry '#{@key}': unknown format #{declared.inspect}") unless Manifest::EXT_TO_FORMAT.values.include?(declared)
-        # If the path has an extension, the declared format must match.
-        if ext != "" && inferred && inferred != declared
-          raise UsageError.new(
-            "entry '#{@key}': path extension #{ext.inspect} does not match declared format #{declared.inspect}",
-          )
-        end
-        return declared
-      end
-
-      "markdown"
-    end
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def validate_format_matrix!
-      ext = File.extname(@path)
-
-      case @format
-      when "markdown"
-        # .md, or no extension (will be appended). Anything else is a mismatch caught above.
-        raise UsageError.new("entry '#{@key}': markdown format requires '.md' path (got #{ext.inspect})") if ext != "" && ext != ".md"
-      when "json"
-        if @nested
-          # nested json: path is a directory; ext must be empty.
-          raise UsageError.new("entry '#{@key}': nested json path must not have an extension") if ext != ""
-        elsif ext != ".json"
-          raise UsageError.new("entry '#{@key}': json format requires '.json' path (got #{ext.inspect})")
-        end
-      when "yaml"
-        if @nested
-          raise UsageError.new("entry '#{@key}': nested yaml path must not have an extension") if ext != ""
-        elsif ext != ".yaml" && ext != ".yml"
-          raise UsageError.new("entry '#{@key}': yaml format requires '.yaml' or '.yml' path (got #{ext.inspect})")
-        end
-      when "text"
-        if @nested
-          raise UsageError.new("entry '#{@key}': nested text path must not have an extension") if ext != ""
-        elsif ext != ".txt" && ext != ""
-          raise UsageError.new("entry '#{@key}': text format requires '.txt' or no extension (got #{ext.inspect})")
-        end
-      end
-
-      # Schema rules.
-      raise UsageError.new("entry '#{@key}': text format must not declare a schema") if @format == "text" && !@schema.nil?
-
-      # Template-required-for-derived rules. Skipped for entries materialized by an
-      # external generator: command (those produce the bytes themselves).
-      if derived? && @template.nil? && @generator.nil? &&
-         (@format == "markdown" || @format == "text") && !@nested
-        raise UsageError.new("entry '#{@key}': derived #{@format} entries require a template")
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    def parse_source!(src)
-      src ||= {}
-      @action = src["action"]
-      @action_config = src["config"] || {}
-      @ttl = src["ttl"]
-    end
-
-    def reject_legacy!(raw)
-      src = raw["source"] || {}
-      if src.key?("parse") || src.key?("from")
-        raise UsageError.new(
-          "entry '#{@key}': source.parse/source.from removed in 0.2; " \
-          "use source.action (+ source.config). See SPEC §5.4.",
-        )
-      end
-      if src.key?("fetcher")
-        raise UsageError.new(
-          "entry '#{@key}': source.fetcher renamed to source.action in 0.4; " \
-          "rename the key. See SPEC §5.4.",
-        )
-      end
-      if raw.key?("hooks")
-        raise UsageError.new(
-          "entry '#{@key}': 'hooks:' renamed to 'events:' in 0.2; " \
-          "remove on_ prefix from event names. See SPEC §5.10.",
-        )
-      end
-
-      @events.each_key do |evt|
-        next if ExtensionRegistry::EVENTS.include?(evt.to_sym)
-
-        raise UsageError.new(
-          "entry '#{@key}': unknown event '#{evt}' in events: block. " \
-          "Known events: #{ExtensionRegistry::EVENTS.join(", ")}.",
-        )
-      end
-    end
-  end
 end

data/lib/textus/migrate_keys.rb

@@ -112,7 +112,7 @@ module Textus
     # ------------------------------------------------------------------
 
     def apply!(store, renames)
-      audit = AuditLog.new(store.root)
+      audit = Store::AuditLog.new(store.root)
       renames.each do |r|
         # Bottom-up order means a child's ancestors haven't moved yet, so
         # `from`/`to` are valid as-recorded. The audit `key` reflects the

data/lib/textus/projection.rb

@@ -18,7 +18,7 @@ module Textus
       explicit_pluck = !@spec["pluck"].nil? && @spec["pluck"] != "*"
       rows = keys.map do |key|
         env = @store.get(key)
-        row = pluck(env["frontmatter"], env["body"])
+        row = pluck(env["_meta"], env["body"])
         explicit_pluck ? row : row.merge("_key" => key)
       end
       reduced = apply_reducer(rows)
@@ -38,13 +38,14 @@ module Textus
     private
 
     def apply_reducer(rows)
-      name = @spec["reducer"] or return rows
-      callable = @store.registry.reducer(name)
+      name = @spec["reduce"] or return rows
+      callable = @store.registry.rpc_callable(:reduce, name)
+      view = Store::View.new(@store)
       Timeout.timeout(REDUCER_TIMEOUT_SECONDS) do
-        callable.call(rows: rows, config: @spec["reducer_config"] || {})
+        callable.call(store: view, rows: rows, config: @spec["reduce_config"] || {})
       end
     rescue Timeout::Error
-      raise UsageError.new("reducer '#{name}' exceeded #{REDUCER_TIMEOUT_SECONDS}s timeout")
+      raise UsageError.new("reduce '#{name}' exceeded #{REDUCER_TIMEOUT_SECONDS}s timeout")
     end
 
     def collect_keys

data/lib/textus/proposal.rb

@@ -4,15 +4,15 @@ module Textus
       raise ProposalError.new("only human role can accept proposals; got '#{as}'") unless as == "human"
 
       env = store.get(pending_key)
-      proposal = env["frontmatter"]["proposal"] or raise ProposalError.new("entry has no proposal block: #{pending_key}")
+      proposal = env["_meta"]["proposal"] or raise ProposalError.new("entry has no proposal block: #{pending_key}")
       target = proposal["target_key"] or raise ProposalError.new("proposal missing target_key")
       action = proposal["action"] || "put"
 
       case action
       when "put"
-        target_fm = env["frontmatter"]["frontmatter"] || {}
+        target_meta = env["_meta"]["frontmatter"] || {}
         target_body = env["body"]
-        store.put(target, frontmatter: target_fm, body: target_body, as: "human")
+        store.put(target, meta: target_meta, body: target_body, as: "human")
       when "delete"
         store.delete(target, as: "human")
       else
@@ -20,7 +20,7 @@ module Textus
       end
 
       store.delete(pending_key, as: "human")
-      store.fire_event(:accept, pending_key: pending_key, target_key: target)
+      store.fire_event(:accept, key: pending_key, target_key: target)
       { "protocol" => PROTOCOL, "accepted" => pending_key, "target_key" => target, "action" => action }
     end
   end