textus 0.8.1 → 0.10.0

data/lib/textus/store/mover.rb

@@ -4,14 +4,15 @@ module Textus
   class Store
     # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     class Mover
-      def initialize(reader:, writer:, manifest:, audit_log:)
+      def initialize(store:, reader:, writer:, manifest:, audit_log:)
+        @store = store
         @reader = reader
         @writer = writer
         @manifest = manifest
         @audit_log = audit_log
       end
 
-      def call(old_key, new_key, as: Role::DEFAULT, dry_run: false)
+      def call(old_key, new_key, as: Role::DEFAULT, dry_run: false, correlation_id: nil)
         @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
@@ -69,23 +70,27 @@ module Textus
         rewrite_name_for_mv!(new_mentry, new_path, new_key)
         etag_after = Etag.for_file(new_path)
 
+        extras = {
+          "from_key" => old_key, "to_key" => new_key,
+          "from_path" => old_path, "to_path" => new_path,
+          "uid" => current_uid
+        }
+        extras["correlation_id"] = correlation_id if correlation_id
+
         @audit_log.append(
           role: as, verb: "mv", key: new_key,
           etag_before: etag_before, etag_after: etag_after,
-          extras: {
-            "from_key" => old_key, "to_key" => new_key,
-            "from_path" => old_path, "to_path" => new_path,
-            "uid" => current_uid
-          }
+          extras: extras
         )
 
-        env = @reader.get(new_key)
+        new_envelope = @reader.get(new_key)
+        @store.fire_event(:mv, key: new_key, from_key: old_key, to_key: new_key, envelope: new_envelope)
         {
           "protocol" => PROTOCOL, "ok" => true,
           "from_key" => old_key, "to_key" => new_key,
           "from_path" => old_path, "to_path" => new_path,
           "uid" => current_uid,
-          "envelope" => env
+          "envelope" => new_envelope
         }
       end
 

data/lib/textus/store/reader.rb

@@ -7,20 +7,22 @@ module Textus
       end
 
       def get(key)
+        read_raw_envelope(key) || raise(UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)))
+      end
+
+      # Reads the current on-disk state of key as a bare envelope, skipping
+      # freshness annotation to avoid recursion. Used by Freshness.refresh_sync
+      # after a sync refresh completes.
+      def read_raw_envelope(key)
         mentry, path, = @manifest.resolve(key)
-        raise UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)) unless File.exist?(path)
+        return nil unless File.exist?(path)
 
         raw = File.binread(path)
         parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-        meta = parsed["_meta"]
-        content = parsed["content"]
-        @store.writer.enforce_name_match!(path, meta, mentry.format)
-        schema = @store.schema_for(mentry.schema)
-        Entry.for_format(mentry.format).validate_against(schema, parsed) if schema
         Envelope.build(
           key: key, mentry: mentry, path: path,
-          meta: meta, body: parsed["body"],
-          etag: Etag.for_bytes(raw), content: content
+          meta: parsed["_meta"], body: parsed["body"],
+          etag: Etag.for_bytes(raw), content: parsed["content"]
         )
       end
 

data/lib/textus/store/staleness.rb

@@ -11,7 +11,7 @@ module Textus
       def call(prefix: nil, zone: nil)
         out = []
         @manifest.entries.each do |mentry|
-          next unless mentry.zone == "derived"
+          next unless mentry.in_generator_zone?
           next if zone && mentry.zone != zone
 
           gen = mentry.generator
@@ -47,11 +47,12 @@ module Textus
         end
 
         @manifest.entries.each do |mentry|
-          next unless mentry.fetch
+          next unless mentry.intake_handler
           next if zone && mentry.zone != zone
           next if prefix && !(mentry.key == prefix || mentry.key.start_with?("#{prefix}."))
 
-          ttl = parse_ttl(mentry.ttl)
+          policy_set = @manifest.policies_for(mentry.key)
+          ttl = policy_set.refresh&.ttl_seconds
           next unless ttl
 
           path = Textus::Key::Path.resolve(@manifest, mentry)
