textus 0.18.0 → 0.20.0

data/lib/textus/application/writes/mv.rb

@@ -1,60 +1,46 @@
-require "fileutils"
-
 module Textus
   module Application
     module Writes
       class Mv
-        MovePlan = Data.define(
-          :old_key, :new_key, :old_path, :new_path,
-          :new_mentry, :uid, :etag_before
-        )
-
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        def initialize(ctx:, manifest:, envelope_io:, bus:, authorizer:, hook_context:)
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(old_key, new_key, dry_run: false)
-          plan, pre_env = prepare_plan(old_key, new_key)
-          return dry_run_result(plan) if dry_run
+          old_res, new_res = prepare(old_key, new_key)
+          return dry_run_result(old_key, new_key, old_res, new_res) if dry_run
 
-          plan = ensure_uid!(plan, pre_env: pre_env)
-          etag_after = perform_move!(plan)
-          new_envelope = record_move(plan, etag_after: etag_after)
-          success_result(plan, new_envelope: new_envelope)
+          ensure_uid!(old_key, old_res.entry)
+          envelope = @envelope_io.move(
+            from_key: old_key, to_key: new_key,
+            new_mentry: new_res.entry
+          )
+          publish_renamed(old_key, new_key, envelope)
+          success_result(old_key, new_key, old_res, new_res, envelope)
         end
 
         private
 
-        def manifest = @ctx.manifest
-        def reader_get(key) = (@reader_get ||= Textus::Application::Reads::Get.new(ctx: @ctx)).call(key)
-
-        def prepare_plan(old_key, new_key)
-          manifest.validate_key!(old_key)
-          manifest.validate_key!(new_key)
+        def prepare(old_key, new_key)
+          @manifest.validate_key!(old_key)
+          @manifest.validate_key!(new_key)
           raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
 
-          old_res = manifest.resolve(old_key)
-          old_mentry = old_res.entry
-          old_path = old_res.path
-          raise UnknownKey.new(old_key) unless @ctx.file_store.exists?(old_path)
+          old_res = @manifest.resolver.resolve(old_key)
+          new_res = @manifest.resolver.resolve(new_key)
+          raise UnknownKey.new(old_key) unless @envelope_io.exists?(old_res.path)
 
-          new_res = manifest.resolve(new_key)
-          new_mentry = new_res.entry
-          new_path = new_res.path
-          validate_zone_and_format!(old_mentry, new_mentry)
-          @ctx.authorize_write!(old_mentry)
-          @ctx.authorize_write!(new_mentry)
-          raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if @ctx.file_store.exists?(new_path)
+          validate_zone_and_format!(old_res.entry, new_res.entry)
+          @authorizer.authorize_write!(old_res.entry, role: @ctx.role)
+          @authorizer.authorize_write!(new_res.entry, role: @ctx.role)
+          raise UsageError.new("mv: target '#{new_key}' already exists at #{new_res.path}") if @envelope_io.exists?(new_res.path)
 
-          pre_env = reader_get(old_key)
-          plan = MovePlan.new(
-            old_key: old_key, new_key: new_key,
-            old_path: old_path, new_path: new_path,
-            new_mentry: new_mentry,
-            uid: pre_env.uid, etag_before: pre_env.etag
-          )
-          [plan, pre_env]
+          [old_res, new_res]
         end
 
         def validate_zone_and_format!(old_mentry, new_mentry)
@@ -69,73 +55,50 @@ module Textus
           raise UsageError.new("mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.")
         end
 
