textus 0.55.1 → 0.56.0

data/lib/textus/format.rb

@@ -1,46 +0,0 @@
-module Textus
-  module Format
-    SEP = "---".freeze
-
-    STRATEGIES = {
-      "markdown" => -> { Format::Markdown },
-      "json" => -> { Format::Json },
-      "yaml" => -> { Format::Yaml },
-      "text" => -> { Format::Text },
-    }.freeze
-
-    EXT_TO_FORMAT = {
-      ".md" => "markdown",
-      ".json" => "json",
-      ".yaml" => "yaml",
-      ".yml" => "yaml",
-      ".txt" => "text",
-    }.freeze
-
-    def self.for(format)
-      STRATEGIES.fetch(format.to_s) { raise Textus::UsageError.new("unknown entry format: #{format.inspect}") }.call
-    end
-
-    def self.infer_from_extension(ext)
-      EXT_TO_FORMAT[ext]
-    end
-
-    def self.formats
-      EXT_TO_FORMAT.values.uniq
-    end
-
-    def self.parse(raw, path: nil, format: "markdown")
-      Format.for(format).parse(raw, path: path)
-    end
-
-    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

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  class Gate
-    class Auth
-      FLOOR = {
-        put: %w[lane_writable_by raw_lane_ingest_only],
-        key_delete: %w[lane_deletable_by],
-        key_mv: %w[lane_writable_by raw_lane_ingest_only],
-        accept: %w[author_held],
-        reject: %w[author_held],
-        propose: %w[lane_writable_by raw_lane_ingest_only],
-        key_mv_prefix: %w[lane_writable_by raw_lane_ingest_only],
-        key_delete_prefix: %w[lane_writable_by raw_lane_ingest_only],
-        ingest: %w[lane_writable_by raw_write_once],
-      }.freeze
-
-      AuthContext = Struct.new(
-        :actor, :actor_caps, :lane_verb,
-        :action, :target, :envelope,
-        :mentry, :manifest,
-        keyword_init: true
-      )
-
-      def initialize(container)
-        @manifest = container.manifest
-        @schemas = container.schemas
-      end
-
-      def check!(cmd)
-        key = extract_key(cmd)
-        return unless key
-
-        evaluate_predicates(
-          action: cmd.verb,
-          actor: cmd.role.to_s,
-          key: key,
-          envelope: nil,
-          extra: {},
-        )
-      end
-
-      # Backward-compatible check for inline action auth (accept, put, etc.).
-      def check_action!(action:, actor:, key:, envelope: nil, extra: {})
-        evaluate_predicates(
-          action: action.to_sym,
-          actor: actor,
-          key: key,
-          envelope: envelope,
-          extra: extra,
-        )
-      end
-
-      private
-
-      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)
-        actor_caps = Set.new(@manifest.data.role_caps.fetch(actor, []))
-
-        ctx = AuthContext.new(
-          actor:, actor_caps:, lane_verb:,
-          action:, target: key, envelope:,
-          mentry:, manifest: @manifest
-        )
-
-        failures = []
-        floor_preds = FLOOR.fetch(action, [])
-        rule_preds = rule_declared_predicates(action, key)
-        (floor_preds + rule_preds).uniq.each do |pred|
-          result = evaluate(pred, ctx, extra)
-          next if result[:pass]
-          raise result[:error] if result[:error]
-
-          failures << [pred, result[:reason]]
-        end
-        raise Textus::GuardFailed.new(failures) unless failures.empty?
-      end
-
-      def extract_key(cmd)
-        cmd.params.key?(:pending_key) ? cmd.pending_key : cmd.key
-      end
-
-      def rule_declared_predicates(action, key)
-        guard_map = @manifest.rules.for(key).guard
-        return [] if guard_map.nil?
-
-        Array(guard_map[action.to_s])
-      end
-
-      def evaluate(pred_name, ctx, extra)
-        case pred_name
-        when "lane_writable_by"      then evaluate_lane_writable_by(ctx)
-        when "author_held"           then evaluate_author_held(ctx)
-        when "target_is_canon"       then evaluate_target_is_canon(ctx)
-        when "etag_match"            then evaluate_etag_match(ctx, extra)
-        when "schema_valid"          then evaluate_schema_valid(ctx)
-        when "fresh_within"          then { pass: true }
-        when "raw_lane_ingest_only"  then evaluate_raw_lane_ingest_only(ctx)
-        when "raw_write_once"        then evaluate_raw_write_once(ctx)
-        when "lane_deletable_by"     then evaluate_lane_deletable_by(ctx)
-        else raise Textus::UsageError.new("unknown predicate '#{pred_name}'")
-        end
-      end
-
-      def evaluate_lane_writable_by(ctx)
-        pass = ctx.actor_caps.include?(ctx.lane_verb.to_s)
-        return { pass: true } if pass
-
-        holders = @manifest.policy.roles_with_capability(ctx.lane_verb.to_s)
-        { pass: false, error: Textus::WriteForbidden.new(ctx.mentry.key, ctx.mentry.lane, verb: ctx.lane_verb, holders:) }
-      end
-
-      def evaluate_author_held(ctx)
-        holders = @manifest.policy.roles_with_capability("author")
-        pass = holders.include?(ctx.actor.to_s)
-        reason = if pass
-                   nil
-                 elsif holders.empty?
-                   "no role holds the 'author' capability; #{ctx.action} is disabled"
-                 else
-                   "role '#{ctx.actor}' lacks the 'author' capability (held by: #{holders.join(", ")})"
-                 end
-        { pass:, reason: }
-      end
-
-      def evaluate_target_is_canon(ctx)
-        kind = @manifest.policy.declared_kind(ctx.mentry.lane.to_s)
-        pass = kind == :canon
-        { pass:, reason: pass ? nil : "target lane '#{ctx.mentry.lane}' is not canon (kind: #{kind})" }
-      end
-
-      def evaluate_etag_match(ctx, extra)
-        if_etag = extra[:if_etag]
-        return { pass: true } if if_etag.nil?
-
-        current = ctx.envelope&.etag
-        pass = current.nil? || current == if_etag
-        { pass:, error: pass ? nil : Textus::EtagMismatch.new(ctx.target, if_etag, current) }
-      end
-
-      def evaluate_schema_valid(ctx)
-        return { pass: true } unless ctx.envelope
-
-        schema_ref = ctx.mentry.schema
-        return { pass: true } unless schema_ref
-
-        schema = @schemas.fetch_or_nil(schema_ref)
-        return { pass: true } unless schema
-
-        frontmatter = ctx.envelope.meta&.dig("_meta") || ctx.envelope.meta || {}
-        begin
-          schema.validate!(frontmatter)
-          { pass: true }
-        rescue Textus::SchemaViolation => e
-          { pass: false, reason: schema_reason(e) }
-        end
-      end
-
-      def evaluate_raw_lane_ingest_only(ctx)
-        return { pass: true } unless @manifest.policy.declared_kind(ctx.mentry.lane.to_s) == :raw
-        return { pass: true } if ctx.action == :ingest
-
-        { pass: false, error: Textus::Error.new(
-          :raw_lane_ingest_only,
-          "raw lane '#{ctx.mentry.lane}' only accepts `textus ingest` — " \
-          "use that verb instead of '#{ctx.action}'",
-        ) }
-      end
-
-      def evaluate_raw_write_once(ctx)
-        path = @manifest.resolver.resolve(ctx.target).path
-        return { pass: true } unless File.exist?(path)
-
-        { pass: false, error: Textus::Error.new(
-          :raw_write_once,
-          "raw entry '#{ctx.target}' already exists; " \
-          "delete it first (`textus key-delete #{ctx.target}`), then re-ingest",
-        ) }
-      end
-
-      # Deletion authority: the lane's write capability OR the author capability.
-      # On raw-kind lanes only the author capability grants deletion (correction
-      # escape hatch); the lane's own verb (ingest) is write-only. On all other
-      # lane kinds the behaviour matches lane_writable_by — the lane's writer
-      # can delete as before.
-      def evaluate_lane_deletable_by(ctx)
-        is_raw = @manifest.policy.declared_kind(ctx.mentry.lane.to_s) == :raw
-        pass = if is_raw
-                 ctx.actor_caps.include?("author")
-               else
-                 ctx.actor_caps.include?(ctx.lane_verb.to_s) || ctx.actor_caps.include?("author")
-               end
-        return { pass: true } if pass
-
-        extra_holders = is_raw ? ["author"] : [ctx.lane_verb.to_s, "author"]
-        holders = extra_holders.flat_map { |v| @manifest.policy.roles_with_capability(v) }.uniq
-        { pass: false, error: Textus::WriteForbidden.new(ctx.mentry.key, ctx.mentry.lane,
-                                                         verb: ctx.lane_verb, holders:) }
-      end
-
-      def schema_reason(err)
-        d = err.details
-        return err.message.dup unless d.is_a?(Hash)
-        return "missing required fields: #{Array(d["missing"]).join(", ")}" if d["missing"]
-        return "field '#{d["field"]}': #{d["reason"]}" if d["field"]
-
-        err.message.dup
-      end
-    end
-  end
-end

