samagotchi 0.151.0 → 0.152.0

data/lib/samagotchi/memory_bundle/file_standing.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "digest"
 require "time"
+require_relative "file_digest"
 
 module Samagotchi
   module MemoryBundle
@@ -156,7 +156,7 @@ module Samagotchi
       # read isn't known to be level. No digest (an older mark): it isn't known
       # either, and a retry would have settled it.
       def differs?(path, incoming_sha)
-        incoming_sha.nil? || Digest::SHA256.file(path).hexdigest != incoming_sha
+        incoming_sha.nil? || FileDigest.hex(path) != incoming_sha
       rescue SystemCallError
         true
       end

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "digest"
 require "json"
+require_relative "file_digest"
 require_relative "../memory_paths"
 require_relative "bundle_hook"
 require_relative "plugin_ref"
@@ -10,11 +10,15 @@ module Samagotchi
   module MemoryBundle
     # Only what reports on an edited file needs it.
     autoload :FileStanding, File.expand_path("file_standing", __dir__)
+    autoload :InstalledManifest, File.expand_path("installed_manifest", __dir__)
 
     # An installed bundle's record, as Provenance#write keeps it in
-    # <bundles>/<name>/manifest.json. Reading is tolerant: an older record
-    # lacks keys a newer chi writes, and a key that is missing or of the
-    # wrong shape reads as empty (nil for the optional strings and lists).
+    # <bundles>/<name>/manifest.json: identity, shas, files and marks.
+    # Reading is tolerant: an older record lacks keys a newer chi writes,
+    # and a key that is missing or of the wrong shape reads as empty (nil
+    # for the optional strings and lists). Its manifest data (requires_chi,
+    # trust_level, needs, providers, renderers, settings…) is read through
+    # #manifest, never off the record.
     #
     #   files       file key ("x.md") => { checksum:, conflict:, incoming_sha:, legacy_base:, why:, missed:, missed_places:,
     #               description: } (symbol keys);
@@ -26,32 +30,36 @@ module Samagotchi
     #   guardrails  basename => recorded sha256 ("" when none)
     #   scripts     file name => recorded sha256 ("" when none)
     #   plugin      PluginRef, nil without one
-    #   needs, context_providers, block_renderers
-    #               the lists as recorded (nil when absent): Manifest.parse_needs,
-    #               ContextProviders.parse_list and BlockRenderers.parse_list check them
     #   includes    a profile's recorded members, nil for a plain bundle
-    #   session_settings
-    #               the keys a session may set (chi --set), [] when none
-    #   session_setting_types
-    #               {key => type} for the typed ones (Manifest::SESSION_SETTING_TYPES), {} when none
-    #   settings    the keys config.yml bundles: <name>: may have, nil when the
-    #               manifest says nothing of them (BundleSettingsCheck)
-    #   setting_types
-    #               {key => type} for the typed ones, {} when none
+    #   mirror      the record's frozen copy of the manifest keys (MIRROR_KEYS,
+    #               string keys, the values as recorded), which only
+    #               InstalledManifest reads: requires_chi, trust_level, needs,
+    #               context_providers, block_renderers, session_settings,
+    #               session_setting_types, settings, setting_types. A key a
+    #               later manifest gains is never mirrored
     #   dev         a dev install (`chi bundle install --dev`): its source is
     #               the folder it links to and its files carry Provenance::DEV_SHA
+    #   manifest_sha  the kept manifest.yml's recorded sha256 (Provenance::DEV_SHA
+    #               for a dev install's link), nil on a record written before
+    #               chi kept it, or rewritten since by a chi that doesn't
+    #   installed_by  the chi VERSION that wrote the record with its kept
+    #               manifest, nil when manifest_sha is
+    #   dir         its .bundles/<name> folder (.read, Provenance.each_installed),
+    #               nil for a record parsed alone or one that doesn't read
     #   error       why manifest.json couldn't be read (the rest empty), else nil
