textus 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca479a6c2f4282b97184aee5c65bc94c3607d18ae0a608756737c70ef53407b5
-  data.tar.gz: 2294eaa31b51276d48f1a7bc850464c3351a2c93b5d273100192fec4d89561d9
+  metadata.gz: 198dc9a4561b79bf4da22a2f890caa5da2764b8d82b1665b506d6c4c8c0e3fe3
+  data.tar.gz: dc5333c3605b7b05174f4b290fcb63260aad7ea089da900f0b3325cf3823d83c
 SHA512:
-  metadata.gz: 6a6c5a434cf90e8e417faed9034e6ea653f1f94b3e373ea00b47045297e73b9e0f58d4619a84f497b45cb3078930da9b4327d7e179540369af7bf7297db2bd05
-  data.tar.gz: 4cbcd09254c93d94d1fd06c766ceefb5125990851422db6f6b3af4ad716b7754d71e432ebc88161d938aa5177ec26d6e1f43b7577daa80210e7a493e0266f6ea
+  metadata.gz: f9e08a7a3fc46732dcd9458114765a54e3f8d2aca08b3ead6b70ecfc2782c0e9fec5eec38fc933cef9582c5943db52973c8bb06e544c02afec468dc50bbc8797
+  data.tar.gz: 9cb891ae4ce1d7583af7546e16e1f1a23d8d88af105430d31c2eb3fd4e25af6df2a60c5677c810a3d11f01582d7500a18d681b8996e9f2f5da1948e32ec2a39f

data/CHANGELOG.md

@@ -8,6 +8,111 @@ The **gem version** (`0.x.y`) is distinct from the **protocol version**
 (currently `textus/2`, embedded in every envelope as `protocol`). The protocol
 is additive within a major; a new major would change the wire string.
 
+## 0.10.0 — Shim removal, signal-based zone detection, Builder extraction (2026-05-22)
+
+### Breaking — Ruby API
+
+- `Textus::Publisher` constant removed. Use `Textus::Infra::Publisher`.
+- `Textus::Store::View` class removed. Use `Textus::Application::Context`
+  (constructed via `Composition.context(store, role:)`).
+- `Textus::Builder` class removed as a public entry point. Build logic lives
+  in `Textus::Application::Writes::Build`. External callers should use
+  `Textus::Composition.writes_build(ctx).call` instead of
+  `Textus::Builder.new(store).build`. The `Textus::Builder` namespace is
+  retained internally only for nested helpers (`Builder::Pipeline`,
+  `Builder::Renderer::*`).
+- `Application::Context` no longer exposes `put` / `delete` / `get` / `list`
+  / `where` shim methods. Hook callers that receive a Context via the
+  `store:` hook keyword must call `ctx.store.put(...)` etc., and explicitly
+  pass `as: ctx.role` for write operations.
+- Intake handler return values must use `_meta:` for frontmatter. The
+  previous `frontmatter:` legacy key is no longer accepted.
+
+### Fixed
+
+- `textus reject` and `textus refresh-stale` now work correctly for stores
+  that use the post-0.9.2 default zone names (`review`, `output`).
+  Zone-kind detection is now signal-based (driven by `writable_by:`
+  membership), not name-based. Stores using the pre-0.9.2 names (`pending`,
+  `derived`) continue to work.
+- Event payloads' `store:` keyword now carries a Context whose
+  `correlation_id` matches the event payload's top-level `correlation_id`
+  key. Previously the `store:` Context received a fresh, unrelated
+  `correlation_id`.
+
+### Added
+
+- `Textus::Manifest::Entry#in_generator_zone?` and `#in_proposal_zone?`
+  predicates. Internal `derived?` retained as an alias of
+  `in_generator_zone?`.
+- `:built` and `:published` events now carry `correlation_id` in the
+  payload, matching the existing pattern on `:put` / `:deleted` /
+  `:accepted`.
+
+### Removed
+
+- Legacy zone-purpose annotations for `canon` / `intake` / `pending` /
+  `derived` removed from `Textus::Intro::ZONE_PURPOSES`. Custom-named zones
+  continue to get no purpose annotation (existing behavior). Stores still
+  using the pre-rename default names will simply not get purpose
+  annotations on those zones in `textus intro` output.
+- Dead code: `Textus::Manifest#validate_keys!` removed (had no callers).
+
+### Internal
+
+- Builder logic fully extracted into `Application::Writes::Build`.
+- CLI verbs now share `context_for(store)` / `resolved_role(store)`
+  helpers on `CLI::Verb`.
+- Internal helpers in `Manifest`, `Doctor`, and `Manifest::Entry` are
+  properly marked private.
+
+### Unchanged
+
+- Wire protocol stays `textus/2`. Envelope shape unchanged.
+- CLI verbs, their flags, and their JSON output shape — unchanged.
+- Manifest YAML schema — unchanged.
+- Event names — unchanged (payload gains `correlation_id` on `:built` /
+  `:published`, but no existing key is removed or renamed).
+- Hook DSL — unchanged in shape. The `store:` keyword still passes an
+  object that responds to `.get`, `.list`, `.where`. The Context's
+  role-aware `with_role` is the recommended construction site for hook
+  contexts now.
+
+### Migration recipe
+
+```ruby
+# Hook handlers — before 0.10.0
+Textus.hook(:intake, :my_hook) do |store:, config:, args:|
+  store.put("inbox.foo", meta: { ... }, body: "...")  # used Context shim
+end
+
+# Hook handlers — 0.10.0+
+Textus.hook(:intake, :my_hook) do |store:, config:, args:|
+  ctx = store  # rename for clarity if desired
+  ctx.store.put("inbox.foo", meta: { ... }, body: "...", as: ctx.role)
+end
+
+# Intake handler returns — before 0.10.0
+{ frontmatter: { ... }, body: "..." }  # legacy key
+
+# Intake handler returns — 0.10.0+
+{ _meta: { ... }, body: "..." }  # _meta is the canonical key
+```
+
+If you imported the removed constants directly:
+
+```ruby
+# Before
+Textus::Publisher        # removed
+Textus::Store::View      # removed
+Textus::Builder.new(store).build(key, ...)  # removed
+
+# After
+Textus::Infra::Publisher
+Textus::Application::Context  # via Composition.context(store, role:)
+Textus::Composition.writes_build(ctx).call(key, ...)
+```
+
 ## 0.9.2 — Policies, audit verbs, zone rename (2026-05-22)
 
 ### Breaking — manifest YAML

