textus 0.18.0 → 0.20.0

data/lib/textus/manifest/schema.rb

@@ -4,7 +4,7 @@ module Textus
       ROOT_KEYS    = %w[version zones entries rules].freeze
       ZONE_KEYS    = %w[name write_policy read_policy].freeze
       ENTRY_KEYS   = %w[
-        key path zone schema owner nested format
+        key path zone kind schema owner nested format
         compute template publish_to publish_each
         intake events inject_intro index_filename
       ].freeze

data/lib/textus/manifest.rb

@@ -1,18 +1,10 @@
 require "yaml"
 require_relative "manifest/schema"
 require_relative "manifest/resolution"
+require_relative "manifest/resolver"
 
 module Textus
   class Manifest
-    TEXTUS_2_HINT = "Install textus 0.11.x to run the migrator, then upgrade to this version. " \
-                    "See https://github.com/patrick204nqh/textus/blob/main/CHANGELOG.md#0110".freeze
-
-    def self.version_hint_for(version)
-      version == "textus/2" ? TEXTUS_2_HINT : nil
-    end
-
-    private_class_method :version_hint_for
-
     attr_reader :root, :entries, :raw
 
     def zones
@@ -59,7 +51,6 @@ module Textus
       raise BadFrontmatter.new(
         source,
         "unsupported manifest version #{raw["version"].inspect}; expected #{PROTOCOL.inspect}",
-        hint: version_hint_for(raw["version"]),
       )
     end
     private_class_method :check_version!
@@ -87,53 +78,8 @@ module Textus
       rules.for(key)
     end
 
-    # Returns a Resolution(entry:, path:, remaining:) value object.
-    def resolve(key)
-      validate_key!(key)
-      segments = key.split(".")
-      # longest-prefix match
-      candidates = @entries
-                   .map { |e| [e, e.key.split(".")] }
-                   .select { |(_, esegs)| esegs == segments[0, esegs.length] }
-                   .sort_by { |(_, esegs)| -esegs.length }
-      raise UnknownKey.new(key, suggestions: suggestions_for(key)) if candidates.empty?
-
-      entry, esegs = candidates.first
-      remaining = segments[esegs.length..]
-      if remaining.empty?
-        path = resolve_leaf_path(entry)
-        Resolution.new(entry: entry, path: path, remaining: [])
-      else
-        raise UnknownKey.new(key, suggestions: suggestions_for(key)) unless entry.nested
-
-        path = if entry.index_filename
-                 File.join(@root, "zones", entry.path, *remaining, entry.index_filename)
-               else
-                 primary_ext = Textus::Entry.for_format(entry.format).extensions.first
-                 File.join(@root, "zones", entry.path, *remaining) + primary_ext
-               end
-        Resolution.new(entry: entry, path: path, remaining: remaining)
-      end
-    end
-
-    # Returns up to 5 dotted keys from the manifest that look similar to the
-    # requested key, ranked by shared-prefix length then Levenshtein distance.
-    def suggestions_for(key)
-      candidates = enumerate.map { |r| r[:key] }
-      # Include declared (non-nested) entry keys even if file is missing.
-      candidates.concat(@entries.reject(&:nested).map(&:key))
-      candidates.uniq!
-      Key::Distance.suggest(key, candidates, limit: 5)
-    rescue StandardError
-      []
-    end
-
-    # Enumerate all entry files reachable through the manifest. Returns
-    # [{ key:, path:, manifest_entry: }, ...]
-    def enumerate(prefix: nil)
-      out = @entries.flat_map { |entry| entry.nested ? enumerate_nested(entry) : enumerate_leaf(entry) }
-      out.select! { |row| row[:key] == prefix || row[:key].start_with?("#{prefix}.") } if prefix
-      out.sort_by { |row| row[:key] }
+    def resolver
+      @resolver ||= Resolver.new(self)
     end
 
     def validate_key!(key)
@@ -144,51 +90,8 @@ module Textus
 
     private
 