data/lib/textus/gate.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  class Gate
-    def initialize(container)
-      @container = container
-    end
-
-    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
-
-      auth = Gate::Auth.new(@container)
-      auth.check!(cmd)
-      check_dispatch_auth(cmd, resolved, auth)
-      call_obj = build_call(cmd, correlation_id: correlation_id)
-      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 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)
-      key = zone ? "#{zone}.#{cmd.key}" : nil
-      cmd.with(params: cmd.params.merge(pending_key: key))
-    end
-
-    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 cascade(cmd, result, call)
-      key = result.is_a?(Hash) ? result["cascade_key"] : nil
-      key ||= cascade_key_from_params(cmd)
-      return unless key
-
-      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 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

@@ -1,157 +0,0 @@
-require "fileutils"
-require "pathname"
-
-module Textus
-  module Init
-    ZONES = %w[knowledge notebook proposals artifacts raw].freeze
-
-    DEFAULT_MANIFEST = <<~YAML
-      version: textus/4
-      roles:
-        - { name: human,      can: [author, propose] }
-        - { name: agent,      can: [propose, keep] }
-        - { name: automation, can: [converge] }
-      lanes:
-        - { name: knowledge, kind: canon,     desc: "the maintained source of truth (identity.* lives here)" }
-        - { name: notebook,  kind: workspace, owner: agent, desc: "the agent's own durable working notes" }
-        - { name: proposals, kind: queue,     desc: "changes awaiting your accept" }
-        - { name: artifacts, kind: machine,   desc: "machine-maintained: external inputs (artifacts.feeds.*) + computed outputs (artifacts.derived.*)" }
-      entries:
-        - { key: knowledge.identity, path: data/knowledge/identity.md, lane: knowledge, schema: null, owner: human:self, kind: leaf }
-        - { key: knowledge.notes,    path: data/knowledge/notes,       lane: knowledge, schema: null, owner: human:self, nested: true, kind: nested }
-        - { key: notebook.notes,     path: data/notebook/notes,        lane: notebook,  schema: null, owner: agent:self, nested: true, kind: nested }
-        - { key: proposals.notes,    path: data/proposals/notes,       lane: proposals, schema: null, owner: agent:self, nested: true, kind: nested }
-        # A per-host snapshot, populated by a registered workflow. Nested so it
-        # grows to a fleet — add leaves over SSH without renaming. tracked:false →
-        # gitignored (machine info can be sensitive/noisy) but still protocol-readable
-        # via `textus get artifacts.feeds.machines.local`. Delete to opt out. (ADR 0043)
-        - key: artifacts.feeds.machines
-          path: data/artifacts/feeds/machines
-          lane: artifacts
-          format: yaml
-          nested: true
-          tracked: false
-          kind: nested
-      rules: []
-    YAML
-
-    AGENT_ENTRIES = <<~YAML.gsub(/^/, "  ")
-      - { key: knowledge.project, path: data/knowledge/project.md, lane: knowledge, schema: project, owner: human:self, kind: leaf }
-      - { key: knowledge.runbooks, path: data/knowledge/runbooks, lane: knowledge, schema: runbook, owner: human:self, nested: true, kind: nested }
-      - key: artifacts.derived.orientation
-        path: data/artifacts/derived/orientation.json
-        lane: artifacts
-        publish:
-        - { to: CLAUDE.md, template: orientation.erb, inject_boot: true }
-        - { to: AGENTS.md, template: orientation.erb, inject_boot: true }
-        kind: produced
-    YAML
-
-    def self.run(target_root, with_agent: false)
-      check_target!(target_root)
-      scaffold_dir = File.expand_path("init/templates", __dir__)
-      create_directories(target_root)
-      write_manifest(target_root, with_agent:)
-      mcp_status = scaffold_agent(target_root, scaffold_dir, with_agent:)
-      setup_state_dirs(target_root)
-      write_gitignore(target_root)
-      build_result(target_root, with_agent:, mcp_status:)
-    end
-
-    def self.check_target!(target_root)
-      raise UsageError.new(".textus/ already exists at #{target_root}") if File.directory?(target_root)
-    end
-
-    ASSET_ZONES = %w[raw].freeze
-
-    def self.create_directories(target_root)
-      FileUtils.mkdir_p(File.join(target_root, "schemas"))
-      FileUtils.mkdir_p(File.join(target_root, "templates"))
-      FileUtils.mkdir_p(File.join(target_root, "workflows"))
-      ZONES.each do |z|
-        dir = File.join(target_root, "data", z)
-        FileUtils.mkdir_p(dir)
-        File.write(File.join(dir, ".gitkeep"), "")
-      end
-      ASSET_ZONES.each do |z|
-        dir = File.join(target_root, "assets", z)
-        FileUtils.mkdir_p(dir)
-        File.write(File.join(dir, ".gitkeep"), "")
-      end
-    end
-
-    def self.write_manifest(target_root, with_agent:)
-      File.write(File.join(target_root, "manifest.yaml"), manifest_yaml(with_agent: with_agent))
-    end
-
-    def self.scaffold_agent(target_root, scaffold_dir, with_agent:)
-      return nil unless with_agent
-
-      scaffold_agent_profile(target_root, scaffold_dir)
-      write_mcp_config(target_root, scaffold_dir)
-    end
-
-    def self.setup_state_dirs(target_root)
-      FileUtils.mkdir_p(Textus::Store::Geometry.new(target_root).audit_dir_path)
-    end
-
-    def self.write_gitignore(target_root)
-      File.write(File.join(target_root, ".gitignore"), derived_gitignore(target_root))
-    end
-
-    def self.build_result(target_root, with_agent:, mcp_status:)
-      result = { "protocol" => PROTOCOL, "initialized" => target_root, "profile" => with_agent ? "agent" : "default" }
-      result["mcp_config"] = mcp_status if with_agent
-      result
-    end
-
-    # Composes the agent profile by inserting AGENT_ENTRIES immediately before the
-    # top-level `rules:` block of DEFAULT_MANIFEST — that block is load-bearing for
-    # this `.sub`; removing it from DEFAULT_MANIFEST would silently drop the entries.
-    def self.manifest_yaml(with_agent:)
-      return DEFAULT_MANIFEST unless with_agent
-
-      DEFAULT_MANIFEST.sub(/^rules:/, "#{AGENT_ENTRIES}rules:")
-    end
-
-    # Copies the proven orientation bundle into a freshly-init'd store.
-    def self.scaffold_agent_profile(target_root, scaffold_dir)
-      {
-        "project.schema.yaml" => File.join("schemas", "project.yaml"),
-        "runbook.schema.yaml" => File.join("schemas", "runbook.yaml"),
-        "orientation.erb" => File.join("templates", "orientation.erb"),
-      }.each do |src, dest|
-        File.write(File.join(target_root, dest), File.read(File.join(scaffold_dir, src)))
-      end
-    end
-
-    # The one file init writes outside .textus/: a starter .mcp.json at the
-    # project root. Write-once — never clobber a hand-authored config. The
-    # command form assumes a gem-installed `textus` on PATH; the user owns
-    # the file after this first write.
-    def self.write_mcp_config(target_root, scaffold_dir)
-      dest = File.join(File.dirname(target_root), ".mcp.json")
-      return "skipped" if File.exist?(dest)
-
-      File.write(dest, File.read(File.join(scaffold_dir, "mcp.json")))
-      "written"
-    end
-
-    # The store's `.gitignore` is generated, never hand-kept (ADR 0038), and now
-    # derived from the manifest: the run subtree plus every `tracked: false`
-    # entry's resolved path (ADR 0043).
-    def self.derived_gitignore(target_root)
-      manifest = Textus::Manifest.load(target_root)
-      root = Pathname.new(target_root)
-      untracked = manifest.data.entries.reject(&:tracked?).map do |e|
-        if e.nested? # a whole subtree of leaf files (artifacts.feeds.machines.* → data/artifacts/feeds/machines/)
-          rel = e.path.start_with?("data/") ? e.path : File.join("data", e.path)
-          "#{rel}/"
-        else
-          Pathname.new(Textus::Key::Path.resolve(manifest.data, e)).relative_path_from(root).to_s
-        end
-      end
-      Textus::Store::Geometry.new(target_root).gitignore_body(untracked_entries: untracked)
-    end
-  end
-end

