textus 0.5.0 → 0.8.0

data/lib/textus/hooks/registry.rb

@@ -0,0 +1,73 @@
+module Textus
+  module Hooks
+    class Registry
+      EVENTS = {
+        # RPC: exactly 1 handler per name; return value flows into store; failure aborts.
+        fetch: { mode: :rpc, args: %i[store config args] },
+        reduce: { mode: :rpc, args: %i[store rows config] },
+        check: { mode: :rpc, args: %i[store] },
+
+        # Pub-sub: 0..N handlers per event; return discarded; failure logged to audit.
+        put: { mode: :pubsub, args: %i[store key envelope] },
+        delete: { mode: :pubsub, args: %i[store key] },
+        refresh: { mode: :pubsub, args: %i[store key envelope change] },
+        build: { mode: :pubsub, args: %i[store key envelope sources] },
+        accept: { mode: :pubsub, args: %i[store key target_key] },
+      }.freeze
+
+      def initialize(dispatcher: nil)
+        @rpc        = Hash.new { |h, k| h[k] = {} }   # event => { name => callable }
+        @pubsub     = Hash.new { |h, k| h[k] = [] }   # event => [{name:, callable:, keys:}]
+        @dispatcher = dispatcher
+      end
+
+      def register(event, name, keys: nil, &blk)
+        spec = EVENTS[event.to_sym] or raise UsageError.new("unknown event: #{event}")
+        shape_check!(event, spec, blk)
+        name = name.to_sym
+
+        case spec[:mode]
+        when :rpc
+          raise UsageError.new("#{event} '#{name}' already registered") if @rpc[event.to_sym].key?(name)
+
+          @rpc[event.to_sym][name] = blk
+        when :pubsub
+          raise UsageError.new("#{event} hook '#{name}' already registered") if @pubsub[event.to_sym].any? { |h| h[:name] == name }
+
+          @pubsub[event.to_sym] << { name: name, callable: blk, keys: keys }
+          @dispatcher&.subscribe(event, name, keys: keys, &blk)
+        end
+      end
+
+      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| h[:keys].nil? || matches_any?(h[:keys], key) }
+      end
+
+      def rpc_names(event) = @rpc[event.to_sym].keys
+      def pubsub_handlers(event) = @pubsub[event.to_sym]
+
+      private
+
+      def shape_check!(event, spec, blk)
+        required = spec[:args]
+        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?
+
+        raise UsageError.new(
+          "#{event} hooks must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})",
+        )
+      end
+
+      def matches_any?(globs, key)
+        Array(globs).any? { |g| File.fnmatch?(g, key.to_s, File::FNM_PATHNAME) }
+      end
+    end
+  end
+end

data/lib/textus/init.rb

@@ -22,27 +22,30 @@ module Textus
 
       FileUtils.mkdir_p(File.join(target_root, "schemas"))
       FileUtils.mkdir_p(File.join(target_root, "templates"))
-      FileUtils.mkdir_p(File.join(target_root, "extensions"))
+      FileUtils.mkdir_p(File.join(target_root, "hooks"))
       ZONES.each do |z|
         dir = File.join(target_root, "zones", z)
         FileUtils.mkdir_p(dir)
         File.write(File.join(dir, ".gitkeep"), "")
       end
-      File.write(File.join(target_root, "extensions", "README.md"), <<~MD)
-        # Extensions
+      File.write(File.join(target_root, "hooks", "README.md"), <<~MD)
+        # Hooks
 
-        Drop one Ruby file per extension. Four verbs are available:
+        Drop one Ruby file per hook. All extensions register through one DSL.
+        Every handler receives `store:` as its first kwarg, then event-specific args.
 
         ```ruby
-        Textus.action(:name)         { |config:, store:, args:| ... }
-        Textus.reducer(:name)        { |rows:, config:|         ... }
-        Textus.hook(:event, :name)   { |key:, envelope:, **kw|  ... }
-        Textus.doctor_check(:name)   { |store:|                 ... }
+        Textus.hook(:fetch,  :name) { |store:, config:, args:|  ... }   # bring bytes in
+        Textus.hook(:reduce, :name) { |store:, rows:, config:|  ... }   # transform rows
+        Textus.hook(:check,  :name) { |store:|                  ... }   # doctor check
+        Textus.hook(:put,    :name, keys: ["..."])                      # lifecycle listener
+                                    { |store:, key:, envelope:| ... }
         ```
 
