textus 0.22.0 → 0.29.0

data/lib/textus/doctor/check/templates.rb

@@ -4,11 +4,11 @@ module Textus
       class Templates < Check
         def call
           out = []
-          store.manifest.entries.each do |entry|
+          manifest.data.entries.each do |entry|
             template = entry.respond_to?(:template) ? entry.template : nil
             next if template.nil?
 
-            tp = File.join(store.root, "templates", template)
+            tp = File.join(root, "templates", template)
             next if File.exist?(tp)
 
             out << {

data/lib/textus/doctor/check/unowned_schema_fields.rb

@@ -3,7 +3,7 @@ module Textus
     class Check
       class UnownedSchemaFields < Check
         def call
-          dir = File.join(store.root, "schemas")
+          dir = File.join(root, "schemas")
           return [] unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.yaml")).flat_map do |path|

data/lib/textus/doctor/check.rb

@@ -14,8 +14,8 @@ module Textus
                           .downcase
       end
 
-      def initialize(store)
-        @store = store
+      def initialize(container)
+        @container = container
       end
 
       def call
@@ -24,7 +24,16 @@ module Textus
 
       protected
 
-      attr_reader :store
+      def root     = @container.root
+      def manifest = @container.manifest
+      def rpc      = @container.rpc
+
+      # Dispatch a verb through the static Dispatcher table.
+      def dispatch(verb, *, **)
+        klass = Textus::Dispatcher.fetch(verb)
+        call_value = Textus::Call.build(role: Textus::Role::DEFAULT)
+        klass.new(container: @container, call: call_value).call(*, **)
+      end
     end
   end
 end

data/lib/textus/doctor.rb

@@ -30,7 +30,7 @@ module Textus
 
     module_function
 
-    def run(store, checks: nil)
+    def build(container:, checks: nil)
       selected_keys = checks ? Array(checks).map(&:to_s) : ALL_CHECKS
       unknown = selected_keys - ALL_CHECKS
       unless unknown.empty?
@@ -40,8 +40,8 @@ module Textus
       end
 
       selected = CHECKS.select { |c| selected_keys.include?(c.name_key) }
-      issues = selected.flat_map { |c| c.new(store).call }
-      issues.concat(run_registered_checks(store))
+      issues = selected.flat_map { |c| c.new(container).call }
+      issues.concat(run_registered_checks(container))
 
       summary = LEVELS.to_h { |l| [l, issues.count { |i| i["level"] == l }] }
       {
@@ -52,30 +52,27 @@ module Textus
       }
     end
 
-    def run_registered_checks(store)
-      out = []
-      store.bus.rpc_names(:validate).each do |name|
-        callable = store.bus.rpc_callable(:validate, name)
-        begin
-          result = Timeout.timeout(DOCTOR_CHECK_TIMEOUT_SECONDS) { callable.call(store: store) }
-          if result.is_a?(Array)
-            out.concat(result.map { |h| h.transform_keys(&:to_s) })
-          else
-            out << fail_issue(name, code: "doctor_check.bad_return",
-                                    message: "doctor_check '#{name}' returned #{result.class} (expected Array)",
-                                    fix: "return an array of issue hashes from the doctor_check block")
-          end
-        rescue Timeout::Error
-          out << fail_issue(name, code: "doctor_check.timeout",
-                                  message: "doctor_check '#{name}' exceeded #{DOCTOR_CHECK_TIMEOUT_SECONDS}s",
-                                  fix: "shorten the check or split it into smaller checks")
-        rescue StandardError => e
-          out << fail_issue(name, code: "doctor_check.failed",
-                                  message: "#{e.class}: #{e.message}",
-                                  fix: "fix the :validate hook in .textus/hooks/")
-        end
+    def run_registered_checks(container)
+      container.rpc.names(:validate).flat_map { |name| invoke_registered_check(container, name) }
+    end
+
+    def invoke_registered_check(container, name)
+      result = Timeout.timeout(DOCTOR_CHECK_TIMEOUT_SECONDS) do
+        container.rpc.invoke(:validate, name, caps: container)
       end
-      out
+      return result.map { |h| h.transform_keys(&:to_s) } if result.is_a?(Array)
+
+      [fail_issue(name, code: "doctor_check.bad_return",
+                        message: "doctor_check '#{name}' returned #{result.class} (expected Array)",
+                        fix: "return an array of issue hashes from the doctor_check block")]
+    rescue Timeout::Error
+      [fail_issue(name, code: "doctor_check.timeout",
+                        message: "doctor_check '#{name}' exceeded #{DOCTOR_CHECK_TIMEOUT_SECONDS}s",
+                        fix: "shorten the check or split it into smaller checks")]
+    rescue StandardError => e
+      [fail_issue(name, code: "doctor_check.failed",
+                        message: "#{e.class}: #{e.message}",
+                        fix: "fix the :validate hook in .textus/hooks/")]
     end
 
     def fail_issue(name, code:, message:, fix:)
@@ -88,6 +85,6 @@ module Textus
       }
     end
 