-    class InstalledBundle < Data.define(:name, :version, :scope, :source, :installed_at, :trust_level, :source_commit,
-                                        :requires_chi, :files, :hooks, :guardrails, :scripts, :plugin, :needs,
-                                        :includes, :context_providers, :block_renderers, :session_settings, :session_setting_types, :settings,
-                                        :setting_types, :dev,
-                                        :error)
-      OPTIONAL = { version: nil, scope: nil, source: nil, installed_at: nil, trust_level: nil, source_commit: nil,
-                   requires_chi: nil, files: {}, hooks: {}, guardrails: {}, scripts: {}, plugin: nil, needs: nil,
-                   includes: nil, context_providers: nil, block_renderers: nil, session_settings: [], session_setting_types: {}, settings: nil, setting_types: {}, dev: false,
-                   error: nil }.freeze
+    class InstalledBundle < Data.define(:name, :version, :scope, :source, :installed_at, :source_commit, :files, :hooks,
+                                        :guardrails, :scripts, :plugin, :includes, :dev, :mirror, :manifest_sha,
+                                        :installed_by, :dir, :error)
+      OPTIONAL = { version: nil, scope: nil, source: nil, installed_at: nil, source_commit: nil, files: {}, hooks: {},
+                   guardrails: {}, scripts: {}, plugin: nil, includes: nil, dev: false, mirror: {}, manifest_sha: nil,
+                   installed_by: nil, dir: nil, error: nil }.freeze
+
+      # The manifest keys a record mirrors, as Provenance#write records them.
+      MIRROR_KEYS = %w[requires_chi trust_level needs context_providers block_renderers session_settings
+                       session_setting_types settings setting_types].freeze
 
       def initialize(name:, **fields)
+        fields[:mirror] = fields[:mirror].to_h.transform_keys(&:to_s).slice(*MIRROR_KEYS).freeze if fields.key?(:mirror)
         super(name: name, **OPTIONAL, **fields)
       end
 
@@ -66,7 +74,7 @@ module Samagotchi
       def self.read(name, path)
         return nil unless File.exist?(path)
 
-        parse(name, JSON.parse(File.read(path)))
+        parse(name, JSON.parse(File.read(path)), File.dirname(path))
       end
 
       # One that couldn't be read: +message+ says why.
@@ -74,25 +82,21 @@ module Samagotchi
 
       # @param raw [Hash] the parsed manifest.json (string or symbol keys);
       #   anything else reads as unreadable
-      def self.parse(name, raw)
+      # @param dir [String, nil] its .bundles/<name> folder
+      def self.parse(name, raw, dir = nil)
         return unreadable(name, "manifest.json is not an object") unless raw.is_a?(Hash)
 
         h = raw.transform_keys(&:to_s)
         new(name: name, version: string(h["version"]), scope: string(h["scope"]), source: string(h["source"]),
-            installed_at: string(h["installed_at"]), trust_level: string(h["trust_level"]),
-            source_commit: string(h["source_commit"]), requires_chi: string(h["requires_chi"]),
+            installed_at: string(h["installed_at"]), source_commit: string(h["source_commit"]),
             files: mapping(h["files"]) { |entry| entry.is_a?(Hash) ? entry.transform_keys(&:to_sym) : {} },
             hooks: mapping(h["hooks"]) { |meta| BundleHook.parse(meta) },
             guardrails: mapping(h["guardrails"]) { |meta| sha(meta) },
             scripts: mapping(h["scripts"]) { |meta| sha(meta) },
-            plugin: PluginRef.parse(h["plugin"]), needs: h["needs"], context_providers: h["context_providers"],
-            block_renderers: h["block_renderers"],
+            plugin: PluginRef.parse(h["plugin"]),
             includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil,
-            session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [],
-            session_setting_types: mapping(h["session_setting_types"]) { |type| type.to_s },
-            settings: h["settings"].is_a?(Array) ? h["settings"].map(&:to_s) : nil,
-            setting_types: mapping(h["setting_types"]) { |type| type.to_s },
-            dev: h["dev"] == true)
+            dev: h["dev"] == true, mirror: h.slice(*MIRROR_KEYS).compact,
+            manifest_sha: string(h["manifest_sha"]), installed_by: string(h["installed_by"]), dir: dir)
       end
 
       def self.string(value) = value&.to_s
@@ -106,12 +110,24 @@ module Samagotchi
 
       def error? = !error.nil?
 
