textus 0.15.0 → 0.18.0

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,14 +1,13 @@
 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)               # pure read
-  #   ops.reads.get_or_refresh.call(key)    # read + refresh-on-stale
-  #   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)
       ctx = Application::Context.new(
@@ -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

@@ -7,8 +7,8 @@ module Textus
     REDUCER_TIMEOUT_SECONDS = 2
 
     # `reader` — a callable `->(key) { envelope_or_nil }`. Caller picks
-    #   semantics: pure read (`ops.reads.get`) for materialization paths;
-    #   `ops.reads.get_or_refresh` if you want refresh-on-stale.
+    #   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.

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

data/lib/textus/store.rb

@@ -1,16 +1,8 @@
 require "fileutils"
-require "securerandom"
 
 module Textus
   class Store
-    attr_reader :root, :manifest, :registry, :reader, :writer, :bus
-
-    # A Textus UID: 16 lowercase hex chars (SecureRandom.hex(8)). Not a UUID —
-    # short on purpose. Random enough for collision-never-in-practice within a
-    # single store.
-    def self.mint_uid
-      SecureRandom.hex(8)
-    end
+    attr_reader :root, :manifest, :schemas, :file_store, :audit_log, :bus, :registry
 
     def self.discover(start_dir = Dir.pwd, root: nil)
       explicit = root || ENV.fetch("TEXTUS_ROOT", nil)
@@ -37,46 +29,17 @@ module Textus
     end
 
     def initialize(root)
-      @root = File.expand_path(root)
-      @manifest = Manifest.load(@root)
-      @bus = Hooks::Dispatcher.new(audit_log: audit_log)
-      @registry = Hooks::Registry.new(dispatcher: @bus)
-      @schemas = {}
-      load_hooks
-      @reader = Reader.new(self)
-      @writer = Writer.new(self)
-      @bus.publish(:store_loaded, store: Textus::Application::Context.system(self))
-    end
-
-    def load_hooks
-      Textus.with_registry(@registry) do
-        Hooks::Builtin.register_all
-        dir = File.join(@root, "hooks")
-        return unless File.directory?(dir)
-
-        Dir.glob(File.join(dir, "**/*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
-          begin
-            load(f)
-          rescue StandardError, ScriptError => e
-            raise UsageError.new("failed loading hook #{File.basename(f)}: #{e.class}: #{e.message}")
-          end
-        end
-      end
-    end
-
-    def schema_for(name)
-      return nil if name.nil?
-
-      @schemas[name] ||= begin
-        sp = File.join(@root, "schemas", "#{name}.yaml")
-        raise IoError.new("schema not found: #{sp}") unless File.exist?(sp)
-
-        Schema.load(sp)
-      end
-    end
-
-    def audit_log
-      @audit_log ||= Store::AuditLog.new(@root)
+      @root       = File.expand_path(root)
+      @manifest   = Manifest.load(@root)
+      @schemas    = Schemas.new(File.join(@root, "schemas"))
+      @file_store = Infra::Storage::FileStore.new
+      @audit_log  = Infra::AuditLog.new(@root)
+      @bus        = Hooks::Dispatcher.new
+      @registry   = Hooks::Registry.new(dispatcher: @bus)
+      Infra::AuditSubscriber.new(@audit_log).attach(@bus)
+      Hooks::Builtin.register_all(@registry)
+      Hooks::Loader.new(registry: @registry).load_dir(File.join(@root, "hooks"))
+      @bus.publish(:store_loaded, store: Application::Context.system(self))
     end
   end
 end

data/lib/textus/uid.rb

@@ -0,0 +1,18 @@
+require "securerandom"
+
+module Textus
+  # A Textus UID: 16 lowercase hex chars (SecureRandom.hex(8)). Not a UUID —
+  # short on purpose. Random enough for collision-never-in-practice within a
+  # single store.
+  module Uid
+    module_function
+
+    def mint
+      SecureRandom.hex(8)
+    end
+
+    def valid?(str)
+      str.is_a?(String) && str.match?(/\A[0-9a-f]{16}\z/)
+    end
+  end
+end

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.15.0"
+  VERSION = "0.18.0"
   PROTOCOL = "textus/3"
 end

data/lib/textus.rb

@@ -8,11 +8,27 @@ loader.inflector.inflect(
   "json" => "Json",
   "yaml" => "Yaml",
   "hook_dsl_scanner" => "HookDSLScanner",
+  "envelope_io" => "EnvelopeIO",
 )
 loader.ignore(File.expand_path("textus/errors.rb", __dir__))
 loader.setup
 loader.eager_load
 
 module Textus
-  extend Hooks::Dsl
+  @hook_mutex  = Mutex.new
+  @hook_blocks = []
+
+  def self.hook(&blk)
+    raise UsageError.new("hook block required") unless blk
+
+    @hook_mutex.synchronize { @hook_blocks << blk }
+  end
+
+  def self.drain_hook_blocks
+    @hook_mutex.synchronize do
+      blocks = @hook_blocks
+      @hook_blocks = []
+      blocks
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Patrick
@@ -124,6 +124,7 @@ files:
 - lib/textus/application/reads/stale.rb
 - lib/textus/application/reads/uid.rb
 - lib/textus/application/reads/validate_all.rb
+- lib/textus/application/reads/validator.rb
 - lib/textus/application/reads/where.rb
 - lib/textus/application/refresh/all.rb
 - lib/textus/application/refresh/orchestrator.rb
@@ -131,6 +132,7 @@ files:
 - lib/textus/application/writes/accept.rb
 - lib/textus/application/writes/build.rb
 - lib/textus/application/writes/delete.rb
+- lib/textus/application/writes/envelope_io.rb
 - lib/textus/application/writes/mv.rb
 - lib/textus/application/writes/publish.rb
 - lib/textus/application/writes/put.rb
@@ -198,6 +200,7 @@ files:
 - lib/textus/doctor/check/templates.rb
 - lib/textus/doctor/check/unowned_schema_fields.rb
 - lib/textus/domain/action.rb
+- lib/textus/domain/freshness.rb
 - lib/textus/domain/freshness/evaluator.rb
 - lib/textus/domain/freshness/policy.rb
 - lib/textus/domain/freshness/verdict.rb
@@ -211,6 +214,10 @@ files:
 - lib/textus/domain/policy/promote.rb
 - lib/textus/domain/policy/promotion.rb
 - lib/textus/domain/policy/refresh.rb
+- lib/textus/domain/sentinel.rb
+- lib/textus/domain/staleness.rb
+- lib/textus/domain/staleness/generator_check.rb
+- lib/textus/domain/staleness/intake_check.rb
 - lib/textus/entry.rb
 - lib/textus/entry/base.rb
 - lib/textus/entry/json.rb
@@ -222,15 +229,17 @@ files:
 - lib/textus/etag.rb
 - lib/textus/hooks/builtin.rb
 - lib/textus/hooks/dispatcher.rb
-- lib/textus/hooks/dsl.rb
 - lib/textus/hooks/loader.rb
 - lib/textus/hooks/registry.rb
+- lib/textus/infra/audit_log.rb
+- lib/textus/infra/audit_subscriber.rb
 - lib/textus/infra/build_lock.rb
 - lib/textus/infra/clock.rb
 - lib/textus/infra/event_bus.rb
 - lib/textus/infra/publisher.rb
 - lib/textus/infra/refresh/detached.rb
 - lib/textus/infra/refresh/lock.rb
+- lib/textus/infra/storage/file_store.rb
 - lib/textus/init.rb
 - lib/textus/intro.rb
 - lib/textus/key/distance.rb
@@ -245,28 +254,20 @@ files:
 - lib/textus/manifest/entry/validators/index_filename.rb
 - lib/textus/manifest/entry/validators/inject_intro.rb
 - lib/textus/manifest/entry/validators/publish_each.rb
+- lib/textus/manifest/resolution.rb
 - lib/textus/manifest/rules.rb
 - lib/textus/manifest/schema.rb
 - lib/textus/migrate_keys.rb
 - lib/textus/mustache.rb
 - lib/textus/operations.rb
-- lib/textus/operations/reads.rb
-- lib/textus/operations/refresh.rb
-- lib/textus/operations/writes.rb
 - lib/textus/projection.rb
 - lib/textus/refresh.rb
 - lib/textus/role.rb
 - lib/textus/schema.rb
 - lib/textus/schema/tools.rb
+- lib/textus/schemas.rb
 - lib/textus/store.rb
-- lib/textus/store/audit_log.rb
-- lib/textus/store/reader.rb
-- lib/textus/store/sentinel.rb
-- lib/textus/store/staleness.rb
-- lib/textus/store/staleness/generator_check.rb
-- lib/textus/store/staleness/intake_check.rb
-- lib/textus/store/validator.rb
-- lib/textus/store/writer.rb
+- lib/textus/uid.rb
 - lib/textus/version.rb
 homepage: https://github.com/patrick204nqh/textus
 licenses:

data/lib/textus/hooks/dsl.rb

@@ -1,11 +0,0 @@
-module Textus
-  module Hooks
-    module Dsl
-      def on(event, name, **, &blk)
-        raise UsageError.new("hook needs a block") unless blk
-
-        Loader.current_registry.register(event, name, **, &blk)
-      end
-    end
-  end
-end