data/lib/textus/jobs.rb

@@ -1,9 +0,0 @@
-module Textus
-  module Jobs
-    def self.fetch(type)
-      Store::Jobs::Registry.fetch(type)
-    rescue Store::Jobs::Registry::UnknownJob
-      raise Textus::UsageError.new("unknown job type: #{type}")
-    end
-  end
-end

data/lib/textus/key/distance.rb

@@ -1,55 +0,0 @@
-module Textus
-  module Key
-    # Small utilities for ranking key suggestions. Bounded inputs only —
-    # Levenshtein is O(n*m) so we refuse to compute on long strings.
-    class Distance
-      MAX_LEN = 200
-
-      # Length of the shared dot-separated prefix between two dotted keys.
-      def self.shared_prefix_segments(left, right)
-        asegs = left.split(".")
-        bsegs = right.split(".")
-        n = [asegs.length, bsegs.length].min
-        i = 0
-        i += 1 while i < n && asegs[i] == bsegs[i]
-        i
-      end
-
-      # Classic iterative Levenshtein with two rows. Bounded to MAX_LEN.
-      def self.levenshtein(left, right)
-        return nil if left.length > MAX_LEN || right.length > MAX_LEN
-        return right.length if left.empty?
-        return left.length if right.empty?
-
-        prev = (0..right.length).to_a
-        curr = Array.new(right.length + 1, 0)
-        (1..left.length).each do |i|
-          curr[0] = i
-          (1..right.length).each do |j|
-            cost = left[i - 1] == right[j - 1] ? 0 : 1
-            curr[j] = [
-              curr[j - 1] + 1,      # insertion
-              prev[j] + 1,          # deletion
-              prev[j - 1] + cost,   # substitution
-            ].min
-          end
-          prev, curr = curr, prev
-        end
-        prev[right.length]
-      end
-
-      # Rank candidate keys against requested. Returns up to `limit` keys.
-      # Sort: longer shared prefix first; then smaller Levenshtein distance.
-      def self.suggest(requested, candidates, limit: 5)
-        return [] if requested.nil? || requested.empty?
-
-        scored = candidates.first(200).map do |k|
-          prefix = shared_prefix_segments(requested, k)
-          dist = levenshtein(requested, k) || Float::INFINITY
-          [k, prefix, dist]
-        end
-        scored.sort_by { |(_, prefix, dist)| [-prefix, dist] }.first(limit).map(&:first)
-      end
-    end
-  end
-end