+      # Its kept manifest.yml (Provenance#kept_manifest_path), nil with no dir.
+      def kept_manifest_path = dir && File.join(dir, "manifest.yml")
+
+      # Whether it lacks a kept manifest.yml chi can read (Provenance#adopt_manifest
+      # keeps one): an older chi's record has no manifest_sha (with or without a
+      # file there, InstalledManifest's legacy and :stale), or the file it
+      # recorded is gone (:missing). false with no dir.
+      def manifest_unkept? = !dir.nil? && (manifest_sha.to_s.empty? || !File.file?(kept_manifest_path))
+
+      # What its manifest says (requires_chi, hook metadata, needs, providers,
+      # renderers, settings…): the one way to read manifest data of an
+      # installed bundle.
+      # @return [InstalledManifest]
+      def manifest = InstalledManifest.of(self)
+
       # The scope its files went to: "system" when none is recorded.
       def effective_scope = scope.to_s.strip.empty? ? "system" : scope
 
-      # A bundle with no trust_level counts as experimental.
-      def experimental? = (trust_level || "experimental") == "experimental"
-
       # A profile (meta bundle): it records its members.
       def profile? = !includes.nil?
 
@@ -155,18 +171,11 @@ module Samagotchi
       end
 
       def source_sha(key)
-        path = File.join(source.to_s, key)
-        File.file?(path) ? Digest::SHA256.file(path).hexdigest : nil
+        FileDigest.hex(File.join(source.to_s, key))
       rescue SystemCallError
         nil
       end
       private :source_sha
-
-      def needs? = needs.is_a?(Array) && !needs.empty?
-
-      def context_providers? = context_providers.is_a?(Array) && !context_providers.empty?
-
-      def block_renderers? = block_renderers.is_a?(Array) && !block_renderers.empty?
     end
   end
 end

data/lib/samagotchi/memory_bundle/installed_copy.rb

@@ -1,19 +1,26 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "json"
 require "tmpdir"
+require "yaml"
 require_relative "bundle_hook"
 require_relative "manifest"
 require_relative "provenance"
 
 module Samagotchi
   module MemoryBundle
-    # An installed bundle laid out as a source folder again: manifest.yml from
-    # its record, the plugin, hooks, rules and scripts as they are installed
-    # (a dev install's links followed), the memories as their bases (the
-    # bundle's bytes, not the user's edits). A bundle's source may be gone or
-    # be a URL; this is what `chi update` can check of what really runs.
+    # An installed bundle laid out as a source folder again: the plugin, hooks,
+    # rules and scripts as they are installed (a dev install's links
+    # followed), the memories as their bases (the bundle's bytes, not the
+    # user's edits). A bundle's source may be gone or be a URL; this is what
+    # `chi update` can check of what really runs.
+    #
+    # manifest.yml: its files:, hooks:, plugin: and scripts: are the record's
+    # and the copy's (what is installed: a memory the install left out, or one
+    # with no base, and a manifest hook the record lacks aren't listed, so the
+    # check finds no missing-file for them). Every other key is the kept
+    # manifest.yml's when it is read (InstalledManifest origin :kept), so the
+    # check sees its unknown keys too; else the record's mirror's.
     #
     # The shas are the files' own, so an edited plugin is checked as written.
     # A plugin, hook or script the record lists that isn't there stays
@@ -33,23 +40,38 @@ module Samagotchi
       end
 
       def write(bundle, provenance, dir)
+        manifest = bundle.manifest
         Manifest.write(
-          dir: dir, name: bundle.name, version: bundle.version.to_s.empty? ? "0" : bundle.version, trust_level: bundle.trust_level,
+          dir: dir, name: bundle.name, version: bundle.version.to_s.empty? ? "0" : bundle.version, trust_level: manifest.trust_level,
           files: memories(bundle, provenance, dir),
-          file_descriptions: bundle.files.to_h { |key, entry| [key, entry[:description].to_s] },
+          file_descriptions: manifest.file_descriptions,
           hooks: hooks(bundle, provenance, dir), plugin: plugin(bundle, provenance, dir),
           scripts: copies(bundle.scripts, provenance.scripts_dir, File.join(dir, "scripts")),
-          requires_chi: bundle.requires_chi, needs: bundle.needs,
-          # A record read with symbol keys: back to what a manifest.yml holds.
-          context_providers: JSON.parse(JSON.generate(Array(bundle.context_providers))),
-          block_renderers: JSON.parse(JSON.generate(Array(bundle.block_renderers))),
-          session_settings: bundle.session_settings, session_setting_types: bundle.session_setting_types,
-          settings: bundle.settings, setting_types: bundle.setting_types
+          requires_chi: manifest.requires_chi, needs: manifest.needs,
+          context_providers: manifest.context_providers, block_renderers: manifest.block_renderers,
+          session_settings: manifest.session_settings, session_setting_types: manifest.session_setting_types,
+          settings: manifest.settings, setting_types: manifest.setting_types
         )