-        Events: :put, :delete, :refresh, :build, :accept.
+        Events: :fetch, :reduce, :check (rpc — return value used)
+                :put, :delete, :refresh, :build, :accept (pub-sub — return discarded)
 
-        See SPEC.md §5.11 for the full contract.
+        See SPEC.md §5.10 for the full table.
       MD
 
       File.write(File.join(target_root, "manifest.yaml"), DEFAULT_MANIFEST)

data/lib/textus/intro.rb

@@ -37,14 +37,14 @@ module Textus
       { "name" => "schema",   "summary" => "field shape for a key family" },
       { "name" => "put",      "summary" => "write an entry; --as=<role>, --stdin payload" },
       { "name" => "accept",   "summary" => "apply a pending.* proposal; --as=human only" },
-      { "name" => "mv",       "summary" => "rename a key in place; uid preserved, audit row written" },
+      { "name" => "key",      "summary" => "key operations: 'key mv', 'key uid', 'key migrate'" },
       { "name" => "delete",   "summary" => "delete an entry; --as=<role>" },
       { "name" => "build",    "summary" => "materialize derived entries; publish_to and publish_each fan out copies" },
       { "name" => "refresh",  "summary" => "run an action for an intake entry" },
       { "name" => "stale",    "summary" => "list derived/intake entries past their freshness check" },
       { "name" => "doctor",   "summary" => "health-check the store (missing schemas, illegal keys, sentinel drift, etc.)" },
-      { "name" => "migrate-keys", "summary" => "rename files whose basenames violate the strict key grammar" },
-      { "name" => "extensions", "summary" => "list registered actions, reducers, doctor_checks, declared hooks" },
+      { "name" => "hook",
+        "summary" => "list and run registered hooks: 'hook list', 'hook run NAME'" },
     ].freeze
 
     def self.run(store)
@@ -80,7 +80,7 @@ module Textus
           "owner" => e.owner,
           "format" => e.format,
           "derived" => derived,
-          "intake" => !e.action.nil?,
+          "intake" => !e.fetch.nil?,
           "publish_to" => Array(e.publish_to),
           "publish_each" => e.publish_each,
         }
@@ -89,18 +89,16 @@ module Textus
 
     def self.extensions_for(store)
       reg = store.registry
-      reducers = reg.reducer_names.map(&:to_s).sort
-      actions = reg.action_names.map(&:to_s).sort
-      doctor_checks = reg.doctor_check_names.map(&:to_s).sort
-      hooks = reg.hook_events.flat_map do |evt|
-        reg.hooks(evt).map { |h| { "event" => evt.to_s, "name" => h[:name].to_s } }
-      end.sort_by { |h| [h["event"], h["name"]] }
-      {
-        "reducers" => reducers,
-        "actions" => actions,
-        "doctor_checks" => doctor_checks,
-        "hooks" => hooks,
-      }
+      sections = {}
+      Hooks::Registry::EVENTS.each do |event, spec|
+        case spec[:mode]
+        when :rpc
+          sections[event.to_s] = reg.rpc_names(event).map(&:to_s).sort
+        when :pubsub
+          sections[event.to_s] = reg.pubsub_handlers(event).map { |h| h[:name].to_s }.sort
+        end
+      end
+      sections
     end
   end
 end

data/lib/textus/key/distance.rb