-        def ensure_uid!(plan, pre_env:)
-          return plan if plan.uid
-
-          env = Textus::Application::Writes::Put.new(ctx: @ctx, envelope_io: @envelope_io).call(
-            plan.old_key,
-            meta: pre_env.meta,
-            body: pre_env.body,
-            content: pre_env.content,
-            suppress_events: true,
+        # If the source file lacks a UID, rewrite it in-place via EnvelopeIO#write
+        # so a UID gets injected before the move. This replaces the previous
+        # Put(suppress_events: true) bypass with a direct EnvelopeIO call —
+        # producing one "put" audit row, then the "mv" row from EnvelopeIO#move.
+        def ensure_uid!(old_key, old_mentry)
+          pre_env = @envelope_io.read_envelope(old_key)
+          return if pre_env.uid
+
+          @envelope_io.write(
+            old_key, mentry: old_mentry,
+                     payload: EnvelopeIO::Payload.new(
+                       meta: pre_env.meta, body: pre_env.body, content: pre_env.content,
+                     )
           )
-          plan.with(uid: env.uid, etag_before: env.etag)
         end
 
-        def perform_move!(plan)
-          FileUtils.mkdir_p(File.dirname(plan.new_path))
-          FileUtils.mv(plan.old_path, plan.new_path)
-          rewrite_name_for_mv!(plan.new_mentry, plan.new_path, plan.new_key)
-          Etag.for_file(plan.new_path)
+        def publish_renamed(old_key, new_key, envelope)
+          @bus.publish(:entry_renamed,
+                       ctx: @hook_context,
+                       key: new_key,
+                       from_key: old_key,
+                       to_key: new_key,
+                       envelope: envelope)
         end
 
-        def record_move(plan, etag_after:)
-          extras = {
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid
-          }
-          extras["correlation_id"] = @ctx.correlation_id if @ctx.correlation_id
-
-          @ctx.audit_log.append(
-            role: @ctx.role, verb: "mv", key: plan.new_key,
-            etag_before: plan.etag_before, etag_after: etag_after,
-            extras: extras
-          )
-          new_envelope = reader_get(plan.new_key)
-          @ctx.bus.publish(:entry_renamed,
-                           store: @ctx.with_role(@ctx.role),
-                           key: plan.new_key,
-                           from_key: plan.old_key,
-                           to_key: plan.new_key,
-                           envelope: new_envelope,
-                           correlation_id: @ctx.correlation_id)
-          new_envelope
-        end
-
-        def dry_run_result(plan)
+        def dry_run_result(old_key, new_key, old_res, new_res)
+          pre_env = @envelope_io.read_envelope(old_key)
           {
             "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid
+            "from_key" => old_key, "to_key" => new_key,
+            "from_path" => old_res.path, "to_path" => new_res.path,
+            "uid" => pre_env.uid
           }
         end
 
-        def success_result(plan, new_envelope:)
+        def success_result(old_key, new_key, old_res, new_res, envelope)
           {
             "protocol" => PROTOCOL, "ok" => true,
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid,
-            "envelope" => new_envelope.to_h_for_wire
+            "from_key" => old_key, "to_key" => new_key,
+            "from_path" => old_res.path, "to_path" => new_res.path,
+            "uid" => envelope.uid,
+            "envelope" => envelope.to_h_for_wire
           }
         end
-
-        def rewrite_name_for_mv!(mentry, new_path, new_key)
-          basename = new_key.split(".").last
-          Entry.for_format(mentry.format).rewrite_name(new_path, basename)
-        end
       end
     end
   end

data/lib/textus/application/writes/publish.rb

@@ -1,37 +1,102 @@
 module Textus
   module Application
     module Writes
-      # Copies nested-leaf entries to their `publish_each:` targets. Fires
-      # `:file_published` for each copy. Mirror of `Build` for the publish
-      # half — split out from the old Build per ADR 0007.
+      # Single-pass publish use case: materializes Derived entries (template +
+      # projection + external runner) AND copies Leaf/Nested entries to their
+      # publish targets. Replaces the former two-step Build + Publish split.
+      #
+      # Return shape: { "protocol", "built", "published_leaves" }
+      # — wire-compatible with what the `textus build` CLI verb previously
+      #   assembled by merging Build + old Publish results.
       class Publish
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(ctx:, manifest:, file_store:, bus:, root:, store:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @file_store   = file_store
+          @bus          = bus
+          @root         = root
+          @store        = store
+          @hook_context = hook_context
         end
 
         def call(prefix: nil)
-          repo_root = File.dirname(store.root)
-          out = []
-          manifest.entries.each do |mentry|
-            next unless mentry.nested && mentry.publish_each
-            next if prefix && !mentry.key.start_with?(prefix) && !prefix.start_with?("#{mentry.key}.")
+          built  = []
+          leaves = []
+          repo_root = File.dirname(@root)
 
-            manifest.enumerate(prefix: mentry.key).each do |row|
-              next unless row[:manifest_entry].equal?(mentry)
-              next if prefix && !row[:key].start_with?(prefix) && row[:key] != prefix
+          @manifest.entries.each do |mentry|
+            next if prefix && !entry_matches_prefix?(mentry, prefix)
 
-              out << publish_leaf(mentry, row, repo_root)
+            case mentry
+            when Textus::Manifest::Entry::Derived
+              next unless mentry.in_generator_zone?
+
+              result = materialize_derived(mentry, repo_root)
+              built << result if result
+            when Textus::Manifest::Entry::Nested
+              next unless mentry.publish_each
+
+              publish_nested(mentry, repo_root, prefix, leaves)
+            when Textus::Manifest::Entry::Leaf
+              next if Array(mentry.publish_to).empty?
+
+              result = publish_leaf_entry(mentry, repo_root)
+              built << result if result
             end
           end
-          { "protocol" => Textus::PROTOCOL, "published_leaves" => out }
+
+          { "protocol" => Textus::PROTOCOL, "built" => built, "published_leaves" => leaves }
         end
 
         private
 
-        def store = @ctx.store
-        def manifest = store.manifest
+        # Materialize a Derived entry and copy to publish_to targets.
+        def materialize_derived(mentry, repo_root)
+          target_path = Materializer.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+            bus: @bus, root: @root, store: @store
+          ).run(mentry)
 
-        def publish_leaf(mentry, row, repo_root)
+          publish_derived_copies(mentry, target_path, repo_root)
+          fire_build_completed(mentry, target_path)
+
+          { "key" => mentry.key, "path" => target_path, "published_to" => mentry.publish_to }
+        end
+
+        def publish_derived_copies(mentry, target_path, repo_root)
+          envelope = reader.call(mentry.key)
+          mentry.publish_to.each do |rel|
+            target_abs = File.join(repo_root, rel)
+            Textus::Infra::Publisher.publish(source: target_path, target: target_abs, store_root: @root)
+            publish_event(:file_published,
+                          key: mentry.key,
+                          envelope: envelope,
+                          source: target_path,
+                          target: target_abs)
+          end
+        end
+
+        def fire_build_completed(mentry, target_path) # rubocop:disable Lint/UnusedMethodArgument
+          envelope = reader.call(mentry.key)
+          src = mentry.source
+          selects = src.is_a?(Textus::Manifest::Entry::Derived::Projection) ? Array(src.select).compact : []
+          publish_event(:build_completed,
+                        key: mentry.key,
+                        envelope: envelope,
+                        sources: selects)
+        end
+
+        # Publish each leaf under a Nested entry's publish_each pattern.
+        def publish_nested(mentry, repo_root, prefix, accumulator)
+          @manifest.resolver.enumerate(prefix: mentry.key).each do |row|
+            next unless row[:manifest_entry].equal?(mentry)
+            next if prefix && !row[:key].start_with?(prefix) && row[:key] != prefix
+
+            accumulator << publish_nested_leaf(mentry, row, repo_root)
+          end
+        end
+
+        def publish_nested_leaf(mentry, row, repo_root)
           target_rel = mentry.publish_target_for(row[:key])
           target_abs = File.expand_path(File.join(repo_root, target_rel))
           unless target_abs.start_with?(File.expand_path(repo_root) + File::SEPARATOR)
@@ -40,16 +105,57 @@ module Textus
             )
           end
 