-    private_class_method :run_registered_checks, :fail_issue
+    private_class_method :run_registered_checks, :invoke_registered_check, :fail_issue
   end
 end

data/lib/textus/domain/authorizer.rb

@@ -3,32 +3,32 @@
 module Textus
   module Domain
     # Authorization service. Single source of truth for "given a manifest
-    # entry and a role, may this caller read/write?". Extracted from
-    # Application::Context so the rule lives in Domain alongside Permission.
+    # entry and a role, may this caller read/write?". Lives in Domain
+    # alongside Permission.
     class Authorizer
       def initialize(manifest:)
         @manifest = manifest
       end
 
       def can_write?(zone, role:)
-        @manifest.permission_for(zone.to_s).allows_write?(role)
+        @manifest.policy.permission_for(zone.to_s).allows_write?(role)
       end
 
       def can_read?(zone, role:)
-        @manifest.permission_for(zone.to_s).allows_read?(role)
+        @manifest.policy.permission_for(zone.to_s).allows_read?(role)
       end
 
       def authorize_write!(mentry, role:)
         return if can_write?(mentry.zone, role: role)
 
-        writers = @manifest.zone_writers(mentry.zone)
+        writers = @manifest.policy.zone_writers(mentry.zone)
         raise WriteForbidden.new(mentry.key, mentry.zone, writers: writers)
       end
 
       def authorize_read!(mentry, role:)
         return if can_read?(mentry.zone, role: role)
 
-        readers = @manifest.zone_readers[mentry.zone]
+        readers = @manifest.policy.zone_readers[mentry.zone]
         readers = nil if readers == :all
         raise ReadForbidden.new(mentry.key, mentry.zone, readers: readers)
       end

data/lib/textus/{application → domain}/policy/predicates/accept_authority_signed.rb

@@ -1,5 +1,5 @@
 module Textus
-  module Application
+  module Domain
     module Policy
       module Predicates
         # Promotion predicate: the role driving the promotion must have
@@ -20,7 +20,7 @@ module Textus
             role_str = role&.to_s
             return true if role_str.nil? || role_str.empty?
 
-            kind = manifest.role_kind(role_str)
+            kind = manifest.policy.role_kind(role_str)
             return true if kind == :accept_authority
 
             @reason = "role '#{role_str}' has kind '#{kind.inspect}', expected ':accept_authority'"

data/lib/textus/{application → domain}/policy/predicates/schema_valid.rb

@@ -1,5 +1,5 @@
 module Textus
-  module Application
+  module Domain
     module Policy
       module Predicates
         class SchemaValid

data/lib/textus/{application → domain}/policy/promotion.rb

@@ -2,7 +2,7 @@ require_relative "predicates/schema_valid"
 require_relative "predicates/accept_authority_signed"
 
 module Textus
-  module Application
+  module Domain
     module Policy
       class Promotion
         Result = Struct.new(:ok?, :reasons, keyword_init: true)

data/lib/textus/domain/sentinel.rb

@@ -1,69 +1,15 @@
-require "json"
 require "digest"
-require "fileutils"
 
 module Textus
   module Domain
