textus 0.9.2 → 0.10.1

data/lib/textus/cli/verb/freshness.rb

@@ -6,8 +6,7 @@ module Textus
         option :zone, "--zone=Z"
 
         def call(store)
-          role = Role.resolve(flag: nil, env: ENV, root: store.root)
-          ctx = Textus::Composition.context(store, role: role)
+          ctx = context_for(store)
           rows = Textus::Composition.freshness(ctx).call(prefix: prefix, zone: zone)
           emit({ "verb" => "freshness", "rows" => rows })
         end

data/lib/textus/cli/verb/get.rb

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("get requires a key")
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          ctx = Textus::Composition.context(store, role: role)
+          ctx = context_for(store)
           result = Textus::Composition.reads_get(ctx).call(key)
           raise Textus::UnknownKey.new(key, suggestions: store.manifest.suggestions_for(key)) if result.nil?
 

data/lib/textus/cli/verb/hook_run.rb

@@ -24,7 +24,7 @@ module Textus
 
           role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
           callable = store.registry.rpc_callable(:intake, name)
-          view = Store::View.new(store, writable: true, as: role)
+          view = Application::Context.new(store: store, role: role)
 
           begin
             Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do

data/lib/textus/cli/verb/mv.rb

@@ -8,8 +8,7 @@ module Textus
         def call(store)
           old_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
           new_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          emit(store.mv(old_key, new_key, as: role, dry_run: dry_run || false))
+          emit(store.mv(old_key, new_key, as: resolved_role(store), dry_run: dry_run || false))
         end
       end
     end

data/lib/textus/cli/verb/policy_explain.rb

@@ -4,8 +4,7 @@ module Textus
       class PolicyExplain < Verb
         def call(store)
           key = positional.shift or raise UsageError.new("policy explain requires a KEY")
-          role = Role.resolve(flag: nil, env: ENV, root: store.root)
-          ctx = Textus::Composition.context(store, role: role)
+          ctx = context_for(store)
           result = Textus::Composition.policy_explain(ctx).call(key: key)
           emit({ "verb" => "policy_explain" }.merge(result.transform_keys(&:to_s)))
         end

data/lib/textus/cli/verb/put.rb

@@ -10,7 +10,7 @@ module Textus
           key = positional.shift or raise UsageError.new("put requires a key")
           raise UsageError.new("put requires --stdin in v1") unless use_stdin
 
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
+          role = resolved_role(store)
 
           raw = @stdin.read
           payload =
@@ -19,7 +19,8 @@ module Textus
               result =
                 begin
                   Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do
-                    callable.call(config: { "bytes" => raw }, store: Textus::Store::View.new(store), args: {})
+                    callable.call(config: { "bytes" => raw },
+                                  store: Textus::Application::Context.new(store: store, role: role), args: {})
                   end
                 rescue Timeout::Error
                   raise UsageError.new(
@@ -32,14 +33,14 @@ module Textus
                   "name" => basename,
                   "last_refreshed_at" => Time.now.utc.iso8601,
                   "fetched_with" => fetch_name,
-                }.merge(result[:_meta] || result["_meta"] || result[:frontmatter] || result["frontmatter"] || {}),
+                }.merge(result[:_meta] || result["_meta"] || {}),
                 "body" => result[:body] || result["body"] || "",
               }
             else
               JSON.parse(raw)
             end
 
-          meta = payload["_meta"] || payload["frontmatter"] || {}
+          meta = payload["_meta"] || {}
           body = payload["body"] || ""
           if_etag = payload["if_etag"]
           ctx = Textus::Composition.context(store, role: role)

data/lib/textus/cli/verb/refresh.rb

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("refresh requires a key")
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          ctx = Textus::Composition.context(store, role: role)
+          ctx = context_for(store)
           emit(Textus::Composition.refresh_worker(ctx).run(key))
         end
       end

data/lib/textus/cli/verb/refresh_stale.rb