@@ -102,21 +103,8 @@ module Textus
         nil
       end
 
-      def parse_ttl(s)
-        return nil unless s
-
-        m = s.to_s.match(/\A(\d+)([smhd])\z/) or return nil
-        n = m[1].to_i
-        case m[2]
-        when "s" then n
-        when "m" then n * 60
-        when "h" then n * 3600
-        when "d" then n * 86_400
-        end
-      end
-
       def intake_stale_row(mentry, path, reason)
-        { "key" => mentry.key, "path" => path, "fetch" => mentry.fetch, "reason" => reason }
+        { "key" => mentry.key, "path" => path, "handler" => mentry.intake_handler, "reason" => reason }
       end
 
       def stale_row(mentry, path, reason)

data/lib/textus/store/validator.rb

@@ -10,14 +10,30 @@ module Textus
 
       def call
         violations = []
+        check_content_violations(violations)
+        check_role_authority_violations(violations)
+        { "protocol" => PROTOCOL, "ok" => violations.empty?, "violations" => violations }
+      end
+
+      private
+
+      def check_content_violations(violations)
         @manifest.enumerate.each do |row|
+          key = row[:key]
+          mentry = row[:manifest_entry]
+          env = fetch_envelope(key, violations) or next
+          schema = mentry.schema && @schema_for.call(mentry.schema)
+          next unless schema
+
           begin
-            @reader.get(row[:key])
+            validate_schema!(schema, env, mentry.format)
           rescue Textus::Error => e
-            violations << { "key" => row[:key], "code" => e.code, "message" => e.message }
+            violations << { "key" => key, "code" => e.code, "message" => e.message }
           end
         end
+      end
 
+      def check_role_authority_violations(violations)
         @manifest.enumerate.each do |row|
           mentry = row[:manifest_entry]
           next unless mentry.schema
@@ -30,26 +46,36 @@ module Textus
           rescue StandardError
             next
           end
-          last_writer = @audit_log.last_writer_for(row[:key])
-          next if last_writer.nil?
-
-          env["_meta"].each_key do |field|
-            owner = schema.maintained_by(field)
-            next if owner.nil?
-            next if last_writer == owner
-            next if last_writer == "human"
-
-            violations << {
-              "key" => row[:key],
-              "code" => "role_authority",
-              "field" => field,
-              "expected" => owner,
-              "last_writer" => last_writer,
-            }
-          end
+          append_authority_violations(violations, row[:key], env, schema)
         end
+      end
 
-        { "protocol" => PROTOCOL, "ok" => violations.empty?, "violations" => violations }
+      def append_authority_violations(violations, key, env, schema)
+        last_writer = @audit_log.last_writer_for(key)
+        return if last_writer.nil?
+
+        env["_meta"].each_key do |field|
+          owner = schema.maintained_by(field)
+          next if owner.nil? || last_writer == owner || last_writer == "human"
+
+          violations << { "key" => key, "code" => "role_authority",
+                          "field" => field, "expected" => owner, "last_writer" => last_writer }
+        end
+      end
+
+      def fetch_envelope(key, violations)
+        @reader.get(key)
+      rescue Textus::Error => e
+        violations << { "key" => key, "code" => e.code, "message" => e.message }
+        nil
+      end
+
+      def validate_schema!(schema, envelope, format)
+        payload = case format
+                  when "json", "yaml" then envelope["content"] || {}
+                  else envelope["_meta"] || {}
+                  end
+        schema.validate!(payload)
       end
     end
   end

data/lib/textus/store/writer.rb

@@ -10,11 +10,19 @@ module Textus
         @reader = store.reader
       end
 