-    # Value object for sentinel files written by Infra::Publisher and inspected
-    # by Doctor::Check::Sentinels. Owns the JSON shape ({source, target,
-    # sha256, mode}) and the on-disk path layout (<store_root>/sentinels/
-    # <target-rel-to-repo>.textus-managed.json). Target/source are repo-relative
-    # when the published file is under the repo root, absolute otherwise.
+    # Pure value object representing a published-file sentinel. Holds the
+    # recorded target path, source path, sha256 checksum, and publish mode.
+    # Has no filesystem I/O — path layout and persistence live in
+    # Ports::SentinelStore; predicate methods accept a FileStat port for
+    # existence and content checks.
     class Sentinel
-      SUFFIX = ".textus-managed.json".freeze
-      DIR    = "sentinels".freeze
-
       attr_reader :target, :source, :sha256, :mode
 
-      def self.write!(target:, source:, store_root:)
-        path = sentinel_path(target, store_root)
-        FileUtils.mkdir_p(File.dirname(path))
-        repo_root = File.dirname(store_root)
-        File.write(path, JSON.generate(
-                           "source" => rel_or_abs(source, repo_root),
-                           "target" => rel_or_abs(target, repo_root),
-                           "sha256" => Digest::SHA256.hexdigest(File.binread(target)),
-                           "mode" => "copy",
-                         ))
-      end
-
-      def self.load(path, repo_root)
-        raw = JSON.parse(File.read(path))
-        new(
-          target: absolutize(raw["target"], repo_root),
-          source: absolutize(raw["source"], repo_root),
-          sha256: raw["sha256"],
-          mode: raw["mode"],
-        )
-      rescue JSON::ParserError, Errno::ENOENT
-        nil
-      end
-
-      def self.sentinel_path(target, store_root)
-        repo_root = File.dirname(store_root)
-        rel = relative_to(target, repo_root) || File.basename(target)
-        File.join(store_root, DIR, rel + SUFFIX)
-      end
-
-      def self.rel_or_abs(path, repo_root)
-        relative_to(path, repo_root) || File.expand_path(path)
-      end
-
-      def self.relative_to(path, repo_root)
-        path = File.expand_path(path)
-        base = File.expand_path(repo_root)
-        return nil unless path.start_with?(base + File::SEPARATOR)
-
-        path[(base.length + 1)..]
-      end
-
-      def self.absolutize(path, repo_root)
-        return path if path.nil?
-        return path if File.absolute_path?(path)
-
-        File.expand_path(path, repo_root)
-      end
-
       def initialize(target:, source:, sha256:, mode:)
         @target = target
         @source = source
@@ -71,15 +17,13 @@ module Textus
         @mode = mode
       end
 
-      def orphan?
-        @target.nil? || !File.exist?(@target)
-      end
+      def orphan?(file_stat) = @target.nil? || !file_stat.exists?(@target)
 
-      def drift?
-        return false if orphan?
+      def drift?(file_stat)
+        return false if orphan?(file_stat)
         return false if @sha256.nil?
 
-        Digest::SHA256.hexdigest(File.binread(@target)) != @sha256
+        Digest::SHA256.hexdigest(file_stat.read(@target)) != @sha256
       end
     end
   end

data/lib/textus/domain/staleness/generator_check.rb

@@ -8,34 +8,43 @@ module Textus
       # entry's `_meta.generated.at` timestamp. Returns an Array of row hashes
       # (possibly empty) per entry.
       class GeneratorCheck
-        def initialize(manifest:)
-          @manifest = manifest
+        def initialize(manifest:, file_stat:)
+          @manifest  = manifest
+          @file_stat = file_stat
         end
 
         def rows_for(mentry)
-          return [] unless mentry.in_generator_zone?
-          return [] unless mentry.is_a?(Textus::Manifest::Entry::Derived)
+          return [] unless applicable?(mentry)
 
-          src = mentry.source
-          return [] unless src.is_a?(Textus::Manifest::Entry::Derived::External)
+          path = Textus::Key::Path.resolve(@manifest.data, mentry)
+          reason = stale_reason(mentry, path)
+          reason ? [stale_row(mentry, path, reason)] : []
+        end
 