-          Textus::Infra::Publisher.publish(source: row[:path], target: target_abs, store_root: store.root)
-          @ctx.bus.publish(:file_published,
-                           store: @ctx.with_role(@ctx.role),
-                           key: row[:key],
-                           envelope: Textus::Application::Reads::Get.new(ctx: @ctx).call(row[:key]),
-                           source: row[:path],
-                           target: target_abs,
-                           correlation_id: @ctx.correlation_id)
+          Textus::Infra::Publisher.publish(source: row[:path], target: target_abs, store_root: @root)
+          publish_event(:file_published,
+                        key: row[:key],
+                        envelope: reader.call(row[:key]),
+                        source: row[:path],
+                        target: target_abs)
           { "key" => row[:key], "source" => row[:path], "target" => target_abs }
         end
+
+        # Publish a standalone Leaf entry that has publish_to targets.
+        def publish_leaf_entry(mentry, repo_root)
+          source_path = @manifest.resolver.resolve(mentry.key).path
+          envelope = reader.call(mentry.key)
+
+          mentry.publish_to.each do |rel|
+            target_abs = File.join(repo_root, rel)
+            Textus::Infra::Publisher.publish(source: source_path, target: target_abs, store_root: @root)
+            publish_event(:file_published,
+                          key: mentry.key,
+                          envelope: envelope,
+                          source: source_path,
+                          target: target_abs)
+          end
+
+          { "key" => mentry.key, "path" => source_path, "published_to" => mentry.publish_to }
+        end
+
+        # Whether the entry should be processed for the given prefix filter.
+        def entry_matches_prefix?(mentry, prefix)
+          return true unless prefix
+
+          case mentry
+          when Textus::Manifest::Entry::Nested
+            # Nested: process if the entry key is a prefix of `prefix` or
+            # `prefix` is a prefix of the entry key (a leaf under it).
+            mentry.key.start_with?(prefix) ||
+              prefix.start_with?("#{mentry.key}.")
+          else
+            mentry.key.start_with?(prefix)
+          end
+        end
+
+        def reader
+          @reader ||= Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          )
+        end
+
+        def publish_event(event, **payload)
+          @bus.publish(event, ctx: @hook_context, **payload)
+        end
       end
     end
   end