@@ -7,8 +7,7 @@ module Textus
         option :as_flag, "--as=ROLE"
 
         def call(store)
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          ctx = Textus::Composition.context(store, role: role)
+          ctx = context_for(store)
           result = Textus::Application::Refresh::All.call(ctx, prefix: prefix, zone: zone)
           emit(result)
           exit(1) unless result["ok"]

data/lib/textus/cli/verb/reject.rb

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("reject requires a key")
-          role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          emit(store.reject(key, as: role))
+          emit(store.reject(key, as: resolved_role(store)))
         end
       end
     end

data/lib/textus/cli/verb.rb

@@ -57,6 +57,20 @@ module Textus
         @stdout.puts(JSON.generate(payload))
         exit_code
       end
+
+      # Resolves the active role for this invocation. Honors the verb's
+      # `--as` flag if declared, then TEXTUS_ROLE, then the project default.
+      def resolved_role(store)
+        flag = respond_to?(:as_flag) ? as_flag : nil
+        Role.resolve(flag: flag, env: ENV, root: store.root)
+      end
+
+      # Returns an Application::Context bound to the resolved role.
+      # Convenience for verbs whose only pre-call boilerplate is
+      # resolving the role and wrapping it in a context.
+      def context_for(store)
+        Textus::Composition.context(store, role: resolved_role(store))
+      end
     end
   end
 end

data/lib/textus/composition.rb

@@ -41,6 +41,7 @@ module Textus
         bus: ctx.store.bus,
         store_root: ctx.store.root,
         store: ctx.store,
+        role: ctx.role,
       )
     end
 

data/lib/textus/doctor.rb

@@ -52,7 +52,7 @@ module Textus
 
     def run_registered_checks(store)
       out = []
-      view = Store::View.new(store)
+      view = Application::Context.new(store: store, role: "human")
       store.registry.rpc_names(:check).each do |name|
         callable = store.registry.rpc_callable(:check, name)
         begin
@@ -86,5 +86,7 @@ module Textus
         "fix" => fix,
       }
     end
+
+    private_class_method :run_registered_checks, :fail_issue
   end
 end

data/lib/textus/intro.rb

@@ -16,11 +16,6 @@ module Textus
       "inbox" => "declared external inputs; script-refreshed via actions",
       "review" => "AI proposals awaiting human accept",
       "output" => "build-computed outputs; never hand-edited",