-    def enumerate_leaf(entry)
-      fp = resolve_leaf_path(entry)
-      File.exist?(fp) ? [{ key: entry.key, path: fp, manifest_entry: entry }] : []
-    end
-
-    def enumerate_nested(entry)
-      base = File.join(@root, "zones", entry.path)
-      return [] unless File.directory?(base)
-
-      glob_pattern = entry.index_filename ? "**/#{entry.index_filename}" : nested_glob(entry.format)
-      Dir.glob(File.join(base, glob_pattern)).filter_map { |path| nested_row_for(entry, base, path) }
-    end
-
-    def nested_row_for(entry, base, path)
-      rel = path.sub(%r{\A#{Regexp.escape(base)}/?}, "")
-      stripped = entry.index_filename ? File.dirname(rel) : rel.sub(/#{Regexp.escape(File.extname(rel))}\z/, "")
-      segs = stripped.split("/").reject { |s| s.empty? || s == "." }
-      return nil if segs.empty?
-
-      illegal = segs.find { |s| !valid_segment?(s) }
-      if illegal
-        warn("textus: skipping illegal key segment '#{illegal}' at #{path} — run 'textus key normalize --dry-run'")
-        return nil
-      end
-
-      { key: (entry.key.split(".") + segs).join("."), path: path, manifest_entry: entry }
-    end
-
-    def valid_segment?(seg)
-      return false if seg.nil? || seg.empty?
-      return false if seg.length > Key::Grammar::MAX_SEGMENT_LEN
-
-      seg.match?(Key::Grammar::SEGMENT)
-    end
-
     def validate_declared_keys!
       @entries.each { |e| validate_key!(e.key) }
     end
-
-    def resolve_leaf_path(entry)
-      Textus::Key::Path.resolve(self, entry)
-    end
-
-    def nested_glob(format)
-      Textus::Entry.for_format(format).nested_glob
-    end
   end
 end

data/lib/textus/operations.rb

@@ -10,102 +10,159 @@ module Textus
   #   ops.refresh_all(prefix: ..., zone: ...)
   class Operations
     def self.for(store, role: Role::DEFAULT, correlation_id: nil, dry_run: false)
-      ctx = Application::Context.new(
+      new(
+        ctx: Application::Context.build(role: role, correlation_id: correlation_id, dry_run: dry_run),
+        manifest: store.manifest,
+        file_store: store.file_store,
+        schemas: store.schemas,
+        audit_log: store.audit_log,
+        bus: store.bus,
+        root: store.root,
         store: store,
-        role: role,
-        correlation_id: correlation_id,
-        dry_run: dry_run,
       )
-      new(ctx)
     end
 
-    attr_reader :ctx
+    attr_reader :ctx, :store
 
-    def initialize(ctx)
-      @ctx = ctx
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(ctx:, manifest:, file_store:, schemas:, audit_log:, bus:, root:, store:)
+      @ctx        = ctx
+      @manifest   = manifest
+      @file_store = file_store
+      @schemas    = schemas
+      @audit_log  = audit_log
+      @bus        = bus
+      @root       = root
+      @store      = store
+      @authorizer = Textus::Domain::Authorizer.new(manifest: @manifest)
     end
+    # rubocop:enable Metrics/ParameterLists
 
-    def with_role(role) = self.class.new(@ctx.with_role(role))
+    def with_role(role)
+      self.class.new(
+        ctx: @ctx.with_role(role),
+        manifest: @manifest, file_store: @file_store, schemas: @schemas,
+        audit_log: @audit_log, bus: @bus,
+        root: @root, store: @store
+      )
+    end
+
+    def hook_context
+      @hook_context ||= Textus::Hooks::Context.new(ops: self)
+    end
 
     # writes
-    def put(...)     = put_op.call(...)
-    def delete(...)  = delete_op.call(...)
-    def mv(...)      = mv_op.call(...)
-    def accept(...)  = accept_op.call(...)
-    def reject(...)  = reject_op.call(...)
-    def build(...)   = build_op.call(...)
-    def publish(...) = publish_op.call(...)
+    def put(...)
+      Application::Writes::Put.new(
+        ctx: @ctx, manifest: @manifest, envelope_io: envelope_io,
+        bus: @bus, authorizer: @authorizer, hook_context: hook_context
+      ).call(...)
+    end
+
+    def delete(...)
+      Application::Writes::Delete.new(
+        ctx: @ctx, manifest: @manifest, envelope_io: envelope_io,
+        bus: @bus, authorizer: @authorizer, hook_context: hook_context
+      ).call(...)
+    end
+
+    def mv(...)
+      Application::Writes::Mv.new(
+        ctx: @ctx, manifest: @manifest, envelope_io: envelope_io,
+        bus: @bus, authorizer: @authorizer, hook_context: hook_context
+      ).call(...)
+    end
+
+    def accept(...)
+      Application::Writes::Accept.new(
+        ctx: @ctx, manifest: @manifest, file_store: @file_store, schemas: @schemas,
+        envelope_io: envelope_io, bus: @bus, authorizer: @authorizer, hook_context: hook_context
+      ).call(...)
+    end
+
+    def reject(...)
+      Application::Writes::Reject.new(
+        ctx: @ctx, manifest: @manifest, file_store: @file_store,
+        envelope_io: envelope_io, bus: @bus, authorizer: @authorizer, hook_context: hook_context
+      ).call(...)
+    end
+
+    def publish(...)
+      Application::Writes::Publish.new(
+        ctx: @ctx, manifest: @manifest, file_store: @file_store,
+        bus: @bus, root: @root, store: @store, hook_context: hook_context
+      ).call(...)
+    end
 
     # reads
-    def get(...)             = get_op.call(...)
-    def get_or_refresh(...)  = get_or_refresh_op.call(...)
-    def list(...)            = list_op.call(...)
-    def where(...)           = where_op.call(...)
-    def uid(...)             = uid_op.call(...)
-    def schema_envelope(...) = schema_envelope_op.call(...)
-    def deps(...)            = deps_op.call(...)
-    def rdeps(...)           = rdeps_op.call(...)
-    def published(...)       = published_op.call(...)
-    def stale(...)           = stale_op.call(...)
-    def audit(...)           = audit_op.call(...)
-    def blame(...)           = blame_op.call(...)
-    def policy_explain(...)  = policy_explain_op.call(...)
-    def freshness(...)       = freshness_op.call(...)
-    def validate_all(...)    = validate_all_op.call(...)
+    def get(...)
+      Application::Reads::Get.new(ctx: @ctx, manifest: @manifest, file_store: @file_store).call(...)
+    end
+
+    def get_or_refresh(...)
+      Application::Reads::GetOrRefresh.new(
+        manifest: @manifest,
+        get: Application::Reads::Get.new(ctx: @ctx, manifest: @manifest, file_store: @file_store),
+        orchestrator: orchestrator,
+      ).call(...)
+    end
+
+    def list(...)            = Application::Reads::List.new(manifest: @manifest).call(...)
+    def where(...)           = Application::Reads::Where.new(manifest: @manifest).call(...)
+    def uid(...)             = Application::Reads::Uid.new(ctx: @ctx, manifest: @manifest, file_store: @file_store).call(...)
+    def schema_envelope(...) = Application::Reads::SchemaEnvelope.new(manifest: @manifest, schemas: @schemas).call(...)
+    def deps(...)            = Application::Reads::Deps.new(manifest: @manifest).call(...)
+    def rdeps(...)           = Application::Reads::Rdeps.new(manifest: @manifest).call(...)
+    def published(...)       = Application::Reads::Published.new(manifest: @manifest).call(...)
+    def stale(...)           = Application::Reads::Stale.new(manifest: @manifest).call(...)
+    def audit(...)           = Application::Reads::Audit.new(manifest: @manifest, root: @root).call(...)
+    def blame(...)           = Application::Reads::Blame.new(manifest: @manifest, root: @root).call(...)
+    def policy_explain(...)  = Application::Reads::PolicyExplain.new(manifest: @manifest).call(...)
+    def freshness(...)       = Application::Reads::Freshness.new(ctx: @ctx, manifest: @manifest, file_store: @file_store).call(...)
+
+    def validate_all(...)
+      Application::Reads::ValidateAll.new(
+        ctx: @ctx, manifest: @manifest, file_store: @file_store, schemas: @schemas, audit_log: @audit_log,
+      ).call(...)
+    end
 
     # refresh
-    def refresh(key) = refresh_worker_op.run(key)
-    def refresh_all(**) = Application::Refresh::All.call(@ctx, **)
+    def refresh(key) = refresh_worker.run(key)
+
+    def refresh_all(**)
+      Application::Refresh::All.new(
+        ctx: @ctx, manifest: @manifest, envelope_io: envelope_io, bus: @bus,
+        store: @store, authorizer: @authorizer, hook_context: hook_context
+      ).call(**)
+    end
 
     private
 
     def envelope_io
       @envelope_io ||= Application::Writes::EnvelopeIO.new(
-        file_store: @ctx.file_store,
-        manifest: @ctx.manifest,
-        schemas: @ctx.schemas,
-        audit_log: @ctx.audit_log,
+        file_store: @file_store,
+        manifest: @manifest,
+        schemas: @schemas,
+        audit_log: @audit_log,
         ctx: @ctx,
       )
     end
 
-    def put_op     = @put_op ||= Application::Writes::Put.new(ctx: @ctx, envelope_io: envelope_io)
-    def delete_op  = @delete_op ||= Application::Writes::Delete.new(ctx: @ctx, envelope_io: envelope_io)
-    def mv_op      = @mv_op ||= Application::Writes::Mv.new(ctx: @ctx, envelope_io: envelope_io)
-    def accept_op  = @accept_op ||= Application::Writes::Accept.new(ctx: @ctx, envelope_io: envelope_io)
-    def reject_op  = @reject_op ||= Application::Writes::Reject.new(ctx: @ctx, envelope_io: envelope_io)
-    def build_op   = @build_op ||= Application::Writes::Build.new(ctx: @ctx)
-    def publish_op = @publish_op ||= Application::Writes::Publish.new(ctx: @ctx)
-
-    def get_op = @get_op ||= Application::Reads::Get.new(ctx: @ctx) # rubocop:disable Naming/AccessorMethodName
-
-    def get_or_refresh_op # rubocop:disable Naming/AccessorMethodName
-      @get_or_refresh_op ||= Application::Reads::GetOrRefresh.new(ctx: @ctx, get: get_op,
-                                                                  orchestrator: orchestrator_op)
-    end
-
-    def list_op            = @list_op ||= Application::Reads::List.new(ctx: @ctx)
-    def where_op           = @where_op ||= Application::Reads::Where.new(ctx: @ctx)
-    def uid_op             = @uid_op ||= Application::Reads::Uid.new(ctx: @ctx)
-    def schema_envelope_op = @schema_envelope_op ||= Application::Reads::SchemaEnvelope.new(ctx: @ctx)
-    def deps_op            = @deps_op ||= Application::Reads::Deps.new(ctx: @ctx)
-    def rdeps_op           = @rdeps_op ||= Application::Reads::Rdeps.new(ctx: @ctx)
-    def published_op       = @published_op ||= Application::Reads::Published.new(ctx: @ctx)
-    def stale_op           = @stale_op ||= Application::Reads::Stale.new(ctx: @ctx)
-    def audit_op           = @audit_op ||= Application::Reads::Audit.new(ctx: @ctx)
-    def blame_op           = @blame_op ||= Application::Reads::Blame.new(ctx: @ctx)
-    def policy_explain_op  = @policy_explain_op ||= Application::Reads::PolicyExplain.new(ctx: @ctx)
-    def freshness_op       = @freshness_op ||= Application::Reads::Freshness.new(ctx: @ctx)
-    def validate_all_op    = @validate_all_op ||= Application::Reads::ValidateAll.new(ctx: @ctx)
-
-    def refresh_worker_op = @refresh_worker_op ||= Application::Refresh::Worker.new(ctx: @ctx, envelope_io: envelope_io)
-
-    def orchestrator_op
-      @orchestrator_op ||= Application::Refresh::Orchestrator.new(
-        worker: refresh_worker_op,
-        store_root: @ctx.store.root,
-        store: @ctx.store,
-        role: @ctx.role,
+    def refresh_worker
+      @refresh_worker ||= Application::Refresh::Worker.new(
+        ctx: @ctx, manifest: @manifest, envelope_io: envelope_io, bus: @bus,
+        store: @store, authorizer: @authorizer, hook_context: hook_context
+      )
+    end
+
+    def orchestrator
+      @orchestrator ||= Application::Refresh::Orchestrator.new(
+        worker: refresh_worker,
+        store_root: @root,
+        bus: @bus,
+        store: @store,
+        ctx: @ctx,
+        hook_context: hook_context,
       )
     end
   end

data/lib/textus/schema/tools.rb

@@ -24,7 +24,7 @@ module Textus
       def self.diff(store, name:)
         schema = load_schema(store, name)
         drift = []
-        store.manifest.enumerate.each do |row|
+        store.manifest.resolver.enumerate.each do |row|
           env = Textus::Operations.for(store).get(row[:key])
           begin
             schema.validate!(env.meta)
@@ -51,7 +51,7 @@ module Textus
 
         ops = Textus::Operations.for(store, role: "human")
         touched = []
-        store.manifest.enumerate.each do |row|
+        store.manifest.resolver.enumerate.each do |row|
           env = ops.get(row[:key])
           meta = env.meta.dup
           changed = false

data/lib/textus/store.rb

@@ -2,7 +2,7 @@ require "fileutils"
 
 module Textus
   class Store
-    attr_reader :root, :manifest, :schemas, :file_store, :audit_log, :bus, :registry
+    attr_reader :root, :manifest, :schemas, :file_store, :audit_log, :bus
 
     def self.discover(start_dir = Dir.pwd, root: nil)
       explicit = root || ENV.fetch("TEXTUS_ROOT", nil)
@@ -34,12 +34,12 @@ module Textus
       @schemas    = Schemas.new(File.join(@root, "schemas"))
       @file_store = Infra::Storage::FileStore.new
       @audit_log  = Infra::AuditLog.new(@root)
-      @bus        = Hooks::Dispatcher.new
-      @registry   = Hooks::Registry.new(dispatcher: @bus)
+      @bus = Hooks::Bus.new
       Infra::AuditSubscriber.new(@audit_log).attach(@bus)
-      Hooks::Builtin.register_all(@registry)
-      Hooks::Loader.new(registry: @registry).load_dir(File.join(@root, "hooks"))
-      @bus.publish(:store_loaded, store: Application::Context.system(self))
+      Hooks::Builtin.register_all(@bus)
+      Hooks::Loader.new(bus: @bus).load_dir(File.join(@root, "hooks"))
+      ops = Operations.for(self, role: Role::DEFAULT)
+      @bus.publish(:store_loaded, ctx: ops.hook_context)
     end
   end
 end

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.18.0"
+  VERSION = "0.20.0"
   PROTOCOL = "textus/3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Patrick
@@ -110,6 +110,10 @@ files:
 - exe/textus
 - lib/textus.rb
 - lib/textus/application/context.rb
+- lib/textus/application/policy/predicates/human_accept.rb
+- lib/textus/application/policy/predicates/schema_valid.rb
+- lib/textus/application/policy/promotion.rb
+- lib/textus/application/projection.rb
 - lib/textus/application/reads/audit.rb
 - lib/textus/application/reads/blame.rb
 - lib/textus/application/reads/deps.rb
@@ -129,10 +133,12 @@ files:
 - lib/textus/application/refresh/all.rb
 - lib/textus/application/refresh/orchestrator.rb
 - lib/textus/application/refresh/worker.rb
+- lib/textus/application/tools/migrate_keys.rb
+- lib/textus/application/tools/migrate_manifest_to_kinds.rb
 - lib/textus/application/writes/accept.rb
-- lib/textus/application/writes/build.rb
 - lib/textus/application/writes/delete.rb
 - lib/textus/application/writes/envelope_io.rb
+- lib/textus/application/writes/materializer.rb
 - lib/textus/application/writes/mv.rb
 - lib/textus/application/writes/publish.rb
 - lib/textus/application/writes/put.rb
@@ -181,7 +187,6 @@ files:
 - lib/textus/cli/verb/schema_migrate.rb
 - lib/textus/cli/verb/uid.rb
 - lib/textus/cli/verb/where.rb
-- lib/textus/dependencies.rb
 - lib/textus/doctor.rb
 - lib/textus/doctor/check.rb
 - lib/textus/doctor/check/audit_log.rb
@@ -200,6 +205,7 @@ files:
 - lib/textus/doctor/check/templates.rb
 - lib/textus/doctor/check/unowned_schema_fields.rb
 - lib/textus/domain/action.rb
+- lib/textus/domain/authorizer.rb
 - lib/textus/domain/freshness.rb
 - lib/textus/domain/freshness/evaluator.rb
 - lib/textus/domain/freshness/policy.rb
@@ -209,10 +215,7 @@ files:
 - lib/textus/domain/policy.rb
 - lib/textus/domain/policy/handler_allowlist.rb
 - lib/textus/domain/policy/matcher.rb
-- lib/textus/domain/policy/predicates/human_accept.rb
-- lib/textus/domain/policy/predicates/schema_valid.rb
 - lib/textus/domain/policy/promote.rb
-- lib/textus/domain/policy/promotion.rb
 - lib/textus/domain/policy/refresh.rb
 - lib/textus/domain/sentinel.rb
 - lib/textus/domain/staleness.rb
@@ -228,9 +231,10 @@ files:
 - lib/textus/errors.rb
 - lib/textus/etag.rb
 - lib/textus/hooks/builtin.rb
-- lib/textus/hooks/dispatcher.rb
+- lib/textus/hooks/bus.rb
+- lib/textus/hooks/context.rb
+- lib/textus/hooks/fire_report.rb
 - lib/textus/hooks/loader.rb
-- lib/textus/hooks/registry.rb
 - lib/textus/infra/audit_log.rb
 - lib/textus/infra/audit_subscriber.rb
 - lib/textus/infra/build_lock.rb
@@ -247,6 +251,11 @@ files:
 - lib/textus/key/path.rb
 - lib/textus/manifest.rb
 - lib/textus/manifest/entry.rb
+- lib/textus/manifest/entry/base.rb
+- lib/textus/manifest/entry/derived.rb
+- lib/textus/manifest/entry/intake.rb
+- lib/textus/manifest/entry/leaf.rb
+- lib/textus/manifest/entry/nested.rb
 - lib/textus/manifest/entry/parser.rb
 - lib/textus/manifest/entry/validators.rb
 - lib/textus/manifest/entry/validators/events.rb
@@ -255,13 +264,11 @@ files:
 - lib/textus/manifest/entry/validators/inject_intro.rb
 - lib/textus/manifest/entry/validators/publish_each.rb
 - lib/textus/manifest/resolution.rb
+- lib/textus/manifest/resolver.rb
 - lib/textus/manifest/rules.rb
 - lib/textus/manifest/schema.rb
-- lib/textus/migrate_keys.rb
 - lib/textus/mustache.rb
 - lib/textus/operations.rb
-- lib/textus/projection.rb
-- lib/textus/refresh.rb
 - lib/textus/role.rb
 - lib/textus/schema.rb
 - lib/textus/schema/tools.rb

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

@@ -1,78 +0,0 @@
-require "fileutils"
-
-module Textus
-  module Application
-    module Writes
-      # Materializes generator-zone entries (template + projection) onto disk
-      # and copies the result to any configured `publish_to:` targets. Fires
-      # `:build_completed` and `:file_published` events.
-      #
-      # For `publish_each:` (per-leaf publishing of nested entries), see
-      # `Application::Writes::Publish`. The CLI verb `textus build` calls
-      # both classes and merges the results.
-      class Build
-        def initialize(ctx:)
-          @ctx = ctx
-        end
-
-        def call(prefix: nil)
-          built = manifest.entries.filter_map do |mentry|
-            next unless mentry.in_generator_zone?
-            next unless mentry.projection || mentry.template
-            next if prefix && !mentry.key.start_with?(prefix)
-
-            materialize(mentry)
-          end
-          { "protocol" => Textus::PROTOCOL, "built" => built }
-        end
-
-        private
-
-        def store = @ctx.store
-        def manifest = store.manifest
-        def root = store.root
-
-        def materialize(mentry)
-          target_path = Builder::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)
-          envelope = Textus::Application::Reads::Get.new(ctx: @ctx).call(mentry.key)
-          repo_root = File.dirname(root)
-
-          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
-
-          publish_event(:build_completed,
-                        key: mentry.key,
-                        envelope: envelope,
-                        sources: Array(mentry.projection&.fetch("select", nil)).compact)
-        end
-
-        def publish_event(event, **payload)
-          @ctx.bus.publish(event, store: @ctx.with_role(@ctx.role), correlation_id: @ctx.correlation_id, **payload)
-        end
-      end
-    end
-  end
-end

data/lib/textus/dependencies.rb

@@ -1,23 +0,0 @@
-module Textus
-  module Dependencies
-    def self.deps_of(manifest, key)
-      entry = manifest.entries.find { |e| e.key == key } or return []
-      result = Array(entry.projection&.fetch("select", nil)).map { |s| s }
-      Array(entry.generator&.fetch("sources", nil)).each { |s| result << s }
-      result.uniq
-    end
-
-    def self.rdeps_of(manifest, key)
-      manifest.entries.each_with_object([]) do |e, acc|
-        sources = Array(e.projection&.fetch("select", nil)) + Array(e.generator&.fetch("sources", nil))
-        acc << e.key if sources.any? { |s| s == key || key.start_with?("#{s}.") }
-      end
-    end
-
-    def self.published_of(manifest)
-      manifest.entries.reject { |e| e.publish_to.empty? }.map do |e|
-        { "key" => e.key, "publish_to" => e.publish_to }
-      end
-    end
-  end
-end

data/lib/textus/domain/policy/predicates/human_accept.rb

@@ -1,31 +0,0 @@
-module Textus
-  module Domain
-    module Policy
-      module Predicates
-        class HumanAccept
-          attr_reader :reason
-
-          def name
-            "human_accept"
-          end
-
-          # The role is passed via `store` (an Application::Context-like object
-          # with a `role` reader) or through the entry metadata. In practice,
-          # Accept already enforces role == "human" before reaching the
-          # promotion gate, so this predicate trivially passes. It documents
-          # intent and future-proofs multi-actor accept flows.
-          def call(store:, entry: nil) # rubocop:disable Lint/UnusedMethodArgument
-            role = store.respond_to?(:role) ? store.role.to_s : nil
-            # If we cannot determine the role (e.g. store doesn't expose it),
-            # we trust that Accept has already checked — allow through.
-            return true if role.nil?
-
-            ok = (role == "human")
-            @reason = "current role is '#{role}', expected 'human'" unless ok
-            ok
-          end
-        end
-      end
-    end
-  end
-end