data/lib/textus/application/writes/put.rb

@@ -2,16 +2,20 @@ module Textus
   module Application
     module Writes
       class Put
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        def initialize(ctx:, manifest:, envelope_io:, bus:, authorizer:, hook_context:)
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
-        def call(key, meta: nil, body: nil, content: nil, if_etag: nil, suppress_events: false)
-          @ctx.manifest.validate_key!(key)
-          mentry = @ctx.manifest.resolve(key).entry
+        def call(key, meta: nil, body: nil, content: nil, if_etag: nil)
+          @manifest.validate_key!(key)
+          mentry = @manifest.resolver.resolve(key).entry
 
-          @ctx.authorize_write!(mentry)
+          @authorizer.authorize_write!(mentry, role: @ctx.role)
 
           envelope = @envelope_io.write(
             key,
@@ -20,13 +24,10 @@ module Textus
             if_etag: if_etag,
           )
 
-          unless suppress_events
-            @ctx.bus.publish(:entry_put,
-                             store: @ctx.with_role(@ctx.role),
-                             key: key,
-                             envelope: envelope,
-                             correlation_id: @ctx.correlation_id)
-          end
+          @bus.publish(:entry_put,
+                       ctx: @hook_context,
+                       key: key,
+                       envelope: envelope)
 
           envelope
         end

data/lib/textus/application/writes/reject.rb

@@ -2,32 +2,41 @@ module Textus
   module Application
     module Writes
       class Reject
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        def initialize(ctx:, manifest:, file_store:, envelope_io:, bus:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @file_store   = file_store
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(pending_key)
           raise ProposalError.new("only human role can reject proposals; got '#{@ctx.role}'") unless @ctx.role == "human"
 
-          mentry = @ctx.manifest.resolve(pending_key).entry
+          mentry = @manifest.resolver.resolve(pending_key).entry
           unless mentry.in_proposal_zone?
             raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})")
           end
 