-      # legacy 0.9.1 zone names — kept so intro still annotates pre-rename stores
-      "canon" => "slow-changing identity; human-only writes",
-      "intake" => "declared external inputs; script-refreshed via actions",
-      "pending" => "AI proposals awaiting human accept",
-      "derived" => "build-computed outputs; never hand-edited",
     }.freeze
 
     WRITE_FLOWS = {

data/lib/textus/manifest/entry.rb

@@ -56,15 +56,32 @@ module Textus
         @publish_each.gsub(PUBLISH_EACH_VAR_RE) { vars.fetch(::Regexp.last_match(1)) }
       end
 
+      # Signal-based zone-kind predicates: derive the "kind" of a zone from its
+      # writable_by signals rather than its literal name. This keeps detection
+      # working when users rename the default zones (canon/intake/pending/derived
+      # → identity/inbox/review/output, etc.).
+      def in_generator_zone?
+        zone_writers.include?("build")
+      end
+
+      def in_proposal_zone?
+        zone_writers.include?("ai")
+      end
+
+      # Legacy alias for in_generator_zone?. Retained because internal validation
+      # callers (and external tools) read more naturally as `derived?`.
       def derived?
-        writers = @manifest.zone_writers(@zone)
-        writers.include?("build")
-      rescue UsageError => e
-        raise UsageError.new("entry '#{@key}': #{e.message}")
+        in_generator_zone?
       end
 
       private
 
+      def zone_writers
+        @manifest.zone_writers(@zone)
+      rescue UsageError => e
+        raise UsageError.new("entry '#{@key}': #{e.message}")
+      end
+
       def validate_inject_intro!
         return unless @inject_intro
 

data/lib/textus/manifest.rb

@@ -136,17 +136,6 @@ module Textus
     end
     # rubocop:enable Metrics/AbcSize
 
-    # Validates all declared entry keys; raises UsageError listing all offenders.
-    def validate_keys!
-      offenders = []
-      @entries.each do |entry|
-        validate_key!(entry.key)
-      rescue UsageError => e
-        offenders << e.message
-      end
-      raise UsageError.new("invalid manifest keys: #{offenders.join("; ")}") unless offenders.empty?
-    end
-
     def validate_key!(key)
       raise UsageError.new("empty key") if key.nil? || key.empty?
 

data/lib/textus/projection.rb

@@ -40,7 +40,7 @@ module Textus
     def apply_reducer(rows)
       name = @spec["reduce"] or return rows
       callable = @store.registry.rpc_callable(:reduce, name)
-      view = Store::View.new(@store)
+      view = Application::Context.new(store: @store, role: "human")
       Timeout.timeout(REDUCER_TIMEOUT_SECONDS) do
         callable.call(store: view, rows: rows, config: @spec["reduce_config"] || {})
       end

data/lib/textus/refresh.rb

@@ -15,8 +15,7 @@ module Textus
     def self.normalize_action_result(res, format:)
       res = res.transform_keys(&:to_s) if res.is_a?(Hash)
       res ||= {}
-      # Accept both legacy :frontmatter/:_meta key names from intake hooks.
-      meta_val = res["_meta"] || res["frontmatter"]
+      meta_val = res["_meta"]
       body    = res["body"]
       content = res["content"]
 

data/lib/textus/store/staleness.rb

@@ -11,7 +11,7 @@ module Textus
       def call(prefix: nil, zone: nil)
         out = []
         @manifest.entries.each do |mentry|
-          next unless mentry.zone == "derived"
+          next unless mentry.in_generator_zone?
           next if zone && mentry.zone != zone
 
           gen = mentry.generator

data/lib/textus/store/writer.rb

@@ -152,7 +152,7 @@ module Textus
         raise ProposalError.new("only human role can reject proposals; got '#{as}'") unless as == "human"
 
         mentry, = @store.manifest.resolve(pending_key)
-        raise ProposalError.new("reject: '#{pending_key}' is not a pending entry (zone=#{mentry.zone})") unless mentry.zone == "pending"
+        raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})") unless mentry.in_proposal_zone?
 
         env = @store.get(pending_key)
         proposal = env.dig("_meta", "proposal") or

data/lib/textus/store.rb

@@ -102,7 +102,7 @@ module Textus
     end
 
     def fire_event(event, **)
-      view = Store::View.new(self)
+      view = Textus::Application::Context.new(store: self, role: "human")
       @bus.publish(event, store: view, **)
     end
 

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.9.2"
+  VERSION = "0.10.1"
   PROTOCOL = "textus/2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.1
 platform: ruby
 authors:
 - Patrick
@@ -102,10 +102,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ARCHITECTURE.md
 - CHANGELOG.md
 - README.md
 - SPEC.md
-- docs/architecture.md
 - docs/conventions.md
 - exe/textus
 - lib/textus.rb
@@ -123,7 +123,6 @@ files:
 - lib/textus/application/writes/delete.rb
 - lib/textus/application/writes/publish.rb
 - lib/textus/application/writes/put.rb
-- lib/textus/builder.rb
 - lib/textus/builder/pipeline.rb
 - lib/textus/builder/renderer.rb
 - lib/textus/builder/renderer/json.rb
@@ -226,7 +225,6 @@ files:
 - lib/textus/mustache.rb
 - lib/textus/projection.rb
 - lib/textus/proposal.rb
-- lib/textus/publisher.rb
 - lib/textus/refresh.rb
 - lib/textus/role.rb
 - lib/textus/schema.rb
@@ -237,7 +235,6 @@ files:
 - lib/textus/store/reader.rb
 - lib/textus/store/staleness.rb
 - lib/textus/store/validator.rb
-- lib/textus/store/view.rb
 - lib/textus/store/writer.rb
 - lib/textus/version.rb
 homepage: https://github.com/patrick204nqh/textus

data/docs/architecture.md