data/lib/textus/key/grammar.rb

@@ -1,33 +0,0 @@
-module Textus
-  module Key
-    module Grammar
-      SEGMENT = /\A[a-z0-9][a-z0-9-]*\z/
-      MAX_SEGMENTS = 8
-      MAX_SEGMENT_LEN = 64
-
-      module_function
-
-      def validate!(key) # rubocop:disable Naming/PredicateMethod
-        raise UsageError.new("key must be a String") unless key.is_a?(String)
-        raise UsageError.new("empty key") if key.empty?
-
-        segs = key.split(".")
-        raise UsageError.new("key '#{key}' has #{segs.length} segments (max #{MAX_SEGMENTS})") if segs.length > MAX_SEGMENTS
-
-        segs.each do |seg|
-          if seg.empty?
-            raise UsageError.new("empty segment in key '#{key}'")
-          elsif seg.length > MAX_SEGMENT_LEN
-            raise UsageError.new("segment '#{seg}' in key '#{key}' exceeds #{MAX_SEGMENT_LEN} chars")
-          elsif !seg.match?(SEGMENT)
-            raise UsageError.new(
-              "invalid key segment '#{seg}' in '#{key}': must match [a-z0-9][a-z0-9-]* " \
-              "(lowercase, digits, hyphens; no underscores or uppercase)",
-            )
-          end
-        end
-        true
-      end
-    end
-  end
-end