@@ -0,0 +1,55 @@
+module Textus
+  module Key
+    # Small utilities for ranking key suggestions. Bounded inputs only —
+    # Levenshtein is O(n*m) so we refuse to compute on long strings.
+    class Distance
+      MAX_LEN = 200
+
+      # Length of the shared dot-separated prefix between two dotted keys.
+      def self.shared_prefix_segments(left, right)
+        asegs = left.split(".")
+        bsegs = right.split(".")
+        n = [asegs.length, bsegs.length].min
+        i = 0
+        i += 1 while i < n && asegs[i] == bsegs[i]
+        i
+      end
+
+      # Classic iterative Levenshtein with two rows. Bounded to MAX_LEN.
+      def self.levenshtein(left, right)
+        return nil if left.length > MAX_LEN || right.length > MAX_LEN
+        return right.length if left.empty?
+        return left.length if right.empty?
+
+        prev = (0..right.length).to_a
+        curr = Array.new(right.length + 1, 0)
+        (1..left.length).each do |i|
+          curr[0] = i
+          (1..right.length).each do |j|
+            cost = left[i - 1] == right[j - 1] ? 0 : 1
+            curr[j] = [
+              curr[j - 1] + 1,      # insertion
+              prev[j] + 1,          # deletion
+              prev[j - 1] + cost,   # substitution
+            ].min
+          end
+          prev, curr = curr, prev
+        end
+        prev[right.length]
+      end
+
+      # Rank candidate keys against requested. Returns up to `limit` keys.
+      # Sort: longer shared prefix first; then smaller Levenshtein distance.
+      def self.suggest(requested, candidates, limit: 5)
+        return [] if requested.nil? || requested.empty?
+
+        scored = candidates.first(200).map do |k|
+          prefix = shared_prefix_segments(requested, k)
+          dist = levenshtein(requested, k) || Float::INFINITY
+          [k, prefix, dist]
+        end
+        scored.sort_by { |(_, prefix, dist)| [-prefix, dist] }.first(limit).map(&:first)
+      end
+    end
+  end
+end

data/lib/textus/key/grammar.rb

@@ -0,0 +1,33 @@
+module Textus
+  module Key
+    module Grammar
+      SEGMENT = /\A[a-z0-9][a-z0-9-]*\z/
+      MAX_SEGMENTS = 8
+      MAX_SEGMENT_LEN = 64
+
+      module_function
+
+      def validate!(key) # rubocop:disable Naming/PredicateMethod
+        raise UsageError.new("key must be a String") unless key.is_a?(String)
+        raise UsageError.new("empty key") if 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?(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
+        true
+      end
+    end
+  end
+end

data/lib/textus/key/path.rb

@@ -0,0 +1,17 @@
+module Textus
+  module Key
+    module Path
+      # 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)
+        primary_ext = Entry.for_format(mentry.format).extensions.first
+        if File.extname(mentry.path) == ""
+          File.join(manifest.root, "zones", mentry.path + primary_ext)
+        else
+          File.join(manifest.root, "zones", mentry.path)
+        end
+      end
+    end
+  end
+end

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",
@@ -32,7 +27,7 @@ module Textus
       raw = YAML.safe_load_file(manifest_path, aliases: false)
       unless raw["version"] == PROTOCOL
         msg = if raw["version"] == "textus/1"
-                "manifest is textus/1; run 'textus migrate v2' to upgrade. See SPEC §15."
+                "manifest is textus/1; edit manifest.yaml: change 'version: textus/1' to 'version: #{PROTOCOL}'"
               else
                 "unsupported manifest version #{raw["version"].inspect}"
               end
@@ -47,11 +42,11 @@ module Textus
       @raw = raw
       raise BadFrontmatter.new(File.join(root, "manifest.yaml"), "manifest must declare zones:") if Array(raw["zones"]).empty?
 
-      @entries = Array(raw["entries"]).map { |e| ManifestEntry.new(self, e) }
+      @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(".")
@@ -70,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
@@ -83,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
@@ -107,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
 
@@ -138,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!
@@ -169,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)

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

@@ -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

@@ -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