@@ -1,129 +0,0 @@
-# Architecture
-
-How the reference Ruby implementation is organized. The wire protocol itself lives in [`../SPEC.md`](../SPEC.md); this document covers *how* the gem implements that spec.
-
-The codebase is a flat graph of small modules under one CLI dispatcher, not a strict pyramid. The clusters below describe what each module exists for and which other modules it talks to.
-
-## At a glance
-
-```
-exe/textus  →  Textus::CLI  ──┬──►  Store          (facade — delegates to Reader/Writer/Mover)
-                              │       ├──►  Store::Reader  (get/list/where/uid/deps/published/stale/validate_all)
-                              │       ├──►  Store::Writer  (put/delete/accept)
-                              │       ├──►  Store::Mover   (mv)
-                              │       └──►  Hooks::Dispatcher  (lifecycle publish/subscribe)
-                              ├──►  Builder        (build verb — Pipeline + per-format renderers)
-                              ├──►  Refresh        (refresh verb)
-                              ├──►  Doctor         (doctor verb)
-                              ├──►  Init           (init verb)
-                              ├──►  Intro          (intro verb)
-                              ├──►  MigrateKeys    (key migrate, key mv verbs)
-                              ├──►  Schema::Tools  (schema init/diff/migrate verbs)
-                              ├──►  Store::View    (read-only projection over Store::Reader)
-                              └──►  Role           (role gate)
-```
-
-CLI is the single entry point. It parses argv and dispatches each verb to whichever module owns that capability — there is no single mediator below CLI.
-
-## Module clusters
-
-### 1. Request path — core read/write verbs
-
-`Store` is a thin facade (~110 LOC) that holds `Manifest`, `Hooks::Registry`, `Hooks::Dispatcher`, and the lazy `Store::AuditLog`, then delegates verbs to a small set of focused collaborators:
-
-- **`Store::Reader`** — owns `get`, `list`, `where`, `uid`, `deps`, `rdeps`, `published`, `schema_envelope`, `validate_all`. The only module that reads working-store entry files. (`freshness` lives in `Application::Reads::Freshness` since 0.9.2; the legacy `stale` shim was removed.)
-- **`Store::Writer`** — owns `put`, `delete`, `accept`. Handles serialization, uid minting, etag check, role gate, audit append, and event publication. The only module that writes working-store entry files.
-- **`Store::Mover`** — owns `mv` (same-zone rename) with uid preservation and one audit row.
-- **`Store::Validator`** / **`Store::Staleness`** — back the `validate_all` / `freshness` reads. Take explicit collaborators (`reader:`, `manifest:`, `audit_log:`, `schema_for:`) instead of the full store.
-
-Shared value modules and primitives consumed by Reader/Writer/Mover:
-
-- **`Textus::Key::Path`** — `Key::Path.resolve(manifest, mentry)` returns the absolute leaf path for a manifest entry. Single source for zone-path construction; used by `Manifest`, `Staleness`, `Builder`, and Writer.
-- **`Textus::Envelope`** — `Envelope.build(...)` returns the canonical envelope hash (protocol, key, zone, owner, path, format, `_meta`, body, etag, schema_ref, uid, optional content). Single source for envelope shape across `get` and `put`.
-- **`Manifest`** — parses `.textus/manifest.yaml`; resolves a dotted key to a path via longest-prefix match. `nested: true` entries treat unmatched suffix segments as `/`-joined subdirs, with `.md` appended. Resolution is path-only; existence is the verb's concern.
-- **`Schema`** — loads YAML schema files; validates frontmatter shape and surfaces unknown-key warnings (the §6 forward-compat rule).
-- **`Entry`** + format adapters (`entry/markdown.rb`, `entry/text.rb`, `entry/json.rb`, `entry/yaml.rb`) — splits raw bytes on `---\n`, feeds the YAML chunk to `YAML.safe_load` (no aliases, restricted classes). The frontmatter `name:` field is enforced against the file basename in Reader/Writer (on read and on write) — mismatch raises `bad_frontmatter`.
-- **`Etag`** — `sha256:<hex>` over raw file bytes. `put` accepts optional `if_etag:`; mismatch raises `etag_mismatch`. No locking, no temp-file-and-rename — v1 leaves stronger guarantees to v1.x.
-- **`Role`** — agent-vs-human gate. Writer checks `Manifest::Entry#zone_writers` before doing anything else; otherwise raises `write_forbidden`.
-- **`Store::AuditLog`** — append-only NDJSON; every successful write emits one line.
-- **`Proposal`** — `accept` verb flow for promoting a pending entry into its target zone.
-- **`Dependencies`** — `deps`/`rdeps`/`published` verb backing; walks manifest declarations.
-
-### 2. Build / publish pipeline
-
-Separate from the request path. Owns derived-entry materialization and byte-copy publish. `Builder` orchestrates per-entry materialization through `Builder::Pipeline`, which runs an ordered step list and dispatches the rendering step to one of four format-specific renderers. Adding a new output format is a single-file change under `lib/textus/builder/renderer/`.
-
-```
-Builder ──► Pipeline ──► LoadSources ──► Project ──► Render (per-format) ──► Write ──► Publisher ──► (sentinel)
-                                                          │
-                                                          └──► Renderer::{Markdown, Text, Json, Yaml}
-```
-
-- **`Builder`** — iterates `zone: derived` entries, hands each to `Pipeline.run`, then handles `Publisher` copy-out and fires the `:build` event. Holds no format-specific logic.
-- **`Builder::Pipeline`** — `Pipeline.run(store:, mentry:, template_loader:)` is the orchestrator: runs the projection, merges `intro` if `inject_intro: true`, dispatches to the matching renderer, writes the bytes to the derived path.
-- **`Builder::InjectMeta`** — builds the `_meta` block (`generated_at`, `from`, `template`, `reduce`) and threads it onto JSON/YAML content as the first key per SPEC §6 ordering.
-- **`Builder::Renderer::{Markdown,Text,Json,Yaml}`** — one class per format, inheriting `Builder::Renderer`. Receives a template-loader lambda and `(mentry:, data:)`; returns rendered bytes. Markdown/Text always require a template; JSON/YAML optionally accept one (otherwise default-shape the projection rows).
-- **`Projection`** — collects rows from manifest-declared source keys, applies optional reducer, sorts and positions. Pure data shaping.
-- **`Mustache`** — minimal mustache renderer for templates in `.textus/templates/`.
-- **`Publisher`** — byte-copy from store path to external target path. Refuses to overwrite unmanaged targets; writes a sentinel in `.textus/sentinels/` to track managed targets.
-
-### 3. Extension surface
-
-Declared in the manifest, loaded on demand, dispatched by `Store` and `Refresh`.
-
-- **`Hooks::Registry`** — loads one `.rb` per hook from `.textus/hooks/`, registers callables under their `(event, name)`. Single source of truth via the `EVENTS` table (rpc vs pubsub, arg shape, failure semantics). For pub-sub events it also forwards registrations to the `Hooks::Dispatcher`.
-- **`Hooks::Dispatcher`** — first-class pub/sub for lifecycle events (`:put`, `:delete`, `:refresh`, `:build`, `:accept`, `:publish`, `:mv`, `:reject`, `:loaded`). Owns the 2-second per-handler timeout and the audit-on-failure middleware (raising handlers do not abort the write; they produce an `event_error` audit row). Embedded callers can `store.dispatcher.subscribe(:put, :name) { ... }` outside `.textus/hooks/`.
-- **`Hooks::Builtin`** — ships built-in `:fetch` hooks (e.g. json, csv, ical-events, rss) available without user-supplied hooks.
-- **`Refresh`** — `refresh` verb: looks up the `:fetch` hook for a key, invokes it, normalizes the result by declared format, writes through `Store::Writer` with an etag check.
-
-### 4. Operational tooling
-
-First-class CLI verbs that don't fit the read/write/build axes. Read-mostly; side modules off CLI.
-
-- **`Doctor`** — `doctor` verb: orchestrator that runs 9 builtin checks under `Doctor::Check::*`. Talks to Manifest/Schema/Entry/Hooks::Registry directly.
-- **`Doctor::Check`** — explicit base class for doctor checks. Each of the 9 builtin checks is its own file under `lib/textus/doctor/check/`.
-- **`MigrateKeys`** — `key migrate` and `key mv` verbs; computes renames against the manifest.
-- **`Schema::Tools`** — `schema init`, `schema diff`, `schema migrate` verbs.
-- **`Init`** — `init` verb: scaffolds `.textus/` with the five zone directories, baseline schemas, empty audit log, starter manifest.
-- **`Intro`** — `intro` verb: emits the human/agent-facing onboarding payload.
-- **`Store::View`** — read-only projection over `Store::Reader` for hook code that should not mutate.
-- **`Key::Distance`** — Levenshtein-ish suggestion for `did-you-mean` on unknown keys.
-
-### 5. Primitives
-
-- **`Errors`** — `Textus::Error` subclasses, each carrying a stable `code`, a `details` hash, and an `exit_code`. `CLI` catches them at the top level and emits the §8 error envelope on stdout. In `--format=json` mode, errors are **never** written to stderr — agents read stdout.
-- **`version`** — gem semver string (independent of the wire protocol `textus/2`).
-
-## Invariants
-
-- **CLI is the only entry point.** No public API surface guarantees outside the verbs CLI exposes.
-- **Manifest is pure.** Reads at load, no mutation.
-- **Store::Writer is the only module that writes to working-store entry files.** Reader reads them; Mover moves them within a zone. Init, MigrateKeys, Publisher, Builder, AuditLog write to **other** parts of `.textus/` (scaffolding, sentinels, audit log, derived targets) — they do not edit existing entry files behind the Store facade's back.
-- **`name:` frontmatter matches file basename.** Enforced on read and write.
-- **Zone semantics live in the manifest, not in directory names.** A project may rename `state/` to anything; the manifest declares which zone each entry belongs to.
-- **`freshness` does not execute anything.** It walks every entry, matches it against the top-level `policies:` block, and returns each entry's verdict (`fresh|stale|never_refreshed|no_policy`). Build runners execute. This is the §5.1 "dataflow oracle, not executor" boundary.
-
-## Policy resolution
-
-Top-level `policies:` are parsed into a `Manifest::Policies` collection. Resolution is by key, slot-aware, most-specific-wins:
-
-```
-Manifest#policies_for(key)
-   └─► Manifest::Policies#for(key)
-          ├─► Policy::Matcher (specificity ranking)
-          └─► returns PolicySet { refresh, handler_allowlist, promote, retention }
-                                 │
-                                 ▼
-                       consumers: Refresh::Worker
-                                  Doctor checks
-                                  Reads::PolicyExplain
-```
-
-Two blocks at the same specificity filling the same slot for the same key is a manifest error reported by `doctor` (`policy_ambiguity`). Custom-named zones see no special handling — policies match against the full key.
-
-## What this implementation deliberately leaves out
-
-- **No process spawning.** Even `stale` does not execute. Build runners do that.
-- **No transport.** No HTTP server, no socket, no MCP server in this gem. Those are downstream wrappers (see [`./conventions.md`](./conventions.md)).
-- **No indexes.** Listing walks the filesystem each time. Premature optimisation for v1.
-- **No locking.** Etag is advisory; concurrent writers can still race. Left to v1.x (§14 open question).