+        keep_manifest_keys(bundle.kept_manifest_path, File.join(dir, "manifest.yml"), manifest.key_problems.keys) if manifest.origin == :kept
         copies(bundle.guardrails, provenance.guardrails_dir, File.join(dir, "guardrails"))
       end
       private_class_method :write
 
+      # What is installed, which the copy's manifest.yml takes from the record.
+      INSTALLED_KEYS = %w[name version files hooks plugin scripts].freeze
+
+      # The written manifest's INSTALLED_KEYS and +failed+ keys (the value
+      # InstalledManifest fell back to: InstalledCheck already names the
+      # problem, and the raw value would name it again), then the kept
+      # manifest's other keys. A kept file of comments only holds none.
+      def keep_manifest_keys(kept, written, failed)
+        ours = YAML.load_file(written)
+        theirs = YAML.load_file(kept) || {}
+        own = INSTALLED_KEYS + failed
+        File.write(written, YAML.dump(ours.slice(*own).merge(theirs.except(*own))))
+      end
+      private_class_method :keep_manifest_keys
+
       # A memory with no base has nothing to install, so it isn't listed.
       def memories(bundle, provenance, dir)
         bundle.files.keys.select { |key| File.file?(provenance.base_path(key)) }.to_h do |key|
@@ -58,8 +80,9 @@ module Samagotchi
       end
       private_class_method :memories
 
+      # The recorded hooks with the metadata they load with (InstalledManifest#hooks).
       def hooks(bundle, provenance, dir)
-        bundle.hooks.to_h do |file, hook|
+        bundle.manifest.hooks.to_h do |file, hook|
           sha = copy(File.join(provenance.hooks_dir, file), File.join(dir, "hooks", file), hook.sha256)
           [file, hook.with(sha256: sha)]
         end