-          path = Textus::Key::Path.resolve(@manifest, mentry)
-          return [stale_row(mentry, path, "derived entry has never been generated")] unless File.exist?(path)
+        private
 
-          parsed = Entry.for_format(mentry.format).parse(File.binread(path), path: path)
-          generated_at = parsed["_meta"].dig("generated", "at")
-          return [stale_row(mentry, path, "missing generated.at frontmatter")] unless generated_at
+        def applicable?(mentry)
+          mentry.in_generator_zone?(@manifest.policy) &&
+            mentry.is_a?(Textus::Manifest::Entry::Derived) &&
+            mentry.source.is_a?(Textus::Manifest::Entry::Derived::External)
+        end
 
-          gen_time = parse_time(generated_at)
-          return [stale_row(mentry, path, "unparseable generated.at: #{generated_at.inspect}")] unless gen_time
+        def stale_reason(mentry, path)
+          return "derived entry has never been generated" unless @file_stat.exists?(path)
 
-          offender = newest_source_after(src, gen_time)
-          return [stale_row(mentry, path, "source '#{offender}' modified after generated.at")] if offender
+          generated_at = generated_at_of(mentry, path)
+          return "missing generated.at frontmatter" unless generated_at
 
-          []
+          gen_time = parse_time(generated_at)
+          return "unparseable generated.at: #{generated_at.inspect}" unless gen_time
+
+          offender = newest_source_after(mentry.source, gen_time)
+          "source '#{offender}' modified after generated.at" if offender
         end
 
-        private
+        def generated_at_of(mentry, path)
+          Entry.for_format(mentry.format).parse(@file_stat.read(path), path: path)["_meta"].dig("generated", "at")
+        end
 
         def parse_time(str)
           Time.parse(str.to_s)
@@ -54,7 +63,7 @@ module Textus
         def check_source(src, gen_time)
           if src.match?(/\A[a-z0-9.][a-z0-9._-]*\z/) && !src.include?("/")
             @manifest.resolver.enumerate(prefix: src).each do |row|
-              return src if File.mtime(row[:path]) > gen_time
+              return src if @file_stat.mtime(row[:path]) > gen_time
             end
             nil
           else
@@ -63,18 +72,29 @@ module Textus
         end
 
         def check_filesystem_source(src, gen_time)
-          abs = File.absolute_path?(src) ? src : File.join(File.dirname(@manifest.root), src)
-          if File.directory?(abs)
-            Dir.glob(File.join(abs, "**", "*")).each do |fp|
-              next unless File.file?(fp)
-              return src if File.mtime(fp) > gen_time
-            end
-            nil
-          elsif File.exist?(abs) && File.mtime(abs) > gen_time
+          abs = absolutize_source(src)
+          if @file_stat.directory?(abs)
+            dir_has_newer_file?(abs, gen_time) ? src : nil
+          elsif @file_stat.exists?(abs) && @file_stat.mtime(abs) > gen_time
             src
           end
         end
 