data/lib/textus/builder.rb

@@ -1,99 +0,0 @@
-require "fileutils"
-
-# As of 0.9.1, Textus::Application::Writes::Build is the preferred public
-# entry point. This class remains as the implementation home of materialization
-# and projection logic; full extraction is deferred to 0.10.0.
-module Textus
-  class Builder
-    def initialize(store)
-      @store = store
-      @manifest = store.manifest
-      @root = store.root
-    end
-
-    def build(prefix: nil)
-      built = []
-      @manifest.entries.each do |mentry|
-        next unless derived_zone?(mentry)
-        next unless mentry.projection || mentry.template
-        next if prefix && !mentry.key.start_with?(prefix)
-
-        result = materialize(mentry)
-        built << result
-      end
-      published_leaves = publish_leaves(prefix: prefix)
-      { "protocol" => Textus::PROTOCOL, "built" => built, "published_leaves" => published_leaves }
-    end
-
-    private
-
-    def publish_leaves(prefix: nil)
-      repo_root = File.dirname(@root)
-      out = []
-      @manifest.entries.each do |mentry|
-        next unless mentry.nested && mentry.publish_each
-        next if prefix && !mentry.key.start_with?(prefix) && !prefix.start_with?("#{mentry.key}.")
-
-        @manifest.enumerate(prefix: mentry.key).each do |row|
-          next unless row[:manifest_entry].equal?(mentry)
-          next if prefix && !row[:key].start_with?(prefix) && row[:key] != prefix
-
-          out << publish_leaf(mentry, row, repo_root)
-        end
-      end
-      out
-    end
-
-    def publish_leaf(mentry, row, repo_root)
-      target_rel = mentry.publish_target_for(row[:key])
-      target_abs = File.expand_path(File.join(repo_root, target_rel))
-      unless target_abs.start_with?(File.expand_path(repo_root) + File::SEPARATOR)
-        raise PublishError.new(
-          "entry '#{mentry.key}': publish_each target '#{target_rel}' for key '#{row[:key]}' escapes repo root",
-        )
-      end
-
-      Textus::Infra::Publisher.publish(source: row[:path], target: target_abs, store_root: @root)
-      @store.fire_event(:published, key: row[:key], envelope: @store.get(row[:key]),
-                                    source: row[:path], target: target_abs)
-      { "key" => row[:key], "source" => row[:path], "target" => target_abs }
-    end
-
-    def derived_zone?(mentry)
-      writers = @manifest.zone_writers(mentry.zone)
-      writers.include?("build")
-    end
-
-    def materialize(mentry)
-      target_path = Pipeline.run(
-        store: @store,
-        mentry: mentry,
-        template_loader: ->(name) { read_template(name) },
-      )
-      publish_and_fire(mentry, target_path)
-      { "key" => mentry.key, "path" => target_path, "published_to" => mentry.publish_to }
-    end
-
-    def read_template(name)
-      tpl_path = File.join(@root, "templates", name)
-      raise TemplateError.new("template not found: #{tpl_path}", template_name: name) unless File.exist?(tpl_path)
-
-      File.read(tpl_path)
-    end
-
-    def publish_and_fire(mentry, target_path)
-      envelope = @store.get(mentry.key)
-      repo_root = File.dirname(@root)
-
-      mentry.publish_to.each do |rel|
-        target_abs = File.join(repo_root, rel)
-        Textus::Infra::Publisher.publish(source: target_path, target: target_abs, store_root: @root)
-        @store.fire_event(:published, key: mentry.key, envelope: envelope,
-                                      source: target_path, target: target_abs)
-      end
-
-      @store.fire_event(:built, key: mentry.key, envelope: envelope,
-                                sources: Array(mentry.projection&.fetch("select", nil)).compact)
-    end
-  end
-end

data/lib/textus/publisher.rb

@@ -1,6 +0,0 @@
-# Deprecated as of 0.9.1: use Textus::Infra::Publisher (or
-# Textus::Application::Writes::Publish for the use-case entry point).
-# Slated for removal in 0.10.0.
-module Textus
-  Publisher = Infra::Publisher
-end

data/lib/textus/store/view.rb

@@ -1,18 +0,0 @@
-module Textus
-  class Store
-    # Deprecated as of 0.9.1: use Textus::Application::Context instead.
-    # Removal scheduled for 0.10.0.
-    class View
-      def self.new(store, writable: false, as: nil)
-        unless @warned_once
-          warn "[textus] Store::View is deprecated; use Application::Context (will be removed in 0.10.0)"
-          @warned_once = true
-        end
-
-        raise UsageError.new("writable Store::View requires an as: role") if writable && (as.nil? || as.to_s.empty?)
-
-        Textus::Application::Context.new(store: store, role: as || "human")
-      end
-    end
-  end
-end