data/lib/textus/key/matching.rb

@@ -1,24 +0,0 @@
-module Textus
-  module Key
-    # Dotted-key scope matching, shared by all prefix-scoped sweeps
-    # (WS4 / ADR 0089-era cleanup). Canonicalised here so every consumer
-    # uses a consistent dotted-boundary check with proper Nested ancestor
-    # handling. ADR 0093: Produce is the sole engine calling this.
-    module Matching
-      module_function
-
-      # Is `key` within the `prefix` scope?
-      #   - exact match, or a dotted descendant (the `prefix.` boundary, so
-      #     prefix "art" does NOT match key "artifacts"), and
-      #   - for a nested entry, also when `prefix` descends INTO it — the nested
-      #     parent owns the leaf the prefix names (e.g. prefix
-      #     "feeds.machines.host1" still selects the nested entry
-      #     "feeds.machines").
-      def matches_prefix?(key, prefix, nested: false)
-        return true if key == prefix || key.start_with?("#{prefix}.")
-
-        nested && prefix.start_with?("#{key}.")
-      end
-    end
-  end
-end

data/lib/textus/key/path.rb

@@ -1,28 +0,0 @@
-module Textus
-  module Key
-    module Path
-      # Returns the absolute filesystem path for a manifest entry (the leaf file,
-      # not a nested directory). Adds the format's primary extension when the
-      # manifest entry's `path:` is extensionless.
-      #
-      # The first argument is a Manifest::Data (or anything responding to .root);
-      # callers historically passed the whole Manifest but should now pass
-      # `manifest.data`.
-      def self.resolve(data, mentry)
-        primary_ext = Format.for(mentry.format).extensions.first
-        rel_path = normalize_relative_path(mentry.path)
-        if File.extname(mentry.path) == ""
-          File.join(data.root, rel_path + primary_ext)
-        else
-          File.join(data.root, rel_path)
-        end
-      end
-
-      def self.normalize_relative_path(path)
-        return path if path.start_with?("data/")
-
-        File.join("data", path)
-      end
-    end
-  end
-end