+      # Backward-compat shim — orchestration now lives in Application::Writes::Put.
       def put(key, meta: nil, body: nil, content: nil, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
-        @manifest.validate_key!(key)
-        mentry, path, = @manifest.resolve(key)
-        writers = @manifest.zone_writers(mentry.zone)
-        raise WriteForbidden.new(key, mentry.zone, writers: writers) unless writers.include?(as)
+        ctx = Textus::Application::Context.new(store: @store, role: as)
+        Textus::Application::Writes::Put.new(ctx: ctx, bus: @store.bus).call(
+          key, meta: meta, body: body, content: content, if_etag: if_etag, suppress_events: suppress_events
+        )
+      end
+
+      # Pure I/O: validate, serialize, etag-check, write to disk, audit. No
+      # permission check and no event firing — those are handled by the caller
+      # (Application::Writes::Put).
+      def write_envelope_to_disk(key, mentry:, meta: nil, body: nil, content: nil, if_etag: nil, as: Role::DEFAULT, correlation_id: nil)
+        _, path, = @manifest.resolve(key)
 
         meta ||= {}
         strategy = Entry.for_format(mentry.format)
@@ -43,13 +51,15 @@ module Textus
         FileUtils.mkdir_p(File.dirname(path))
         File.binwrite(path, bytes)
         etag_after = Etag.for_bytes(bytes)
-        @store.audit_log.append(role: as, verb: "put", key: key, etag_before: etag_before, etag_after: etag_after)
-        envelope = Envelope.build(
+        @store.audit_log.append(
+          role: as, verb: "put", key: key,
+          etag_before: etag_before, etag_after: etag_after,
+          extras: correlation_id ? { "correlation_id" => correlation_id } : nil
+        )
+        Envelope.build(
           key: key, mentry: mentry, path: path,
           meta: eff_meta, body: eff_body, etag: etag_after, content: eff_content
         )
-        @store.fire_event(:put, key: key, envelope: envelope) unless suppress_events
-        envelope
       end
 
       def existing_uid_for(mentry, path)
@@ -108,24 +118,51 @@ module Textus
         end
       end
 
+      # Backward-compat shim — orchestration now lives in Application::Writes::Delete.
       def delete(key, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
-        mentry, path, = @manifest.resolve(key)
-        writers = @manifest.zone_writers(mentry.zone)
-        raise WriteForbidden.new(key, mentry.zone, writers: writers) unless writers.include?(as)
+        ctx = Textus::Application::Context.new(store: @store, role: as)
+        Textus::Application::Writes::Delete.new(ctx: ctx, bus: @store.bus).call(
+          key, if_etag: if_etag, suppress_events: suppress_events
+        )
+      end
+
+      # Pure I/O: resolve path, validate etag, delete from disk, audit. No
+      # permission check and no event firing — those are handled by the caller
+      # (Application::Writes::Delete).
+      def delete_envelope_from_disk(key, if_etag: nil, as: Role::DEFAULT, correlation_id: nil)
+        _, path, = @manifest.resolve(key)
         raise UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)) unless File.exist?(path)
 
         etag_before = Etag.for_file(path)
         raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && if_etag != etag_before
 
         File.delete(path)
-        @store.audit_log.append(role: as, verb: "delete", key: key, etag_before: etag_before, etag_after: nil)
-        @store.fire_event(:delete, key: key) unless suppress_events
-        { "protocol" => PROTOCOL, "ok" => true, "key" => key, "deleted" => true }
+        @store.audit_log.append(
+          role: as, verb: "delete", key: key,
+          etag_before: etag_before, etag_after: nil,
+          extras: correlation_id ? { "correlation_id" => correlation_id } : nil
+        )
       end
 
       def accept(key, as:)
         Proposal.accept(@store, key, as: as)
       end
+
+      def reject(pending_key, as: Role::DEFAULT)
+        raise ProposalError.new("only human role can reject proposals; got '#{as}'") unless as == "human"
+
+        mentry, = @store.manifest.resolve(pending_key)
+        raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})") unless mentry.in_proposal_zone?
+
+        env = @store.get(pending_key)
+        proposal = env.dig("_meta", "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")
+
+        delete(pending_key, as: as)
+        @store.fire_event(:reject, key: pending_key, target_key: target_key)
+        { "protocol" => PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
+      end
     end
     # rubocop:enable Metrics/ParameterLists
   end

data/lib/textus/store.rb

@@ -45,6 +45,7 @@ module Textus
       load_hooks
       @reader = Reader.new(self)
       @writer = Writer.new(self)
+      fire_event(:loaded)
     end
 
     def load_hooks
@@ -53,7 +54,7 @@ module Textus
         dir = File.join(@root, "hooks")
         return unless File.directory?(dir)
 
-        Dir.glob(File.join(dir, "*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
+        Dir.glob(File.join(dir, "**/*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
           begin
             load(f)
           rescue StandardError, ScriptError => e
@@ -74,24 +75,43 @@ module Textus
       end
     end
 
-    def get(key)
-      @reader.get(key)
+    def get(key, as: Textus::Role::DEFAULT)
+      ctx = Textus::Composition.context(self, role: as)
+      result = Textus::Composition.reads_get(ctx).call(key)
+      raise UnknownKey.new(key, suggestions: manifest.suggestions_for(key)) if result.nil?
+
+      result
     end
 
     def where(key) = @reader.where(key)
     def list(**) = @reader.list(**)
     def schema_envelope(key) = @reader.schema_envelope(key)
 
-    def put(...) = @writer.put(...)
+    # rubocop:disable Metrics/ParameterLists
+    def put(key, meta: nil, body: nil, content: nil, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
+      ctx = Textus::Composition.context(self, role: as)
+      Textus::Composition.writes_put(ctx).call(
+        key, meta: meta, body: body, content: content, if_etag: if_etag, suppress_events: suppress_events
+      )
+    end
+    # rubocop:enable Metrics/ParameterLists
 
-    def delete(...) = @writer.delete(...)
+    def delete(key, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
+      ctx = Textus::Composition.context(self, role: as)
+      Textus::Composition.writes_delete(ctx).call(key, if_etag: if_etag, suppress_events: suppress_events)
+    end
 
     def fire_event(event, **)
-      view = Store::View.new(self)
+      view = Textus::Application::Context.new(store: self, role: "human")
       @bus.publish(event, store: view, **)
     end
 
-    def accept(...) = @writer.accept(...)
+    def accept(key, as: Role::DEFAULT)
+      ctx = Textus::Composition.context(self, role: as)
+      Textus::Composition.writes_accept(ctx).call(key)
+    end
+
+    def reject(...) = @writer.reject(...)
 
     def deps(key)    = @reader.deps(key)
     def rdeps(key)   = @reader.rdeps(key)
@@ -104,9 +124,9 @@ module Textus
     # Move an entry from old_key to new_key within the same zone. Preserves
     # uid (minting one first if absent), validates both keys against the
     # manifest, refuses to clobber, and writes one mv audit row.
-    def mv(old_key, new_key, as: Role::DEFAULT, dry_run: false)
-      Mover.new(reader: @reader, writer: @writer, manifest: @manifest, audit_log: audit_log)
-           .call(old_key, new_key, as: as, dry_run: dry_run)
+    def mv(old_key, new_key, as: Role::DEFAULT, dry_run: false, correlation_id: nil)
+      Mover.new(store: self, reader: @reader, writer: @writer, manifest: @manifest, audit_log: audit_log)
+           .call(old_key, new_key, as: as, dry_run: dry_run, correlation_id: correlation_id)
     end
 
     def audit_log

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.8.1"
+  VERSION = "0.10.0"
   PROTOCOL = "textus/2"
 end

data/lib/textus.rb

@@ -13,4 +13,5 @@ loader.setup
 loader.eager_load
 
 module Textus
+  extend Hooks::Dsl
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Patrick
@@ -109,7 +109,20 @@ files:
 - docs/conventions.md
 - exe/textus
 - lib/textus.rb
-- lib/textus/builder.rb
+- lib/textus/application/context.rb
+- lib/textus/application/reads/audit.rb
+- lib/textus/application/reads/blame.rb
+- lib/textus/application/reads/freshness.rb
+- lib/textus/application/reads/get.rb
+- lib/textus/application/reads/policy_explain.rb
+- lib/textus/application/refresh/all.rb
+- lib/textus/application/refresh/orchestrator.rb
+- lib/textus/application/refresh/worker.rb
+- lib/textus/application/writes/accept.rb
+- lib/textus/application/writes/build.rb
+- lib/textus/application/writes/delete.rb
+- lib/textus/application/writes/publish.rb
+- lib/textus/application/writes/put.rb
 - lib/textus/builder/pipeline.rb
 - lib/textus/builder/renderer.rb
 - lib/textus/builder/renderer/json.rb
@@ -120,13 +133,17 @@ files:
 - lib/textus/cli/group.rb
 - lib/textus/cli/group/hook.rb
 - lib/textus/cli/group/key.rb
+- lib/textus/cli/group/policy.rb
 - lib/textus/cli/group/schema.rb
 - lib/textus/cli/verb.rb
 - lib/textus/cli/verb/accept.rb
+- lib/textus/cli/verb/audit.rb
+- lib/textus/cli/verb/blame.rb
 - lib/textus/cli/verb/build.rb
 - lib/textus/cli/verb/delete.rb
 - lib/textus/cli/verb/deps.rb
 - lib/textus/cli/verb/doctor.rb
+- lib/textus/cli/verb/freshness.rb
 - lib/textus/cli/verb/get.rb
 - lib/textus/cli/verb/hook_run.rb
 - lib/textus/cli/verb/hooks.rb
@@ -135,29 +152,48 @@ files:
 - lib/textus/cli/verb/list.rb
 - lib/textus/cli/verb/migrate_keys.rb
 - lib/textus/cli/verb/mv.rb
+- lib/textus/cli/verb/policy_explain.rb
+- lib/textus/cli/verb/policy_list.rb
 - lib/textus/cli/verb/published.rb
 - lib/textus/cli/verb/put.rb
 - lib/textus/cli/verb/rdeps.rb
 - lib/textus/cli/verb/refresh.rb
+- lib/textus/cli/verb/refresh_stale.rb
+- lib/textus/cli/verb/reject.rb
 - lib/textus/cli/verb/schema.rb
 - lib/textus/cli/verb/schema_diff.rb
 - lib/textus/cli/verb/schema_init.rb
 - lib/textus/cli/verb/schema_migrate.rb
-- lib/textus/cli/verb/stale.rb
 - lib/textus/cli/verb/uid.rb
 - lib/textus/cli/verb/where.rb
+- lib/textus/composition.rb
 - lib/textus/dependencies.rb
 - lib/textus/doctor.rb
 - lib/textus/doctor/check.rb
 - lib/textus/doctor/check/audit_log.rb
+- lib/textus/doctor/check/handler_allowlist.rb
 - lib/textus/doctor/check/hooks.rb
 - lib/textus/doctor/check/illegal_keys.rb
+- lib/textus/doctor/check/intake_registration.rb
+- lib/textus/doctor/check/legacy_intake_fields.rb
 - lib/textus/doctor/check/manifest_files.rb
+- lib/textus/doctor/check/policy_ambiguity.rb
 - lib/textus/doctor/check/schema_violations.rb
 - lib/textus/doctor/check/schemas.rb
 - lib/textus/doctor/check/sentinels.rb
 - lib/textus/doctor/check/templates.rb
 - lib/textus/doctor/check/unowned_schema_fields.rb
+- lib/textus/domain/action.rb
+- lib/textus/domain/freshness/evaluator.rb
+- lib/textus/domain/freshness/policy.rb
+- lib/textus/domain/freshness/verdict.rb
+- lib/textus/domain/outcome.rb
+- lib/textus/domain/permission.rb
+- lib/textus/domain/policy.rb
+- lib/textus/domain/policy/handler_allowlist.rb
+- lib/textus/domain/policy/matcher.rb
+- lib/textus/domain/policy/promote.rb
+- lib/textus/domain/policy/refresh.rb
 - lib/textus/entry.rb
 - lib/textus/entry/base.rb
 - lib/textus/entry/json.rb
@@ -169,8 +205,14 @@ files:
 - lib/textus/etag.rb
 - lib/textus/hooks/builtin.rb
 - lib/textus/hooks/dispatcher.rb
+- lib/textus/hooks/dsl.rb
 - lib/textus/hooks/loader.rb
 - lib/textus/hooks/registry.rb
+- lib/textus/infra/clock.rb
+- lib/textus/infra/event_bus.rb
+- lib/textus/infra/publisher.rb
+- lib/textus/infra/refresh/detached.rb
+- lib/textus/infra/refresh/lock.rb
 - lib/textus/init.rb
 - lib/textus/intro.rb
 - lib/textus/key/distance.rb
@@ -178,11 +220,11 @@ files:
 - lib/textus/key/path.rb
 - lib/textus/manifest.rb
 - lib/textus/manifest/entry.rb
+- lib/textus/manifest/policies.rb
 - lib/textus/migrate_keys.rb
 - lib/textus/mustache.rb
 - lib/textus/projection.rb
 - lib/textus/proposal.rb
-- lib/textus/publisher.rb
 - lib/textus/refresh.rb
 - lib/textus/role.rb
 - lib/textus/schema.rb
@@ -193,7 +235,6 @@ files:
 - lib/textus/store/reader.rb
 - lib/textus/store/staleness.rb
 - lib/textus/store/validator.rb
-- lib/textus/store/view.rb
 - lib/textus/store/writer.rb
 - lib/textus/version.rb
 homepage: https://github.com/patrick204nqh/textus

data/lib/textus/builder.rb

@@ -1,86 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Builder
-    def initialize(store)
-      @store = store
-      @manifest = store.manifest
-      @root = store.root
-    end
-
-    def build(prefix: nil)
-      built = []
-      @manifest.entries.each do |mentry|
-        next unless derived_zone?(mentry)
-        next unless mentry.projection || mentry.template
-        next if prefix && !mentry.key.start_with?(prefix)
-
-        result = materialize(mentry)
-        built << result
-      end
-      published_leaves = publish_leaves(prefix: prefix)
-      { "protocol" => Textus::PROTOCOL, "built" => built, "published_leaves" => published_leaves }
-    end
-
-    private
-
-    def publish_leaves(prefix: nil)
-      repo_root = File.dirname(@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}.")
-
-        @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
-
-          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)
-            raise PublishError.new(
-              "entry '#{mentry.key}': publish_each target '#{target_rel}' for key '#{row[:key]}' escapes repo root",
-            )
-          end
-
-          Publisher.publish(source: row[:path], target: target_abs, store_root: @root)
-          out << { "key" => row[:key], "source" => row[:path], "target" => target_abs }
-        end
-      end
-      out
-    end
-
-    def derived_zone?(mentry)
-      writers = @manifest.zone_writers(mentry.zone)
-      writers.include?("build")
-    end
-
-    def materialize(mentry)
-      target_path = Pipeline.run(
-        store: @store,
-        mentry: mentry,
-        template_loader: ->(name) { read_template(name) },
-      )
-      publish_and_fire(mentry, target_path)
-      { "key" => mentry.key, "path" => target_path, "published_to" => mentry.publish_to }
-    end
-
-    def read_template(name)
-      tpl_path = File.join(@root, "templates", name)
-      raise TemplateError.new("template not found: #{tpl_path}", template_name: name) unless File.exist?(tpl_path)
-
-      File.read(tpl_path)
-    end
-
-    def publish_and_fire(mentry, target_path)
-      mentry.publish_to.each do |rel|
-        repo_root = File.dirname(@root)
-        Publisher.publish(source: target_path, target: File.join(repo_root, rel), store_root: @root)
-      end
-
-      envelope = @store.get(mentry.key)
-      @store.fire_event(:build, key: mentry.key, envelope: envelope,
-                                sources: Array(mentry.projection&.fetch("select", nil)).compact)
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Textus
-  class CLI
-    class Verb
-      class Stale < Verb
-        option :prefix, "--prefix=KEY"
-        option :zone, "--zone=Z"
-
-        def call(store)
-          emit(store.stale(prefix: prefix, zone: zone))
-        end
-      end
-    end
-  end
-end