+        def absolutize_source(src)
+          File.absolute_path?(src) ? src : File.join(File.dirname(@manifest.data.root), src)
+        end
+
+        def dir_has_newer_file?(abs, gen_time)
+          @file_stat.glob(File.join(abs, "**", "*")).any? do |fpath|
+            file?(fpath) && @file_stat.mtime(fpath) > gen_time
+          end
+        end
+
+        # FileStat substitute for File.file?: excludes directories but treats
+        # special files (FIFOs/sockets/devices) as regular files — acceptable
+        # because a generator source tree won't contain them.
+        def file?(fpath) = !@file_stat.directory?(fpath) && @file_stat.exists?(fpath)
+
         def stale_row(mentry, path, reason)
           {
             "key" => mentry.key,

data/lib/textus/domain/staleness/intake_check.rb

@@ -6,30 +6,38 @@ module Textus
       # Reports TTL-exceeded staleness for intake-handler entries. Returns an
       # Array of row hashes (possibly empty) per entry.
       class IntakeCheck
-        def initialize(manifest:)
-          @manifest = manifest
+        def initialize(manifest:, file_stat:, clock:)
+          @manifest  = manifest
+          @file_stat = file_stat
+          @clock     = clock
         end
 
         def rows_for(mentry)
           return [] unless mentry.is_a?(Textus::Manifest::Entry::Intake)
 
-          ttl = @manifest.rules_for(mentry.key).refresh&.ttl_seconds
+          ttl = @manifest.rules.for(mentry.key).refresh&.ttl_seconds
           return [] unless ttl
 
-          path = Textus::Key::Path.resolve(@manifest, mentry)
-          return [row(mentry, path, "never refreshed")] unless File.exist?(path)
+          path = Textus::Key::Path.resolve(@manifest.data, mentry)
+          reason = ttl_reason(mentry, path, ttl)
+          reason ? [row(mentry, path, reason)] : []
+        end
+
+        private
 
-          meta = Entry.for_format(mentry.format).parse(File.binread(path), path: path)["_meta"]
-          last_str = meta["last_refreshed_at"]
-          return [row(mentry, path, "never refreshed (no last_refreshed_at)")] if last_str.nil?
+        def ttl_reason(mentry, path, ttl)
+          return "never refreshed" unless @file_stat.exists?(path)
 
-          last = parse_time(last_str)
-          return [row(mentry, path, "ttl exceeded (#{ttl}s)")] if last.nil? || (Time.now - last) > ttl
+          last_str = last_refreshed_of(mentry, path)
+          return "never refreshed (no last_refreshed_at)" if last_str.nil?
 
-          []
+          last = parse_time(last_str)
+          "ttl exceeded (#{ttl}s)" if last.nil? || (@clock.now - last) > ttl
         end
 
-        private
+        def last_refreshed_of(mentry, path)
+          Entry.for_format(mentry.format).parse(@file_stat.read(path), path: path)["_meta"]["last_refreshed_at"]
+        end
 
         def parse_time(str)
           Time.parse(str.to_s)

data/lib/textus/domain/staleness.rb

@@ -1,14 +1,14 @@
 module Textus
   module Domain
     class Staleness
-      def initialize(manifest:)
+      def initialize(manifest:, file_stat:, clock:)
         @manifest = manifest
-        @generator_check = GeneratorCheck.new(manifest: manifest)
-        @intake_check = IntakeCheck.new(manifest: manifest)
+        @generator_check = GeneratorCheck.new(manifest: manifest, file_stat: file_stat)
+        @intake_check    = IntakeCheck.new(manifest: manifest, file_stat: file_stat, clock: clock)
       end
 
       def call(prefix: nil, zone: nil)
-        @manifest.entries
+        @manifest.data.entries
                  .select { |m| entry_matches?(m, prefix: prefix, zone: zone) }
                  .flat_map { |m| @generator_check.rows_for(m) + @intake_check.rows_for(m) }
       end

data/lib/textus/envelope/io/reader.rb

@@ -0,0 +1,44 @@
+module Textus
+  class Envelope
+    module IO
+      # Read-only counterpart to EnvelopeWriter. Resolves a key, reads the
+      # bytes, parses them via the format strategy, and hands back an
+      # Envelope. Used by Mv (pre-move inspection) and by EnvelopeWriter
+      # (existing-uid lookup for the uid-preservation step in #put).
+      #
+      # No audit, no events, no permission checks — those live one layer up.
+      class Reader
+        def initialize(file_store:, manifest:)
+          @file_store = file_store
+          @manifest   = manifest
+        end
+
+        def read(key)
+          res = @manifest.resolver.resolve(key)
+          path = res.path
+          return nil unless @file_store.exists?(path)
+
+          mentry = res.entry
+          raw = @file_store.read(path)
+          parsed = Entry.for_format(mentry.format).parse(raw, path: path)
+          Textus::Envelope.build(
+            key: key, mentry: mentry, path: path,
+            meta: parsed["_meta"], body: parsed["body"],
+            etag: Etag.for_bytes(raw), content: parsed["content"]
+          )
+        end
+
+        def existing_uid(key)
+          env = read(key)
+          env&.uid
+        rescue StandardError
+          nil
+        end
+
+        def exists?(key)
+          @file_store.exists?(@manifest.resolver.resolve(key).path)
+        end
+      end
+    end
+  end
+end