textus 0.14.4 → 0.18.0

data/lib/textus/hooks/builtin.rb

@@ -7,22 +7,22 @@ module Textus
   module Hooks
     module Builtin
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def self.register_all
-        Textus.on(:resolve_intake, :json) do |store:, config:, args:|
+      def self.register_all(registry)
+        registry.on(:resolve_intake, :json) do |store:, config:, args:|
           _ = store
           _ = args
           data = JSON.parse(config["bytes"].to_s)
           { _meta: {}, body: YAML.dump(data) }
         end
 
-        Textus.on(:resolve_intake, :csv) do |store:, config:, args:|
+        registry.on(:resolve_intake, :csv) do |store:, config:, args:|
           _ = store
           _ = args
           rows = CSV.parse(config["bytes"].to_s, headers: true).map(&:to_h)
           { _meta: {}, body: YAML.dump(rows) }
         end
 
-        Textus.on(:resolve_intake, :"markdown-links") do |store:, config:, args:|
+        registry.on(:resolve_intake, :"markdown-links") do |store:, config:, args:|
           _ = store
           _ = args
           links = config["bytes"].to_s.scan(%r{\[([^\]]+)\]\((https?://[^)\s]+)\)}).map do |text, href|
@@ -31,7 +31,7 @@ module Textus
           { _meta: {}, body: YAML.dump(links) }
         end
 
-        Textus.on(:resolve_intake, :"ical-events") do |store:, config:, args:|
+        registry.on(:resolve_intake, :"ical-events") do |store:, config:, args:|
           _ = store
           _ = args
           events = []
@@ -50,7 +50,7 @@ module Textus
           { _meta: {}, body: YAML.dump(events) }
         end
 
-        Textus.on(:resolve_intake, :rss) do |store:, config:, args:|
+        registry.on(:resolve_intake, :rss) do |store:, config:, args:|
           _ = store
           _ = args
           doc = REXML::Document.new(config["bytes"].to_s)

data/lib/textus/hooks/dispatcher.rb

@@ -7,9 +7,15 @@ module Textus
     class Dispatcher
       HOOK_TIMEOUT_SECONDS = 2
 
-      def initialize(audit_log:)
-        @audit_log = audit_log
+      def initialize
         @subscribers = Hash.new { |h, k| h[k] = [] }
+        @error_handlers = []
+      end
+
+      # Register an error callback invoked when a user hook raises.
+      # Used by Infra::AuditSubscriber to record an "event_error" audit row.
+      def on_error(&block)
+        @error_handlers << block
       end
 
       def subscribe(event, name, keys: nil, &block)
@@ -31,13 +37,15 @@ module Textus
         accepted = filter_kwargs(sub[:callable], kwargs)
         Timeout.timeout(HOOK_TIMEOUT_SECONDS) { sub[:callable].call(**accepted) }
       rescue StandardError => e
-        extras = { "event" => event.to_s, "hook" => sub[:name].to_s, "error" => "#{e.class}: #{e.message}" }
-        extras["target_key"]  = kwargs[:target_key]  if kwargs.key?(:target_key)
-        extras["pending_key"] = kwargs[:pending_key] if kwargs.key?(:pending_key)
-        @audit_log.append(
-          role: "runner", verb: "event_error", key: key,
-          etag_before: nil, etag_after: nil, extras: extras
-        )
+        notify_error(event, sub, key, kwargs, e)
+      end
+
+      def notify_error(event, sub, key, kwargs, error)
+        @error_handlers.each do |handler|
+          handler.call(event: event, hook: sub[:name], key: key, kwargs: kwargs, error: error)
+        rescue StandardError => e
+          warn "[textus] error handler failed: #{e.class}: #{e.message}"
+        end
       end
 
       # Passes only the kwargs a hook block declares. Lets us extend event

data/lib/textus/hooks/loader.rb

@@ -1,25 +1,28 @@
 module Textus
   module Hooks
-    module Loader
-      THREAD_REGISTRY_KEY = :__textus_active_registry__
-      private_constant :THREAD_REGISTRY_KEY
-
-      def self.with_registry(registry)
-        prev = Thread.current[THREAD_REGISTRY_KEY]
-        Thread.current[THREAD_REGISTRY_KEY] = registry
-        yield
-      ensure
-        Thread.current[THREAD_REGISTRY_KEY] = prev
+    class Loader
+      def initialize(registry:)
+        @registry = registry
       end
 
-      def self.current_registry
-        Thread.current[THREAD_REGISTRY_KEY] or
-          raise UsageError.new("no active registry; hook code must be loaded by a Store")
+      def load_dir(dir)
+        return unless File.directory?(dir)
+
+        # Discard any leftover blocks from a prior partial load.
+        Textus.drain_hook_blocks
+
+        Dir.glob(File.join(dir, "**/*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
+          load(f)
+        rescue StandardError, ScriptError => e
+          raise UsageError.new("failed loading hook #{File.basename(f)}: #{e.class}: #{e.message}")
+        end
+
+        Textus.drain_hook_blocks.each do |blk|
+          blk.call(@registry)
+        rescue StandardError, ScriptError => e
+          raise UsageError.new("failed registering hook: #{e.class}: #{e.message}")
+        end
       end
     end
   end
-
-  # Public DSL
-  def self.with_registry(registry, &) = Hooks::Loader.with_registry(registry, &)
-  def self.current_registry           = Hooks::Loader.current_registry
 end

data/lib/textus/hooks/registry.rb

@@ -28,6 +28,10 @@ module Textus
         @dispatcher = dispatcher
       end
 
+      def on(event, name, keys: nil, &)
+        register(event, name, keys: keys, &)
+      end
+
       def register(event, name, keys: nil, &blk)
         event_sym = event.to_sym
         spec = EVENTS[event_sym] or raise UsageError.new("unknown event: #{event}")

data/lib/textus/{store → infra}/audit_log.rb

@@ -2,7 +2,7 @@ require "json"
 require "time"
 
 module Textus
-  class Store
+  module Infra
     class AuditLog
       def initialize(root)
         @path = File.join(root, "audit.log")

data/lib/textus/infra/audit_subscriber.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Textus
+  module Infra
+    # Writes an "event_error" audit row when a user hook raises during
+    # Hooks::Dispatcher publish. Attached at Store boot.
+    #
+    # Integration: uses Hooks::Dispatcher#on_error callback (chosen over a
+    # synthetic :hook_error event because the dispatcher already owns the
+    # rescue and the failure is a dispatcher-internal concern, not a domain
+    # event subscribers should be able to filter by key glob).
+    #
+    # NOTE (0.16 scope): lifecycle audit rows for verb: "put" / "delete" /
+    # "rename" are still written directly by Store::Writer and
+    # Application::Writes::Mv. Moving those into this subscriber requires
+    # event payloads to carry etag_before/etag_after across many write paths;
+    # that is properly a 0.18 port-extraction concern.
+    class AuditSubscriber
+      def initialize(audit_log)
+        @audit_log = audit_log
+      end
+
+      def attach(bus)
+        bus.on_error do |event:, hook:, key:, kwargs:, error:|
+          record_error(event: event, hook: hook, key: key, kwargs: kwargs, error: error)
+        end
+        self
+      end
+
+      private
+
+      def record_error(event:, hook:, key:, kwargs:, error:)
+        extras = { "event" => event.to_s, "hook" => hook.to_s, "error" => "#{error.class}: #{error.message}" }
+        extras["target_key"]  = kwargs[:target_key]  if kwargs.key?(:target_key)
+        extras["pending_key"] = kwargs[:pending_key] if kwargs.key?(:pending_key)
+        @audit_log.append(
+          role: "runner", verb: "event_error", key: key,
+          etag_before: nil, etag_after: nil, extras: extras
+        )
+      end
+    end
+  end
+end

data/lib/textus/infra/publisher.rb

@@ -6,7 +6,7 @@ module Textus
     # Publish = copy + sentinel. The in-store file is already the consumer-shaped
     # artifact; no parsing or stripping.
     #
-    # Sentinel I/O is delegated to Store::Sentinel. Sentinels live under
+    # Sentinel I/O is delegated to Textus::Domain::Sentinel. Sentinels live under
     # `<store_root>/sentinels/` and mirror the target's repo-relative layout so
     # consumer directories aren't polluted with `.textus-managed.json` siblings.
     module Publisher
@@ -15,7 +15,7 @@ module Textus
         refuse_if_unmanaged(target, store_root)
         File.delete(target) if File.symlink?(target)
         FileUtils.cp(source, target)
-        Store::Sentinel.write!(target: target, source: source, store_root: store_root)
+        Textus::Domain::Sentinel.write!(target: target, source: source, store_root: store_root)
       end
 
       def self.refuse_if_unmanaged(target, store_root)
@@ -26,7 +26,7 @@ module Textus
       end
 
       def self.managed?(target, store_root)
-        File.exist?(Store::Sentinel.sentinel_path(target, store_root))
+        File.exist?(Textus::Domain::Sentinel.sentinel_path(target, store_root))
       end
     end
   end

data/lib/textus/infra/storage/file_store.rb

@@ -0,0 +1,26 @@
+require "fileutils"
+
+module Textus
+  module Infra
+    module Storage
+      # Pure filesystem I/O port. Wraps File/FileUtils/Etag with no knowledge
+      # of envelopes, entries, schemas, or audit.
+      class FileStore
+        def read(path) = File.binread(path)
+
+        def write(path, bytes)
+          FileUtils.mkdir_p(File.dirname(path))
+          File.binwrite(path, bytes)
+        end
+
+        # Raises Errno::ENOENT if absent — mirrors File.delete and matches the
+        # semantics used by Store::Writer (which guards with File.exist? first).
+        def delete(path) = File.delete(path)
+
+        def exists?(path) = File.exist?(path)
+
+        def etag(path) = Etag.for_file(path)
+      end
+    end
+  end
+end

data/lib/textus/init.rb

@@ -28,17 +28,19 @@ module Textus
       ## DSL
 
       ```ruby
-      Textus.on(:resolve_intake, :my_source) do |config:, args:, **|
-        { _meta: { "last_refreshed_at" => Time.now.utc.iso8601 }, body: "…" }
-      end
+      Textus.hook do |reg|
+        reg.on(:resolve_intake, :my_source) do |config:, args:, **|
+          { _meta: { "last_refreshed_at" => Time.now.utc.iso8601 }, body: "…" }
+        end
 
-      Textus.on(:transform_rows, :my_source) { |rows:, **| rows.map { |r| r.merge(processed: true) } }
-      Textus.on(:validate,       :my_check)  { |store:, **| [] }
-      Textus.on(:entry_put,      :my_listener, keys: ["working.*"]) { |key:, envelope:, **| }
+        reg.on(:transform_rows, :my_source) { |rows:, **| rows.map { |r| r.merge(processed: true) } }
+        reg.on(:validate,       :my_check)  { |store:, **| [] }
+        reg.on(:entry_put,      :my_listener, keys: ["working.*"]) { |key:, envelope:, **| }
 
-      # Run a side-effect every time textus writes a file to your repo:
-      Textus.on(:file_published, :notify) do |key:, target:, **|
-        warn "wrote \#{target} (from \#{key})"
+        # Run a side-effect every time textus writes a file to your repo:
+        reg.on(:file_published, :notify) do |key:, target:, **|
+          warn "wrote \#{target} (from \#{key})"
+        end
       end
       ```
 

data/lib/textus/manifest/resolution.rb

@@ -0,0 +1,5 @@
+module Textus
+  class Manifest
+    Resolution = Data.define(:entry, :path, :remaining)
+  end
+end

data/lib/textus/manifest.rb

@@ -1,5 +1,6 @@
 require "yaml"
 require_relative "manifest/schema"
+require_relative "manifest/resolution"
 
 module Textus
   class Manifest
@@ -86,7 +87,7 @@ module Textus
       rules.for(key)
     end
 
-    # Returns [Manifest::Entry, resolved_path, remaining_segments]
+    # Returns a Resolution(entry:, path:, remaining:) value object.
     def resolve(key)
       validate_key!(key)
       segments = key.split(".")
@@ -101,7 +102,7 @@ module Textus
       remaining = segments[esegs.length..]
       if remaining.empty?
         path = resolve_leaf_path(entry)
-        [entry, path, []]
+        Resolution.new(entry: entry, path: path, remaining: [])
       else
         raise UnknownKey.new(key, suggestions: suggestions_for(key)) unless entry.nested
 
@@ -111,7 +112,7 @@ module Textus
                  primary_ext = Textus::Entry.for_format(entry.format).extensions.first
                  File.join(@root, "zones", entry.path, *remaining) + primary_ext
                end
-        [entry, path, remaining]
+        Resolution.new(entry: entry, path: path, remaining: remaining)
       end
     end
 

data/lib/textus/migrate_keys.rb

@@ -112,7 +112,7 @@ module Textus
     # ------------------------------------------------------------------
 
     def apply!(store, renames)
-      audit = Store::AuditLog.new(store.root)
+      audit = Textus::Infra::AuditLog.new(store.root)
       renames.each do |r|
         # Bottom-up order means a child's ancestors haven't moved yet, so
         # `from`/`to` are valid as-recorded. The audit `key` reflects the

data/lib/textus/operations.rb

@@ -1,21 +1,20 @@
 module Textus
   # Single canonical entrypoint for invoking application use-cases against a
-  # store. Mirrors the directory structure under `lib/textus/application/`:
+  # store. Public surface is flat — one method per use case:
   #
   #   ops = Textus::Operations.for(store, role: "agent")
-  #   ops.writes.put.call(key, body: "...")
-  #   ops.reads.get.call(key)
-  #   ops.refresh.worker.call(key)
-  #
-  # Replaces the prior `Textus::Composition` module (deleted in v0.12.2).
+  #   ops.put(key, body: "...")
+  #   ops.get(key)               # pure read
+  #   ops.get_or_refresh(key)    # read + refresh-on-stale
+  #   ops.refresh(key)           # synchronous worker refresh
+  #   ops.refresh_all(prefix: ..., zone: ...)
   class Operations
-    def self.for(store, role: Role::DEFAULT, correlation_id: nil, dry_run: false, bypass_freshness: false)
+    def self.for(store, role: Role::DEFAULT, correlation_id: nil, dry_run: false)
       ctx = Application::Context.new(
         store: store,
         role: role,
         correlation_id: correlation_id,
         dry_run: dry_run,
-        bypass_freshness: bypass_freshness,
       )
       new(ctx)
     end
@@ -26,20 +25,88 @@ module Textus
       @ctx = ctx
     end
 
-    def writes
-      @writes ||= Writes.new(@ctx)
-    end
+    def with_role(role) = self.class.new(@ctx.with_role(role))
+
+    # writes
+    def put(...)     = put_op.call(...)
+    def delete(...)  = delete_op.call(...)
+    def mv(...)      = mv_op.call(...)
+    def accept(...)  = accept_op.call(...)
+    def reject(...)  = reject_op.call(...)
+    def build(...)   = build_op.call(...)
+    def publish(...) = publish_op.call(...)
+
+    # reads
+    def get(...)             = get_op.call(...)
+    def get_or_refresh(...)  = get_or_refresh_op.call(...)
+    def list(...)            = list_op.call(...)
+    def where(...)           = where_op.call(...)
+    def uid(...)             = uid_op.call(...)
+    def schema_envelope(...) = schema_envelope_op.call(...)
+    def deps(...)            = deps_op.call(...)
+    def rdeps(...)           = rdeps_op.call(...)
+    def published(...)       = published_op.call(...)
+    def stale(...)           = stale_op.call(...)
+    def audit(...)           = audit_op.call(...)
+    def blame(...)           = blame_op.call(...)
+    def policy_explain(...)  = policy_explain_op.call(...)
+    def freshness(...)       = freshness_op.call(...)
+    def validate_all(...)    = validate_all_op.call(...)
+
+    # refresh
+    def refresh(key) = refresh_worker_op.run(key)
+    def refresh_all(**) = Application::Refresh::All.call(@ctx, **)
+
+    private
 
-    def reads
-      @reads ||= Reads.new(@ctx)
+    def envelope_io
+      @envelope_io ||= Application::Writes::EnvelopeIO.new(
+        file_store: @ctx.file_store,
+        manifest: @ctx.manifest,
+        schemas: @ctx.schemas,
+        audit_log: @ctx.audit_log,
+        ctx: @ctx,
+      )
     end
 
-    def refresh
-      @refresh ||= Refresh.new(@ctx)
+    def put_op     = @put_op ||= Application::Writes::Put.new(ctx: @ctx, envelope_io: envelope_io)
+    def delete_op  = @delete_op ||= Application::Writes::Delete.new(ctx: @ctx, envelope_io: envelope_io)
+    def mv_op      = @mv_op ||= Application::Writes::Mv.new(ctx: @ctx, envelope_io: envelope_io)
+    def accept_op  = @accept_op ||= Application::Writes::Accept.new(ctx: @ctx, envelope_io: envelope_io)
+    def reject_op  = @reject_op ||= Application::Writes::Reject.new(ctx: @ctx, envelope_io: envelope_io)
+    def build_op   = @build_op ||= Application::Writes::Build.new(ctx: @ctx)
+    def publish_op = @publish_op ||= Application::Writes::Publish.new(ctx: @ctx)
+
+    def get_op = @get_op ||= Application::Reads::Get.new(ctx: @ctx) # rubocop:disable Naming/AccessorMethodName
+
+    def get_or_refresh_op # rubocop:disable Naming/AccessorMethodName
+      @get_or_refresh_op ||= Application::Reads::GetOrRefresh.new(ctx: @ctx, get: get_op,
+                                                                  orchestrator: orchestrator_op)
     end
 
-    def with_role(role)
-      self.class.new(@ctx.with_role(role))
+    def list_op            = @list_op ||= Application::Reads::List.new(ctx: @ctx)
+    def where_op           = @where_op ||= Application::Reads::Where.new(ctx: @ctx)
+    def uid_op             = @uid_op ||= Application::Reads::Uid.new(ctx: @ctx)
+    def schema_envelope_op = @schema_envelope_op ||= Application::Reads::SchemaEnvelope.new(ctx: @ctx)
+    def deps_op            = @deps_op ||= Application::Reads::Deps.new(ctx: @ctx)
+    def rdeps_op           = @rdeps_op ||= Application::Reads::Rdeps.new(ctx: @ctx)
+    def published_op       = @published_op ||= Application::Reads::Published.new(ctx: @ctx)
+    def stale_op           = @stale_op ||= Application::Reads::Stale.new(ctx: @ctx)
+    def audit_op           = @audit_op ||= Application::Reads::Audit.new(ctx: @ctx)
+    def blame_op           = @blame_op ||= Application::Reads::Blame.new(ctx: @ctx)
+    def policy_explain_op  = @policy_explain_op ||= Application::Reads::PolicyExplain.new(ctx: @ctx)
+    def freshness_op       = @freshness_op ||= Application::Reads::Freshness.new(ctx: @ctx)
+    def validate_all_op    = @validate_all_op ||= Application::Reads::ValidateAll.new(ctx: @ctx)
+
+    def refresh_worker_op = @refresh_worker_op ||= Application::Refresh::Worker.new(ctx: @ctx, envelope_io: envelope_io)
+
+    def orchestrator_op
+      @orchestrator_op ||= Application::Refresh::Orchestrator.new(
+        worker: refresh_worker_op,
+        store_root: @ctx.store.root,
+        store: @ctx.store,
+        role: @ctx.role,
+      )
     end
   end
 end

data/lib/textus/projection.rb

@@ -6,10 +6,18 @@ module Textus
     MAX_LIMIT = 1000
     REDUCER_TIMEOUT_SECONDS = 2
 
-    def initialize(store, spec, bypass_freshness: false)
-      @store = store
-      @spec = spec || {}
-      @bypass_freshness = bypass_freshness
+    # `reader` — a callable `->(key) { envelope_or_nil }`. Caller picks
+    #   semantics: pure read (`ops.get`) for materialization paths;
+    #   `ops.get_or_refresh` if you want refresh-on-stale.
+    # `lister` — a callable `->(prefix:) { [ { "key" => ... }, ... ] }`.
+    # `transform_resolver` — a callable `->(name) { callable_or_raise }`.
+    # `transform_context` — `Application::Context` handed to the transform reducer.
+    def initialize(reader:, spec:, lister:, transform_resolver:, transform_context:)
+      @reader             = reader
+      @spec               = spec || {}
+      @lister             = lister
+      @transform_resolver = transform_resolver
+      @transform_context  = transform_context
       @limit = (@spec["limit"] || MAX_LIMIT).to_i
       raise InvalidProjection.new("limit #{@limit} exceeds max #{MAX_LIMIT}") if @limit > MAX_LIMIT
     end
@@ -17,9 +25,8 @@ module Textus
     def run
       keys = collect_keys
       explicit_pluck = !@spec["pluck"].nil? && @spec["pluck"] != "*"
-      ops = Operations.for(@store, bypass_freshness: @bypass_freshness)
       rows = keys.map do |key|
-        env = ops.reads.get.call(key)
+        env = @reader.call(key)
         row = pluck(env.meta, env.body)
         explicit_pluck ? row : row.merge("_key" => key)
       end
@@ -41,10 +48,9 @@ module Textus
 
     def apply_reducer(rows)
       name = @spec["transform"] or return rows
-      callable = @store.registry.rpc_callable(:transform_rows, name)
-      view = Application::Context.system(@store)
+      callable = @transform_resolver.call(name)
       Timeout.timeout(REDUCER_TIMEOUT_SECONDS) do
-        callable.call(store: view, rows: rows, config: @spec["transform_config"] || {})
+        callable.call(store: @transform_context, rows: rows, config: @spec["transform_config"] || {})
       end
     rescue Timeout::Error
       raise UsageError.new("transform_rows '#{name}' exceeded #{REDUCER_TIMEOUT_SECONDS}s timeout")
@@ -52,8 +58,7 @@ module Textus
 
     def collect_keys
       prefixes = Array(@spec["select"])
-      ops = Operations.for(@store, bypass_freshness: @bypass_freshness)
-      prefixes.flat_map { |p| ops.reads.list.call(prefix: p).map { |row| row["key"] } }.uniq
+      prefixes.flat_map { |p| @lister.call(prefix: p).map { |row| row["key"] } }.uniq
     end
 
     def pluck(frontmatter, _body)

data/lib/textus/refresh.rb

@@ -1,7 +1,7 @@
 module Textus
   module Refresh
     def self.call(store, key, as:)
-      Textus::Operations.for(store, role: as).refresh.worker.run(key)
+      Textus::Operations.for(store, role: as).refresh(key)
     end
 
     def self.refresh_stale(store, prefix: nil, zone: nil, as: "runner")

data/lib/textus/schema/tools.rb

@@ -6,7 +6,7 @@ module Textus
     module Tools
       # textus schema init NAME --from=KEY  → infer YAML schema from an entry's frontmatter
       def self.init(store, name:, from:)
-        env = Textus::Operations.for(store).reads.get.call(from)
+        env = Textus::Operations.for(store).get(from)
         meta = env.meta
         schema = {
           "name" => name,
@@ -25,7 +25,7 @@ module Textus
         schema = load_schema(store, name)
         drift = []
         store.manifest.enumerate.each do |row|
-          env = Textus::Operations.for(store).reads.get.call(row[:key])
+          env = Textus::Operations.for(store).get(row[:key])
           begin
             schema.validate!(env.meta)
           rescue SchemaViolation => e
@@ -52,7 +52,7 @@ module Textus
         ops = Textus::Operations.for(store, role: "human")
         touched = []
         store.manifest.enumerate.each do |row|
-          env = ops.reads.get.call(row[:key])
+          env = ops.get(row[:key])
           meta = env.meta.dup
           changed = false
           renames.each do |old, new|
@@ -63,7 +63,7 @@ module Textus
           end
           next unless changed
 
-          ops.writes.put.call(row[:key], meta: meta, body: env.body)
+          ops.put(row[:key], meta: meta, body: env.body)
           touched << row[:key]
         end
         { "protocol" => PROTOCOL, "migrated" => touched, "renames" => renames }
@@ -81,7 +81,7 @@ module Textus
       end
 
       def self.load_schema(store, name)
-        store.schema_for(name)
+        store.schemas.fetch(name)
       rescue IoError
         raise UsageError.new("schema not found: #{name}")
       end

data/lib/textus/schemas.rb

@@ -0,0 +1,46 @@
+module Textus
+  # Eager-loading schema cache. Loads every *.yaml under +dir+ at construction.
+  # A missing directory is treated as "no schemas" (does not raise) to mirror
+  # the lazy behavior previously embedded in Store#schema_for.
+  class Schemas
+    def initialize(dir)
+      @dir = dir
+      @schemas = {}
+      load_all
+    end
+
+    def fetch(name)
+      @schemas[name] || raise(IoError.new("schema not found: #{File.join(@dir, "#{name}.yaml")}"))
+    end
+
+    # Only nil short-circuits. A missing-but-named schema still raises IoError.
+    def fetch_or_nil(name)
+      return nil if name.nil?
+
+      fetch(name)
+    end
+
+    def all
+      @schemas.values
+    end
+
+    private
+
+    def load_all
+      return unless File.directory?(@dir)
+
+      Dir.glob(File.join(@dir, "*.yaml")).each do |path|
+        name = File.basename(path, ".yaml")
+        begin
+          @schemas[name] = Schema.load(path)
+        rescue StandardError
+          # Tolerate broken schema files at construction time so the rest of
+          # the store remains loadable. Surfacing the failure is the job of
+          # Doctor::Check::SchemaParseError. Lookups via #fetch still raise
+          # IoError for the missing-but-named schema.
+          next
+        end
+      end
+    end
+  end
+end