-          env = Textus::Application::Reads::Get.new(ctx: @ctx).call(pending_key)
+          env = Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          ).call(pending_key)
           proposal = env.meta&.dig("proposal") or
             raise ProposalError.new("entry has no proposal block: #{pending_key}")
           target_key = proposal["target_key"] or
             raise ProposalError.new("proposal missing target_key")
 
-          Textus::Application::Writes::Delete.new(ctx: @ctx, envelope_io: @envelope_io).call(pending_key, suppress_events: true)
+          Textus::Application::Writes::Delete.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io,
+            bus: @bus, authorizer: @authorizer, hook_context: @hook_context
+          ).call(pending_key, suppress_events: true)
 
-          @ctx.bus.publish(:proposal_rejected,
-                           store: @ctx.with_role(@ctx.role),
-                           key: pending_key,
-                           target_key: target_key,
-                           correlation_id: @ctx.correlation_id)
+          @bus.publish(:proposal_rejected,
+                       ctx: @hook_context,
+                       key: pending_key,
+                       target_key: target_key)
 
           { "protocol" => PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
         end

data/lib/textus/builder/pipeline.rb

@@ -7,11 +7,15 @@ module Textus
       # Returns a new hash with _meta as the first key, per SPEC §6 ordering.
       def self.call(content_hash, mentry)
         meta = { "generated_at" => Time.now.utc.iso8601 }
-        from = Array(mentry.projection&.fetch("select", nil)).compact
-        meta["from"] = from unless from.empty?
+        if mentry.is_a?(Textus::Manifest::Entry::Derived)
+          src = mentry.source
+          if src.is_a?(Textus::Manifest::Entry::Derived::Projection)
+            from = Array(src.select).compact
+            meta["from"] = from unless from.empty?
+            meta["reduce"] = src.transform if src.transform
+          end
+        end
         meta["template"] = mentry.template if mentry.template
-        reduce = mentry.projection&.dig("transform")
-        meta["reduce"] = reduce if reduce
 
         out = { "_meta" => meta }
         content_hash.each { |k, v| out[k] = v unless k == "_meta" }
@@ -58,22 +62,23 @@ module Textus
         }
       end
 
-      def self.run(store:, mentry:, template_loader:)
+      # rubocop:disable Metrics/ParameterLists
+      def self.run(mentry:, manifest:, reader:, lister:, transform_resolver:, template_loader:,
+                   transform_context: nil, inject_intro: nil)
         # 1. Load sources + project + reduce
         data =
