textus 0.54.2 → 0.55.1

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

@@ -8,12 +8,12 @@ module Textus
       # that drift without making `build` scan globally.
       class OrphanedPublishTargets < Check
         def call
-          sdir = Textus::Layout.sentinels(root)
+          sdir = Textus::Store::Geometry.new(root).sentinels_root
           return [] unless File.directory?(sdir)
 
           repo_root = File.dirname(root)
-          store = Textus::Ports::SentinelStore.new
-          glob = File.join(sdir, "**", "*#{Textus::Ports::SentinelStore::SUFFIX}")
+          store = Textus::Port::SentinelStore.new
+          glob = File.join(sdir, "**", "*#{Textus::Port::SentinelStore::SUFFIX}")
           Dir.glob(glob).filter_map do |spath|
             sentinel = store.load(spath, repo_root)
             next nil if sentinel.nil? || sentinel.source.nil?

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

@@ -8,7 +8,7 @@ module Textus
       class ProtocolVersion < Check
         # Standalone interface: root is the project root (parent of .textus/).
         def self.run(root:)
-          path = File.join(root, ".textus/manifest.yaml")
+          path = File.join(root, ".textus", "manifest.yaml")
           return [] unless File.exist?(path)
 
           doc = YAML.safe_load_file(path, aliases: false) || {}
@@ -26,7 +26,7 @@ module Textus
         # Doctor check interface: root is the .textus/ directory itself,
         # so manifest.yaml lives directly inside it.
         def call
-          path = File.join(root, "manifest.yaml")
+          path = geometry.manifest_path
           return [] unless File.exist?(path)
 
           doc = YAML.safe_load_file(path, aliases: false) || {}

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

@@ -42,7 +42,7 @@ module Textus
         end
 
         def find_asset_path(asset_rel)
-          File.join(root, "assets", asset_rel)
+          File.join(geometry.root, "assets", asset_rel)
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Textus
       # leaving the operator with no signal that a schema is broken.
       class SchemaParseError < Check
         def call
-          dir = File.join(root, "schemas")
+          dir = geometry.schemas_dir
           return [] unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.yaml")).each_with_object([]) do |path, out|

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

@@ -4,11 +4,11 @@ module Textus
       class SchemaViolations < Check
         def call
           result = Textus::Doctor::Validator.new(
-            reader: ->(key, ctnr, c) { Textus::Action::Get.new(key: key).call(container: ctnr, call: c) },
+            reader: ->(key, ctnr, c) { Value::Result.unwrap(Textus::Action::Get.call(container: ctnr, call: c, key: key)) },
             manifest: @container.manifest,
             audit_log: @container.audit_log,
             schema_for: ->(name) { @container.schemas.fetch_or_nil(name) },
-          ).call(container: @container, call: Textus::Call.build(role: Textus::Role::DEFAULT))
+          ).call(container: @container, call: Textus::Value::Call.build(role: Textus::Value::Role::DEFAULT))
 
           result["violations"].map do |v|
             fix = v["expected"] &&

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

@@ -7,7 +7,7 @@ module Textus
           manifest.data.entries.each do |entry|
             next if entry.schema.nil?
 