data/lib/textus/application/context.rb

@@ -39,30 +39,6 @@ module Textus
           dry_run: @dry_run,
         )
       end
-
-      # Backward-compat for intake handlers receiving a Context (was Store::View)
-      # that call store.put/get/delete on it. Slated for removal in 0.10.0.
-      def put(key, **opts)
-        opts[:as] ||= role
-        store.put(key, **opts)
-      end
-
-      def delete(key, **opts)
-        opts[:as] ||= role
-        store.delete(key, **opts)
-      end
-
-      def get(key, **)
-        store.get(key, **)
-      end
-
-      def list(*, **)
-        store.list(*, **)
-      end
-
-      def where(*, **)
-        store.where(*, **)
-      end
     end
   end
 end

data/lib/textus/application/refresh/orchestrator.rb

@@ -2,11 +2,12 @@ module Textus
   module Application
     module Refresh
       class Orchestrator
-        def initialize(worker:, bus:, store_root:, store: nil, detached_spawner: nil)
+        def initialize(worker:, bus:, store_root:, store: nil, role: "human", detached_spawner: nil)
           @worker = worker
           @bus = bus
           @store_root = store_root
           @store = store
+          @role = role
           @detached_spawner = detached_spawner || default_spawner
         end
 
@@ -46,7 +47,7 @@ module Textus
 
           if thread.alive?
             thread.kill
-            store_view = @store ? Textus::Store::View.new(@store) : nil
+            store_view = @store ? Textus::Application::Context.new(store: @store, role: @role) : nil
             payload = { key: key, started_at: Time.now.utc.iso8601, budget_ms: budget_ms }
             payload[:store] = store_view if store_view
             @bus.publish(:refresh_detached, **payload)

data/lib/textus/application/refresh/worker.rb

@@ -23,7 +23,7 @@ module Textus
         private
 
         def read_view
-          Store::View.new(@ctx.store)
+          Application::Context.new(store: @ctx.store, role: @ctx.role)
         end
 
         def fetch_with_bus(key, mentry)

data/lib/textus/application/writes/accept.rb

@@ -17,6 +17,8 @@ module Textus
 
           case action
           when "put"
+            # Nested proposal "frontmatter" — the meta to write to the accepted
+            # target. Not related to the removed intake-handler legacy bridge.
             target_meta = env["_meta"]["frontmatter"] || {}
             target_body = env["body"]
             Composition.writes_put(@ctx).call(target, meta: target_meta, body: target_body)
@@ -28,9 +30,8 @@ module Textus
 
           Composition.writes_delete(@ctx).call(pending_key)
 
-          store_view = Store::View.new(@ctx.store)
           @bus.publish(:accepted,
-                       store: store_view,
+                       store: @ctx.with_role(@ctx.role),
                        key: pending_key,
                        target_key: target,
                        correlation_id: @ctx.correlation_id)

data/lib/textus/application/writes/build.rb

@@ -1,6 +1,12 @@
+require "fileutils"
+
 module Textus
   module Application
     module Writes
+      # Materializes generator-zone entries (template + projection) onto disk
+      # and copies the result to any configured `publish_to` / `publish_each`
+      # targets. Fires `:built` and `:published` events on the bus, tagged with
+      # the request's correlation_id for traceability.
       class Build
         def initialize(ctx:, bus:)
           @ctx = ctx
@@ -8,15 +14,101 @@ module Textus
         end
 
         def call(prefix: nil)