-          if mentry.projection
-            ops = Operations.for(store)
-            Projection.new(
-              reader: ops.method(:get),
-              spec: mentry.projection,
-              lister: ops.method(:list),
-              transform_resolver: ->(name) { store.registry.rpc_callable(:transform_rows, name) },
-              transform_context: Application::Context.system(store),
+          if mentry.is_a?(Textus::Manifest::Entry::Derived) && mentry.projection?
+            Application::Projection.new(
+              reader: reader,
+              spec: mentry.source.to_h.transform_keys(&:to_s),
+              lister: lister,
+              transform_resolver: transform_resolver,
+              transform_context: transform_context,
             ).run
           else
             { "entries" => [], "count" => 0, "generated_at" => Time.now.utc.iso8601 }
           end
-        data = data.merge("intro" => Intro.run(store)) if mentry.inject_intro
+        data = data.merge("intro" => inject_intro.call) if mentry.inject_intro && inject_intro
 
         # 2. Render
         klass = renderers[mentry.format] or
@@ -81,12 +86,13 @@ module Textus
         bytes = klass.new(template_loader: template_loader).call(mentry: mentry, data: data)
 
         # 3. Write (idempotent: skip if only generated_at would differ)
-        target_path = Key::Path.resolve(store.manifest, mentry)
+        target_path = Key::Path.resolve(manifest, mentry)
         FileUtils.mkdir_p(File.dirname(target_path))
         write_if_changed(target_path, bytes, mentry.format)
 
         target_path
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def self.write_if_changed(target_path, bytes, format)
         if File.exist?(target_path)

data/lib/textus/builder/renderer/json.rb

@@ -28,7 +28,10 @@ module Textus
         end
 
         def default_shape(mentry, data)
-          if mentry.projection && mentry.projection["transform"] && data.is_a?(Hash) && !data.key?("entries")
+          has_transform = mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+                          mentry.source.is_a?(Textus::Manifest::Entry::Derived::Projection) &&
+                          mentry.source.transform
+          if has_transform && data.is_a?(Hash) && !data.key?("entries")
             data
           elsif data.is_a?(Hash) && data["entries"].is_a?(Array)
             { "entries" => data["entries"] }

data/lib/textus/builder/renderer/markdown.rb

@@ -8,10 +8,16 @@ module Textus
           raise TemplateError.new("entry '#{mentry.key}': markdown build requires a template") unless mentry.template
 
           body = Mustache.render(@template_loader.call(mentry.template), data)
+          from = if mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+                    mentry.source.is_a?(Textus::Manifest::Entry::Derived::Projection)
+                   Array(mentry.source.select).compact
+                 else
+                   []
+                 end
           frontmatter = {
             "generated" => {
               "at" => Time.now.utc.iso8601,
-              "from" => Array(mentry.projection&.fetch("select", nil)).compact,
+              "from" => from,
             },
           }
           Entry.for_format("markdown").serialize(meta: frontmatter, body: body)

data/lib/textus/builder/renderer/yaml.rb

@@ -28,7 +28,10 @@ module Textus
         end
 
         def default_shape(mentry, data)
-          if mentry.projection && mentry.projection["transform"] && data.is_a?(Hash) && !data.key?("entries")
+          has_transform = mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+                          mentry.source.is_a?(Textus::Manifest::Entry::Derived::Projection) &&
+                          mentry.source.transform
+          if has_transform && data.is_a?(Hash) && !data.key?("entries")
             data
           elsif data.is_a?(Hash) && data["entries"].is_a?(Array)
             { "entries" => data["entries"] }

data/lib/textus/cli/verb/build.rb

@@ -9,11 +9,8 @@ module Textus
         def call(store)
           Textus::Infra::BuildLock.with(root: store.root) do
             ops = Textus::Operations.for(store, role: "builder")
-            build_res   = ops.build(prefix: prefix)
-            publish_res = ops.publish(prefix: prefix)
-            emit({ "protocol" => Textus::PROTOCOL,
-                   "built" => build_res["built"],
-                   "published_leaves" => publish_res["published_leaves"] })
+            result = ops.publish(prefix: prefix)
+            emit(result)
           end
         end
       end

data/lib/textus/cli/verb/get.rb

@@ -9,7 +9,7 @@ module Textus
         def call(store)
           key = positional.shift or raise UsageError.new("get requires a key")
           result = operations_for(store).get_or_refresh(key)
-          raise Textus::UnknownKey.new(key, suggestions: store.manifest.suggestions_for(key)) if result.nil?
+          raise Textus::UnknownKey.new(key, suggestions: store.manifest.resolver.suggestions_for(key)) if result.nil?
 
           emit(result.to_h_for_wire)
         end

data/lib/textus/cli/verb/hook_run.rb

@@ -26,13 +26,12 @@ module Textus
             end
           end
 
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          callable = store.registry.rpc_callable(:resolve_intake, name)
-          view = Application::Context.new(store: store, role: role)
+          Role.resolve(flag: as_flag, env: ENV, root: store.root)
+          callable = store.bus.rpc_callable(:resolve_intake, name)
 
           begin
             Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do
-              callable.call(config: {}, store: view, args: args)
+              callable.call(config: {}, store: store, args: args)
             end
           rescue Timeout::Error
             raise UsageError.new(