data/lib/samagotchi/memory_bundle/installed_manifest.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative "../context_providers"
+require_relative "../version"
+require_relative "manifest"
+require_relative "provenance"
+
+module Samagotchi
+  autoload :BlockRenderers, File.expand_path("../block_renderers", __dir__)
+
+  module MemoryBundle
+    # The one answer to "this installed bundle's manifest": what its
+    # manifest.yml says, as the readers of an installed bundle take it
+    # (InstalledBundle#manifest). Identity and state stay on the record
+    # (InstalledBundle: name, version, source, the plugin's file, every
+    # sha, files, marks, a profile's members); manifest data is read here.
+    #
+    # Read from the bundle's kept manifest.yml (.bundles/<name>/manifest.yml,
+    # Provenance#write's manifest_from:) when the record has its sha and the
+    # file still has it (a dev install's link is never checked): origin
+    # :kept, so a key the record never mirrored (one an older chi didn't
+    # know) is read. Otherwise from the record's frozen mirror of the
+    # manifest keys (origin :record), in four cases:
+    #   no kept file, no manifest_sha a record from before chi kept it; no problem
+    #   no kept file, a manifest_sha  problems["manifest.yml"] = :missing (it was
+    #                                 removed, or something else is in its place)
+    #   kept, no manifest_sha         problems["manifest.yml"] = :stale (a chi
+    #                                 without the kept manifest rewrote the record;
+    #                                 the file may be an earlier version's)
+    #   kept, another sha, or not a   problems["manifest.yml"] = :edited
+    #   YAML mapping
+    #   kept, its sha                 origin :kept
+    # Each key is parsed on its own (Manifest.tolerant for the kept file): one
+    # that doesn't parse reads as the mirror's value if that parses, else as
+    # empty, and its message is in +problems+ (key => message), so one bad key
+    # never costs the rest. A reader that logged such a key logs problems[key].
+    # Built once per record and kept file (a process-wide cache keyed by the
+    # record and the file's stat): chi web asks per request.
+    #
+    #   requires_chi, trust_level   the strings as recorded, nil when none
+    #   description                 the kept manifest's, nil from the record
+    #   hooks                       basename => BundleHook: each recorded hook,
+    #                               the kept manifest's events, on_error and
+    #                               priority with the record's sha
+    #   needs                       Manifest.parse_needs'
+    #   script_names                the scripts/ files it lists
+    #   context_providers           Array<ContextProviders::Provider>
+    #   block_renderers             Array<BlockRenderers::Renderer>
+    #   session_settings, session_setting_types, settings, setting_types
+    #                               as Manifest reads them (settings nil when
+    #                               the manifest said nothing of them)
+    #   file_descriptions           file key => the memory's description
+    #   includes                    a profile's recorded members (the record's
+    #                               identity, never the kept file's), nil for a plain bundle
+    #   unknown_keys                the kept manifest's keys this chi doesn't know
+    #   floor_keys                  the kept manifest's Manifest#floor_keys (key =>
+    #                               the first chi that read it), {} from the record
+    #   origin                      :kept or :record
+    class InstalledManifest < Data.define(:name, :version, :requires_chi, :trust_level, :description, :hooks, :needs,
+                                          :script_names, :context_providers, :block_renderers, :session_settings,
+                                          :session_setting_types, :settings, :setting_types, :file_descriptions,
+                                          :includes, :unknown_keys, :floor_keys, :problems, :origin)
+      # The key problems names the kept file's standing under.
+      KEPT_FILE = "manifest.yml"
+      # How many manifests the cache holds before it starts again.
+      CACHE_LIMIT = 256
+      @cache = {}
+      @cache_lock = Mutex.new
+
+      # @param bundle [InstalledBundle]
+      # @return [InstalledManifest]
+      def self.of(bundle)
+        key = [bundle, kept_stat(bundle.kept_manifest_path)]
+        cached = @cache_lock.synchronize { @cache[key] }
+        return cached if cached
+
+        built = deep_freeze(build(bundle))
+        @cache_lock.synchronize do
+          @cache.clear if @cache.size >= CACHE_LIMIT
+          @cache[key] = built
+        end
+      end
+
+      # Callers share the cached value, so nothing in it can change under another.
+      def self.deep_freeze(value)
+        case value
+        when Hash then value.each { |key, item| deep_freeze(key) && deep_freeze(item) }
+        when Array then value.each { |item| deep_freeze(item) }
+        when Data then value.to_h.each_value { |item| deep_freeze(item) }
+        end
+        value.freeze
+      end
+
+      # What says the kept file changed: nil when there is none.
+      def self.kept_stat(path)
+        stat = path && File.stat(path)
+        stat && [stat.mtime.to_r, stat.size, stat.ino, stat.dev]
+      rescue SystemCallError
+        nil
+      end
+
+      def self.build(bundle)
+        mirrored = from_record(bundle)
+        path = bundle.kept_manifest_path
+        return mirrored unless path
+
+        recorded = !bundle.manifest_sha.to_s.empty?
+        return recorded ? standing(mirrored, :missing) : mirrored unless File.file?(path)
+        return standing(mirrored, :stale) unless recorded
+        return standing(mirrored, :edited) unless Provenance.sha_matches?(path, bundle.manifest_sha)
+
+        kept, problems = Manifest.tolerant(path: path, fallback_scripts: bundle.scripts.keys)
+        from_kept(bundle, kept, problems, mirrored)
+      rescue Manifest::ValidationError, SystemCallError, EncodingError
+        standing(mirrored, :edited)
+      end
+
+      def self.standing(mirrored, why) = mirrored.with(problems: mirrored.problems.merge(KEPT_FILE => why).freeze)
+
+      # The kept manifest's values; a key that failed takes the mirror's.
+      def self.from_kept(bundle, kept, problems, mirrored)
+        pick = ->(key, ours, theirs) { problems.key?(key) ? theirs : ours }
+        session = pick.call("session_settings", kept, mirrored)
+        settings = pick.call("settings", kept, mirrored)
+        new(name: bundle.name, version: bundle.version,
+            requires_chi: pick.call("requires_chi", kept.requires_chi, mirrored.requires_chi),
+            trust_level: kept.trust_level, description: kept.description.empty? ? nil : kept.description,
+            hooks: pick.call("hooks", kept_hooks(bundle.hooks, kept.hooks), bundle.hooks),
+            needs: pick.call("needs", kept.needs, mirrored.needs),
+            script_names: pick.call("scripts", kept.scripts.keys, mirrored.script_names),
+            context_providers: pick.call("context_providers", kept.context_providers, mirrored.context_providers),
+            block_renderers: pick.call("block_renderers", kept.block_renderers, mirrored.block_renderers),
+            session_settings: session.session_settings, session_setting_types: session.session_setting_types,
+            settings: settings.settings, setting_types: settings.setting_types,
+            file_descriptions: pick.call("files", kept.file_descriptions, mirrored.file_descriptions),
+            includes: bundle.includes,
+            unknown_keys: kept.unknown_keys.map(&:to_s), floor_keys: floors(kept), problems: problems.freeze, origin: :kept)
+      end
+
+      # Manifest#floor_keys of the tolerant read; a shape it can't tell is no floor.
+      def self.floors(kept)
+        kept.floor_keys
+      rescue StandardError
+        {}
+      end
+
+      # Each recorded hook (what is installed): the kept manifest's metadata
+      # for it with the record's sha; one the manifest doesn't list (a found
+      # hooks/*.rb) as recorded. A manifest hook the record lacks isn't installed.
+      def self.kept_hooks(recorded, declared)
+        recorded.to_h do |file, hook|
+          [file, declared.key?(file) ? declared[file].with(sha256: hook.sha256) : hook]
+        end
+      end
+
+      def self.from_record(bundle)
+        raw = recorded(bundle)
+        problems = {}
+        new(name: bundle.name, version: bundle.version,
+            requires_chi: raw["requires_chi"]&.to_s, trust_level: raw["trust_level"]&.to_s, description: nil,
+            hooks: bundle.hooks,
+            needs: parsed(problems, "needs", [], Manifest::ValidationError) { Manifest.parse_needs(raw["needs"]) },
+            script_names: bundle.scripts.keys,
+            context_providers: parsed(problems, "context_providers", []) { ContextProviders.parse_list(raw["context_providers"]) },
+            block_renderers: parsed(problems, "block_renderers", []) { BlockRenderers.parse_list(raw["block_renderers"]) },
+            session_settings: list(raw["session_settings"]) || [],
+            session_setting_types: types(raw["session_setting_types"]),
+            settings: list(raw["settings"]),
+            setting_types: types(raw["setting_types"]),
+            file_descriptions: file_descriptions(bundle.files),
+            includes: bundle.includes, unknown_keys: [], floor_keys: {}, problems: problems.freeze, origin: :record)
+      end
+
+      # The record's values of the manifest keys (its frozen mirror), string
+      # keys: what a bundle with no usable kept manifest, or no dir (a record
+      # parsed alone), reads.
+      def self.recorded(bundle) = bundle.mirror
+
+      # The block's value, else +empty+ with the key's problem noted.
+      # ArgumentError: ContextProviders::Invalid and BlockRenderers::Invalid
+      # are ones; EncodingError: a record's string whose bytes aren't UTF-8
+      # (JSON keeps them) raises Encoding::CompatibilityError when parsed.
+      def self.parsed(problems, key, empty, *errors)
+        yield
+      rescue ArgumentError, EncodingError, *errors => e
+        problems[key] = e.message
+        empty
+      end
+
+      def self.list(value) = value.is_a?(Array) ? value.map(&:to_s) : nil
+
+      def self.types(value) = value.is_a?(Hash) ? value.to_h { |key, type| [key.to_s, type.to_s] } : {}
+
+      def self.file_descriptions(files)
+        files.each_with_object({}) do |(key, entry), acc|
+          text = entry[:description].to_s
+          acc[key] = text unless text.empty?
+        end
+      end
+      private_class_method :deep_freeze, :kept_stat, :build, :standing, :from_kept, :floors, :kept_hooks, :from_record, :recorded, :parsed,
+                           :list, :types, :file_descriptions
+
+      # Why the kept manifest.yml wasn't read: :missing, :stale or :edited (the class
+      # comment's cases), nil when it was or there is none.
+      def standing = problems[KEPT_FILE]
+
+      # The keys that didn't parse, key => message, without the kept file's standing.
+      def key_problems = problems.except(KEPT_FILE)
+
+      # Why chi +version+ can't load this bundle, nil when it can (or it
+      # names no requirement): the one requires_chi gate.
+      def requires_chi_failure(version = Samagotchi::VERSION) = Manifest.requires_chi_failure(requires_chi, version)
+
+      # A bundle with no trust_level counts as experimental.
+      def experimental? = (trust_level || "experimental") == "experimental"
+
+      def needs? = !needs.empty?
+
+      def context_providers? = !context_providers.empty?
+
+      def block_renderers? = !block_renderers.empty?
+    end
+  end
+end