-            sp = File.join(root, "schemas", "#{entry.schema}.yaml")
+            sp = geometry.schema_path(entry.schema)
             next if File.exist?(sp)
 
             out << {

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

@@ -3,13 +3,13 @@ module Textus
     class Check
       class Sentinels < Check
         def call
-          store      = Textus::Ports::SentinelStore.new
-          file_stat  = Textus::Ports::Storage::FileStat.new
-          dir        = Textus::Layout.sentinels(root)
+          store      = Textus::Port::SentinelStore.new
+          file_stat  = Textus::Port::Storage::FileStat.new
+          dir        = Textus::Store::Geometry.new(root).sentinels_root
           return [] unless file_stat.directory?(dir)
 
           repo_root = File.dirname(root)
-          file_stat.glob(File.join(dir, "**", "*#{Textus::Ports::SentinelStore::SUFFIX}")).flat_map do |sentinel_path|
+          file_stat.glob(File.join(dir, "**", "*#{Textus::Port::SentinelStore::SUFFIX}")).flat_map do |sentinel_path|
             inspect_sentinel(sentinel_path, repo_root, store, file_stat)
           end
         end

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

@@ -9,7 +9,7 @@ module Textus
               template = target.template
               next if template.nil?
 
-              tp = File.join(root, "templates", template)
+              tp = geometry.template_path(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(root, "schemas")
+          dir = geometry.schemas_dir
           return [] unless File.directory?(dir)
 
           Dir.glob(File.join(dir, "*.yaml")).flat_map do |path|

data/lib/textus/doctor/check.rb

@@ -14,7 +14,7 @@ module Textus
                           .downcase
       end
 
-      def initialize(container, role: Textus::Role::DEFAULT)
+      def initialize(container, role: Textus::Value::Role::DEFAULT)
         @container = container
         @role      = role
       end
@@ -26,18 +26,15 @@ module Textus
       protected
 
       def root     = @container.root
+      def geometry = @container.geometry
       def manifest = @container.manifest
 
       # Dispatch a verb through Gate.
       def dispatch(verb, *args, **kwargs)
         klass = Textus::Action::VERBS[verb]
         spec = klass.contract if klass.respond_to?(:contract?) && klass.contract?
-        inputs = spec ? Textus::Contract::Binder.inputs_from_ordered(spec, args, kwargs) : kwargs
-        cmd_class = Textus::Gate::VERB_COMMAND.fetch(verb)
-        merged = inputs.merge(role: @role)
-        filled = cmd_class.members.to_h { |m| [m, merged.key?(m) ? merged[m] : nil] }
-        cmd = cmd_class.new(**filled)
-        @container.gate.dispatch(cmd)
+        inputs = spec ? Textus::Gate::Binder.inputs_from_ordered(spec, args, kwargs) : kwargs
+        @container.gate.dispatch(spec:, inputs:, role: @role)
       end
     end
   end

data/lib/textus/doctor.rb

@@ -30,7 +30,7 @@ module Textus
 
     module_function
 
-    def build(container:, checks: nil, role: Textus::Role::DEFAULT)
+    def build(container:, checks: nil, role: Textus::Value::Role::DEFAULT)
       selected_keys = checks ? Array(checks).map(&:to_s) : ALL_CHECKS
       unknown = selected_keys - ALL_CHECKS
       unless unknown.empty?

data/lib/textus/errors.rb

@@ -225,6 +225,12 @@ module Textus
     end
   end
 
+  class ActionError < Error
+    def initialize(code, message, details: {})
+      super(code, message, details: details, exit_code: 1)
+    end
+  end
+
   class CursorExpired < Error
     attr_reader :requested, :min_available
 

data/lib/textus/format/base.rb

@@ -29,10 +29,6 @@ module Textus
         raise NotImplementedError.new("#{name}.validate_path_extension not implemented")
       end
 
-      def self.inject_uid(_meta, _content, _existing_uid)
-        raise NotImplementedError.new("#{name}.inject_uid not implemented")
-      end
-
       def self.enforce_name_match!(_path, _meta)
         raise NotImplementedError.new("#{name}.enforce_name_match! not implemented")
       end

data/lib/textus/format/json.rb

@@ -80,12 +80,6 @@ module Textus
         raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
       end
 
-      def self.inject_uid(meta, content, existing_uid)
-        m = meta.is_a?(Hash) ? meta.dup : {}
-        m["uid"] = existing_uid || Textus::Uid.mint unless m["uid"].is_a?(String) && !m["uid"].empty?
-        [m, content]
-      end
-
       def self.validate_path_extension(path, nested)
         ext = File.extname(path)
         if nested
@@ -98,6 +92,11 @@ module Textus
 
         raise UsageError.new("json format requires '.json' path (got #{ext.inspect})")
       end
+
+      def self.data_to_payload(data)
+        data = data.transform_keys(&:to_s) if data.is_a?(Hash)
+        { meta: data["_meta"] || {}, body: nil, content: data["content"] || data }
+      end
     end
   end
 end

data/lib/textus/format/markdown.rb

@@ -64,18 +64,17 @@ module Textus
         raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
       end
 
-      def self.inject_uid(meta, content, existing_uid)
-        m = meta.is_a?(Hash) ? meta.dup : {}
-        m["uid"] = existing_uid || Textus::Uid.mint unless m["uid"].is_a?(String) && !m["uid"].empty?
-        [m, content]
-      end
-
       def self.validate_path_extension(path, _nested)
         ext = File.extname(path)
         return if ["", ".md"].include?(ext)
 
         raise UsageError.new("markdown format requires '.md' path (got #{ext.inspect})")
       end
+
+      def self.data_to_payload(data)
+        data = data.transform_keys(&:to_s) if data.is_a?(Hash)
+        { meta: data["_meta"] || {}, body: (data["body"] || "").to_s, content: nil }
+      end
     end
   end
 end

data/lib/textus/format/shared.rb

@@ -0,0 +1,17 @@
+module Textus
+  module Format
+    module Shared
+      ENFORCE_NAME_RE = /\.(md|json|yaml|yml|txt)\z/i
+
+      def self.enforce_name_match!(path, meta, extensions)
+        return unless meta.is_a?(Hash) && meta["name"]
+
+        ext = extensions.first
+        basename = File.basename(path, ext)
+        return if meta["name"] == basename
+
+        raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
+      end
+    end
+  end
+end

data/lib/textus/format/text.rb

@@ -20,10 +20,6 @@ module Textus
 
       def self.nested_glob = "**/*.txt"
 
-      def self.inject_uid(meta, content, _existing_uid)
-        [meta, content]
-      end
-
       def self.enforce_name_match!(_path, _meta); end
 
       def self.serialize_for_put(meta:, body:, content:, path:)
@@ -49,6 +45,11 @@ module Textus
 
         raise UsageError.new("text format requires '.txt' or no extension (got #{ext.inspect})")
       end
+
+      def self.data_to_payload(data)
+        data = data.transform_keys(&:to_s) if data.is_a?(Hash)
+        { meta: data["_meta"] || {}, body: (data["body"] || "").to_s, content: nil }
+      end
     end
   end
 end

data/lib/textus/format/yaml.rb

@@ -37,6 +37,31 @@ module Textus
         schema.validate!(parsed["content"] || {})
       end
 
+      RAW_REQUIRED = %w[ingested_at content_hash].freeze
+      RAW_SOURCE_KINDS = %w[url file asset].freeze
+
+      def self.validate_raw_entry!(parsed, lane)
+        return unless lane == "raw"
+
+        content = parsed["content"] || {}
+        return if content["superseded_by"]
+
+        missing = RAW_REQUIRED.reject { |f| content[f] }
+        raise Textus::BadContent.new(nil, "raw entry missing required field(s): #{missing.join(", ")}") if missing.any?
+
+        source = content["source"] || {}
+        kind = source["kind"]
+        unless RAW_SOURCE_KINDS.include?(kind)
+          raise Textus::BadContent.new(
+            nil, "raw entry source.kind must be #{RAW_SOURCE_KINDS.join("|")}, got #{kind.inspect}"
+          )
+        end
+
+        return unless kind == "url" && !source["url"]
+
+        raise Textus::BadContent.new(nil, "raw entry with source.kind=url must have source.url")
+      end
+
       def self.extensions = [".yaml", ".yml"]
 
       def self.nested_glob = "**/*.{yaml,yml}"
@@ -78,12 +103,6 @@ module Textus
         raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
       end
 
-      def self.inject_uid(meta, content, existing_uid)
-        m = meta.is_a?(Hash) ? meta.dup : {}
-        m["uid"] = existing_uid || Textus::Uid.mint unless m["uid"].is_a?(String) && !m["uid"].empty?
-        [m, content]
-      end
-
       def self.validate_path_extension(path, nested)
         ext = File.extname(path)
         if nested
@@ -96,6 +115,11 @@ module Textus
 
         raise UsageError.new("yaml format requires '.yaml' or '.yml' path (got #{ext.inspect})")
       end
+
+      def self.data_to_payload(data)
+        data = data.transform_keys(&:to_s) if data.is_a?(Hash)
+        { meta: data["_meta"] || {}, body: nil, content: data["content"] || data }
+      end
     end
   end
 end

data/lib/textus/format.rb

@@ -36,5 +36,11 @@ module Textus
     def self.serialize(meta: {}, body: "", content: nil, format: "markdown")
       Format.for(format).serialize(meta: meta, body: body, content: content)
     end
+
+    def self.data_to_payload(data, format)
+      return { meta: {}, body: "", content: nil } if data.nil?
+
+      Format.for(format).data_to_payload(data)
+    end
   end
 end

data/lib/textus/gate/auth.rb

@@ -27,13 +27,12 @@ module Textus
         @schemas = container.schemas
       end
 
-      # Command-based check (new Gate path).
       def check!(cmd)
         key = extract_key(cmd)
         return unless key
 
         evaluate_predicates(
-          action: command_to_action(cmd),
+          action: cmd.verb,
           actor: cmd.role.to_s,
           key: key,
           envelope: nil,
@@ -52,18 +51,8 @@ module Textus
         )
       end
 
-      def self.command_to_verb
-        @command_to_verb ||= Textus::Gate::VERB_COMMAND.invert.freeze
-      end
-
       private
 
-      def command_to_action(cmd)
-        self.class.command_to_verb.fetch(cmd.class) do
-          raise Textus::UsageError.new("unmapped command: #{cmd.class}")
-        end
-      end
-
       def evaluate_predicates(action:, actor:, key:, envelope:, extra:)
         mentry = @manifest.resolver.resolve(key).entry
         lane_verb = @manifest.policy.verb_for_lane(mentry.lane.to_s)
@@ -89,11 +78,7 @@ module Textus
       end
 
       def extract_key(cmd)
-        if cmd.respond_to?(:pending_key)
-          cmd.pending_key
-        elsif cmd.respond_to?(:key)
-          cmd.key
-        end
+        cmd.params.key?(:pending_key) ? cmd.pending_key : cmd.key
       end
 
       def rule_declared_predicates(action, key)

data/lib/textus/gate/binder.rb

@@ -0,0 +1,50 @@
+module Textus
+  class Gate
+    # Raised when a required arg is absent from the bound input. Surface
+    # adapters translate this to their native error (MCP ToolError, CLI
+    # UsageError); a direct Ruby call lets it surface as-is.
+    class MissingArgs < Textus::Error
+      attr_reader :spec, :missing
+
+      def initialize(spec, missing)
+        @spec = spec
+        @missing = missing
+        super("missing_args", "#{spec.verb}: missing #{missing.map(&:wire).join(", ")}")
+      end
+    end
+
+    # Validates and resolves a by-name inputs hash against a contract spec.
+    # Returns a flat hash with defaults and session_defaults filled in.
+    # Every caller receives the same shape — no positional/kwarg split.
+    module Binder
+      module_function
+
+      def bind(spec, inputs, session: nil)
+        missing = spec.required_args.reject { |a| inputs.key?(a.name) }
+        raise MissingArgs.new(spec, missing) unless missing.empty?
+
+        spec.args.each_with_object({}) do |a, h|
+          if inputs.key?(a.name)
+            h[a.name] = inputs[a.name]
+          elsif a.session_default && session
+            h[a.name] = session.public_send(a.session_default)
+          elsif !a.default.nil?
+            h[a.name] = a.default
+          end
+        end
+      end
+
+      def inputs_from_ordered(spec, ordered_positionals, by_name_keywords)
+        names = spec.args.select(&:positional).map(&:name)
+        names.zip(ordered_positionals).to_h.compact.merge(by_name_keywords)
+      end
+
+      def inputs_from_wire(spec, raw)
+        raw ||= {}
+        spec.args.each_with_object({}) do |a, h|
+          h[a.name] = raw[a.wire.to_s] if raw.key?(a.wire.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/textus/gate.rb

@@ -2,115 +2,91 @@
 
 module Textus
   class Gate
-    VERB_COMMAND = {
-      get: Textus::Command::Get,
-      put: Textus::Command::Put,
-      propose: Textus::Command::Propose,
-      key_delete: Textus::Command::KeyDelete,
-      key_mv: Textus::Command::KeyMv,
-      accept: Textus::Command::Accept,
-      reject: Textus::Command::Reject,
-      enqueue: Textus::Command::Enqueue,
-      list: Textus::Command::List,
-      where: Textus::Command::Where,
-      uid: Textus::Command::Uid,
-      blame: Textus::Command::Blame,
-      audit: Textus::Command::Audit,
-      deps: Textus::Command::Deps,
-      rdeps: Textus::Command::Rdeps,
-      pulse: Textus::Command::Pulse,
-      rule_explain: Textus::Command::RuleExplain,
-      rule_list: Textus::Command::RuleList,
-      rule_lint: Textus::Command::RuleLint,
-      published: Textus::Command::Published,
-      schema_show: Textus::Command::SchemaShow,
-      doctor: Textus::Command::Doctor,
-      boot: Textus::Command::Boot,
-      jobs: Textus::Command::Jobs,
-      data_mv: Textus::Command::DataMv,
-      key_mv_prefix: Textus::Command::KeyMvPrefix,
-      key_delete_prefix: Textus::Command::KeyDeletePrefix,
-      drain: Textus::Command::Drain,
-      ingest: Textus::Command::Ingest,
-    }.freeze
-
-    ROUTES = {
-      Command::Get => [Textus::Action::Get],
-      Command::Put => [Textus::Action::Put],
-      Command::Propose => [Textus::Action::Propose],
-      Command::KeyDelete => [Textus::Action::KeyDelete],
-      Command::KeyMv => [Textus::Action::KeyMv],
-      Command::Accept => [Textus::Action::Accept],
-      Command::Reject => [Textus::Action::Reject],
-      Command::Enqueue => [Textus::Action::Enqueue],
-      Command::List => [Textus::Action::List],
-      Command::Where => [Textus::Action::Where],
-      Command::Uid => [Textus::Action::Uid],
-      Command::Blame => [Textus::Action::Blame],
-      Command::Audit => [Textus::Action::Audit],
-      Command::Deps => [Textus::Action::Deps],
-      Command::Rdeps => [Textus::Action::Rdeps],
-      Command::Pulse => [Textus::Action::Pulse],
-      Command::RuleExplain => [Textus::Action::RuleExplain],
-      Command::RuleList => [Textus::Action::RuleList],
-      Command::RuleLint => [Textus::Action::RuleLint],
-      Command::Published => [Textus::Action::Published],
-      Command::SchemaShow => [Textus::Action::SchemaEnvelope],
-      Command::Doctor => [Textus::Action::Doctor],
-      Command::Boot => [Textus::Action::Boot],
-      Command::Jobs => [Textus::Action::Jobs],
-      Command::DataMv => [Textus::Action::DataMv],
-      Command::KeyMvPrefix => [Textus::Action::KeyMvPrefix],
-      Command::KeyDeletePrefix => [Textus::Action::KeyDeletePrefix],
-      Command::Drain => [Textus::Action::Drain],
-      Command::Ingest => [Textus::Action::Ingest],
-    }.freeze
-
     def initialize(container)
       @container = container
     end
 
-    def dispatch(cmd, correlation_id: nil)
-      cmd = normalize_propose_key(cmd, @container) if cmd.is_a?(Command::Propose)
-      action_classes = ROUTES.fetch(cmd.class) do
-        raise Textus::UsageError.new("unknown command: #{cmd.class}")
+    def dispatch(spec:, inputs:, role:, correlation_id: nil, session: nil, surface: nil)
+      resolved = Binder.bind(spec, inputs, session: session)
+      cmd = Value::Command.new(verb: spec.verb, params: resolved.freeze, role: role)
+
+      cmd = normalize_propose_key(cmd) if cmd.verb == :propose
+      action_class = Textus::Action::VERBS.fetch(cmd.verb) do
+        raise Textus::UsageError.new("unknown command verb: #{cmd.verb}")
       end
 
-      Gate::Auth.new(@container).check!(cmd)
+      auth = Gate::Auth.new(@container)
+      auth.check!(cmd)
+      check_dispatch_auth(cmd, resolved, auth)
       call_obj = build_call(cmd, correlation_id: correlation_id)
-      results = action_classes.map { |klass| run_action(klass, cmd, @container, call_obj) }
-      results.length == 1 ? results.first : results
+      result = run_action(action_class, resolved, call_obj)
+      cascade(cmd, result, call_obj) if CASCADE_VERBS.include?(cmd.verb) && !call_obj.dry_run
+      return result unless surface
+
+      spec.view(surface).call(result, resolved)
     end
 
+    CASCADE_VERBS = %i[put propose accept reject key_mv key_delete].freeze
+
+    AUTH_KEYS = {
+      key_mv: ->(params) { [params[:old_key], params[:new_key]] },
+      ingest: ->(params) { Textus::Action::Ingest.dispatch_key(**params) },
+    }.freeze
+
     private
 
-    def normalize_propose_key(cmd, container)
+    def check_dispatch_auth(cmd, resolved, auth)
+      return unless (resolver = AUTH_KEYS[cmd.verb])
+
+      keys = Array(resolver.call(resolved))
+      keys.each { |k| auth.check_action!(action: cmd.verb, actor: cmd.role, key: k) }
+    end
+
+    def normalize_propose_key(cmd)
       return cmd if cmd.pending_key
 
-      zone = container.manifest.policy.propose_lane_for(cmd.role.to_s)
-      cmd.with(pending_key: zone ? "#{zone}.#{cmd.key}" : nil)
+      zone = @container.manifest.policy.propose_lane_for(cmd.role.to_s)
+      key = zone ? "#{zone}.#{cmd.key}" : nil
+      cmd.with(params: cmd.params.merge(pending_key: key))
     end
 
-    def run_action(klass, cmd, container, call_obj)
-      action = klass.new(**extract_kwargs(klass, cmd))
-      action.call(container:, call: call_obj)
+    def run_action(klass, params, call_obj)
+      result = klass.call(container: @container, call: call_obj, **params)
+      Value::Result.unwrap(result)
+    end
+
+    def build_call(cmd, correlation_id: nil)
+      dry_run = cmd.params.key?(:dry_run) ? !cmd.params[:dry_run].nil? : false
+      Textus::Value::Call.build(role: cmd.role, dry_run:, correlation_id: correlation_id)
     end
 
-    def extract_kwargs(klass, cmd)
-      params = klass.instance_method(:initialize).parameters
-      accepts_keyrest = params.any? { |t, _| t == :keyrest }
-      param_set = params.to_set { |_t, n| n }
-      cmd.members.each_with_object({}) do |m, h|
-        next unless accepts_keyrest || param_set.include?(m)
+    def cascade(cmd, result, call)
+      key = result.is_a?(Hash) ? result["cascade_key"] : nil
+      key ||= cascade_key_from_params(cmd)
+      return unless key
 
-        val = cmd.public_send(m)
-        h[m] = val unless val.nil?
+      rdeps_result = Textus::Action::Rdeps.call(container: @container, call: call, key: key)
+      rdeps = Value::Result.unwrap(rdeps_result).fetch("rdeps", [])
+      producible = rdeps.select { |dep_key| producible?(dep_key) }
+      producible.each do |dep_key|
+        Textus::Store::Jobs::Materialize.call(container: @container, call: call, key: dep_key)
       end
     end
 
-    def build_call(cmd, correlation_id: nil)
-      dry_run = cmd.respond_to?(:dry_run) ? !cmd.dry_run.nil? : false
-      Textus::Call.build(role: cmd.role, dry_run:, correlation_id: correlation_id)
+    def cascade_key_from_params(cmd)
+      case cmd.verb
+      when :put, :key_delete then cmd.params[:key]
+      when :key_mv           then cmd.params[:new_key]
+      when :propose, :reject then cmd.params[:pending_key]
+      when :accept           then nil
+      end
+    end
+
+    def producible?(key)
+      entry = @container.manifest.resolver.resolve(key).entry
+      !entry.publish_tree.nil?
+    rescue Textus::Error
+      false
     end
   end
 end

data/lib/textus/init.rb

@@ -92,9 +92,7 @@ module Textus
     end
 
     def self.setup_state_dirs(target_root)
-      FileUtils.mkdir_p(Textus::Layout.audit_dir(target_root))
-      FileUtils.mkdir_p(Textus::Layout.cursors(target_root))
-      FileUtils.mkdir_p(Textus::Layout.locks(target_root))
+      FileUtils.mkdir_p(Textus::Store::Geometry.new(target_root).audit_dir_path)
     end
 
     def self.write_gitignore(target_root)
@@ -153,7 +151,7 @@ module Textus
           Pathname.new(Textus::Key::Path.resolve(manifest.data, e)).relative_path_from(root).to_s
         end
       end
-      Textus::Layout.gitignore_body(untracked_paths: untracked)
+      Textus::Store::Geometry.new(target_root).gitignore_body(untracked_entries: untracked)
     end
   end
 end

data/lib/textus/jobs.rb

@@ -1,15 +1,9 @@
 module Textus
   module Jobs
-    @registry = {}
-
-    def self.registry = @registry
-
-    def self.register(klass)
-      @registry[klass::TYPE] = klass if klass.const_defined?(:TYPE, false)
-    end
-
     def self.fetch(type)
-      @registry.fetch(type) { raise Textus::UsageError.new("unknown job type: #{type}") }
+      Store::Jobs::Registry.fetch(type)
+    rescue Store::Jobs::Registry::UnknownJob
+      raise Textus::UsageError.new("unknown job type: #{type}")
     end
   end
 end