-          # Delegate to legacy Builder for the materialization/projection logic.
-          # Builder fires its own events through @store.fire_event; we do NOT
-          # double-fire from here. Full extraction of Builder internals into
-          # Writes::Build is deferred to 0.10.0.
-          #
-          # TODO(0.10.0): propagate @ctx.correlation_id through :built/:published
-          # events once Builder internals are extracted into this use case.
-          legacy = Textus::Builder.new(@ctx.store)
-          legacy.build(prefix: prefix)
+          built = []
+          manifest.entries.each do |mentry|
+            next unless mentry.in_generator_zone?
+            next unless mentry.projection || mentry.template
+            next if prefix && !mentry.key.start_with?(prefix)
+
+            built << materialize(mentry)
+          end
+          published_leaves = publish_leaves(prefix: prefix)
+          { "protocol" => Textus::PROTOCOL, "built" => built, "published_leaves" => published_leaves }
+        end
+
+        private
+
+        def store = @ctx.store
+        def manifest = store.manifest
+        def root = store.root
+
+        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)
+          publish_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 materialize(mentry)
+          target_path = Builder::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)
+            publish_event(:published,
+                          key: mentry.key,
+                          envelope: envelope,
+                          source: target_path,
+                          target: target_abs)
+          end
+
+          publish_event(:built,
+                        key: mentry.key,
+                        envelope: envelope,
+                        sources: Array(mentry.projection&.fetch("select", nil)).compact)
+        end
+
+        def publish_event(event, **payload)
+          # `with_role` returns a Context that preserves the original
+          # correlation_id, so hooks reading `store.correlation_id` see the
+          # same value as the event's top-level correlation_id key.
+          @bus.publish(event, store: @ctx.with_role(@ctx.role), correlation_id: @ctx.correlation_id, **payload)
         end
       end
     end

data/lib/textus/application/writes/delete.rb

@@ -22,9 +22,8 @@ module Textus
           )
 
           unless suppress_events
-            store_view = Store::View.new(@ctx.store)
             @bus.publish(:deleted,
-                         store: store_view,
+                         store: @ctx.with_role(@ctx.role),
                          key: key,
                          correlation_id: @ctx.correlation_id)
           end

data/lib/textus/application/writes/put.rb

@@ -28,9 +28,8 @@ module Textus
           )
 
           unless suppress_events
-            store_view = Store::View.new(@ctx.store)
             @bus.publish(:put,
-                         store: store_view,
+                         store: @ctx.with_role(@ctx.role),
                          key: key,
                          envelope: envelope,
                          correlation_id: @ctx.correlation_id)

data/lib/textus/builder/pipeline.rb

@@ -2,7 +2,7 @@ require "fileutils"
 require "time"
 
 module Textus
-  class Builder
+  module Builder
     module InjectMeta
       # Returns a new hash with _meta as the first key, per SPEC §6 ordering.
       def self.call(content_hash, mentry)

data/lib/textus/builder/renderer/json.rb

@@ -1,7 +1,7 @@
 require "json"
 
 module Textus
-  class Builder
+  module Builder
     class Renderer
       class Json < Renderer
         def call(mentry:, data:)

data/lib/textus/builder/renderer/markdown.rb

@@ -1,7 +1,7 @@
 require "time"
 
 module Textus
-  class Builder
+  module Builder
     class Renderer
       class Markdown < Renderer
         def call(mentry:, data:)

data/lib/textus/builder/renderer/text.rb

@@ -1,5 +1,5 @@
 module Textus
-  class Builder
+  module Builder
     class Renderer
       class Text < Renderer
         def call(mentry:, data:)

data/lib/textus/builder/renderer/yaml.rb

@@ -1,7 +1,7 @@
 require "yaml"
 
 module Textus
-  class Builder
+  module Builder
     class Renderer
       class Yaml < Renderer
         def call(mentry:, data:)

data/lib/textus/builder/renderer.rb

@@ -1,5 +1,5 @@
 module Textus
-  class Builder
+  module Builder
     # Abstract base for output renderers. Each concrete renderer owns
     # producing the bytes for one manifest format (markdown/json/yaml/text).
     class Renderer

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

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("accept 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.writes_accept(ctx).call(key))
         end
       end

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

@@ -11,8 +11,7 @@ module Textus
         option :limit, "--limit=N"
 
         def call(store)
-          role = Role.resolve(flag: nil, env: ENV, root: store.root)
-          ctx = Textus::Composition.context(store, role: role)
+          ctx = context_for(store)
           since_time = since && Textus::Application::Reads::Audit.parse_since(since, now: ctx.now)
           rows = Textus::Composition.audit(ctx).call(
             key: key_filter,

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

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("blame requires a key")
-          role = Role.resolve(flag: nil, env: ENV, root: store.root)
-          ctx = Textus::Composition.context(store, role: role)
+          ctx = context_for(store)
           rows = Textus::Composition.blame(ctx).call(key: key, limit: limit&.to_i)
           emit({ "verb" => "blame", "key" => key, "rows" => rows })
         end

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

@@ -7,8 +7,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("delete 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.writes_delete(ctx).call(key, if_etag: if_etag))
         end
       end

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.0"
   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.0
 platform: ruby
 authors:
 - Patrick
@@ -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/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