textus 0.41.0 → 0.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4991eadd244e9ced0531683c7a40f27b88b825e23e8d0bd5ad5be7f91716e4c9
-  data.tar.gz: d3e8d18c1e360455aef19bd7168b0ffb4516c54d0004253f34af78940752120d
+  metadata.gz: 36d711f8c5947548e8f2431cfded1a514596af239b4eb6e91a3d3d0a6f20c83e
+  data.tar.gz: 33496ad8d0d862655cddbc47c36fd4c3ccf01f7e1b37dea06ee1fc24062be51c
 SHA512:
-  metadata.gz: f0f63a06265e280a8424476dff4941dfc0de016f68a9530ed53799429115416fea50f9f9479266baecd8d34c96e3bece97e1d97ab35446dd0dcb4cb2c7f61771
-  data.tar.gz: 4cbfee016952dcc19312097018b18b63b8515d59786fddafc81d4a696737cbd3bd32f1d3dd45beae6d8660495c631defe70d324344c274ce02d505a3285ae8df
+  metadata.gz: 6b5b84af6db5f692db3b27f3b029348ab80d7bc9e05d2ebf74d32b9fc9b29d497fb275b508725b8437549f75bc69c1de01818ccc2d1eee4dc2af79cfa292e6dc
+  data.tar.gz: 99f9c63b92f629bd37956a79a303fcc081997d81afe96a85d804d806831388f9d6821b66c449299f82c7f27422e97ada2759518be6062061a45acb8db043d7c9

data/CHANGELOG.md

@@ -9,6 +9,14 @@ The **gem version** (`0.x.y`) is distinct from the **protocol version**
 bump is a breaking change that requires a store migration; the gem version
 tracks both additive improvements and breaking protocol bumps independently.
 
+## 0.42.0 — 2026-06-02 — Remove `publish_each`: collapse publish to two modes ([ADR 0051](docs/architecture/decisions/0051-remove-publish-each.md))
+
+No `textus/3` wire-format change. **Breaking (pre-1.0):** the `publish_each:` manifest key is removed; a manifest declaring it now fails at load. The publish surface collapses to two modes — `publish_to:` (fixed paths) and `publish_tree:` (whole-subtree mirror) — plus `None`.
+
+### Removed
+
+- **BREAKING (pre-1.0): the `publish_each:` publish mode is removed ([ADR 0051](docs/architecture/decisions/0051-remove-publish-each.md)).** Both the file-leaf and directory-leaf (`index_filename`-driven) forms of `publish_each` are gone, along with the `Publish::Each` / `EachFile` / `EachDir` modes and their `{leaf}`/`{basename}`/`{key}`/`{ext}` template vocabulary. The mode had zero real-world usage (dogfood, example, and `init` scaffold all publish via `publish_to`), and its one niche — a leaf that is both an addressable key *and* published to a per-leaf templated path — never materialized, including in the native skill-authoring pipeline (ADR 0050), which rides `publish_tree`. A manifest declaring `publish_each:` now **fails at load** with a migration message ("publish_each was removed in 0.42.0 (ADR 0051) — mirror the subtree with publish_tree (and index_filename to keep the index addressable)"). **Migration:** a directory-leaf `publish_each: "skills/{leaf}"` over a `nested` skills entry becomes `publish_tree: "skills"` over the parent entry (layout preserved). `index_filename:` is **kept** — it survives as a pure *enumeration* feature, independent of publish. The ADR 0049 sum type makes re-adding one subtree mode (or lifting `index_filename` ⊥ `publish_tree` so the two compose) a cheap one-arm change if the niche ever appears.
+
 ## 0.41.0 — 2026-06-02 — `publish_tree` subtree mirror + content-identical publish adoption ([ADR 0047](docs/architecture/decisions/0047-publish-tree-keyless-subtree-mirror.md), [0050](docs/architecture/decisions/0050-native-authoring-and-content-identical-adoption.md))
 
 No `textus/3` wire-format change — every change here is repo-local publish behaviour or internal re-layering. Headlines: a key-less `publish_tree:` subtree mirror (ADR 0047), and publish now *adopts* a byte-identical pre-existing target instead of refusing (ADR 0050), so an artifact tree already on disk onboards without a manual delete. Internals were re-cut along the way (fetch subsystem, ADR 0048; publish modes as a sum type, ADR 0049) with no contract change.

data/README.md

@@ -182,7 +182,7 @@ For a worked store — knowledge entries, a staged proposal, schemas, a template
 
 ## What's shipped
 
-- **Per-entry formats & publish.** `format: markdown|json|yaml|text` per entry; `publish_to:`/`publish_each:` byte-copy derived files to their consumer paths. ([SPEC §5.2–5.3](SPEC.md))
+- **Per-entry formats & publish.** `format: markdown|json|yaml|text` per entry; `publish_to:`/`publish_tree:` byte-copy derived files (or a whole subtree) to their consumer paths. ([SPEC §5.2–5.3](SPEC.md))
 - **Stable identity.** Auto-minted `uid:` survives writes and `textus key mv`; reorganising never breaks references.
 - **Capability × zone-kind gate.** Writes carry `--as=<role>`; a role may write a zone iff it holds the capability the zone's `kind:` requires (`canon`→`author`, `workspace`→`keep`, `quarantine`→`fetch`, `queue`→`propose`, `derived`→`build`). The wrong role gets `write_forbidden` naming the capability needed and the roles that hold it. ([SPEC §5](SPEC.md))
 - **Agent loop.** `textus boot` orients a fresh session; `textus pulse --since=N` is the per-turn heartbeat (changed entries, stale keys, pending proposals). ([docs/how-to/agents-mcp.md](docs/how-to/agents-mcp.md))
@@ -203,7 +203,7 @@ Derived entries declare `compute: { kind: projection, select: ..., pluck: ..., s
 
 For externally-generated entries, declare `compute: { kind: external, sources: [...] }` — textus tracks the declared sources for staleness; the build automation produces the file.
 
-`publish_to: [path]` byte-copies a single derived file to one target. `publish_each: "template/{basename}.md"` on a nested entry byte-copies every leaf to its templated target — substitutes `{leaf}`, `{basename}`, `{key}`, `{ext}`. Sentinels for every published file live under `.textus/sentinels/`. See SPEC §5.2, §5.3, §5.12.
+`publish_to: [path]` byte-copies a single derived file to one or more targets. `publish_tree: "dir"` on a nested entry mirrors its whole stored subtree to one target directory, preserving layout (path-driven — no keys or template variables). Sentinels for every published file live under `.textus/sentinels/`. See SPEC §5.2, §5.3, §5.12.
 
 ## Extension points
 

data/SPEC.md

@@ -240,41 +240,9 @@ For `nested: true`, the recursive glob matches the format's extension (markdown
   index_filename: SKILL.md
 ```
 
-A file at `.textus/zones/skills/ask/SKILL.md` enumerates as `skills.ask`; `.textus/zones/skills/ask/references/algorithm.md` is not enumerated. Resolving `skills.ask` returns the `SKILL.md` path. `index_filename:` requires `nested: true`; the value must be a bare basename (no slashes).
+A file at `.textus/zones/skills/ask/SKILL.md` enumerates as `skills.ask`; `.textus/zones/skills/ask/references/algorithm.md` is not enumerated. Resolving `skills.ask` returns the `SKILL.md` path. `index_filename:` requires `nested: true`; the value must be a bare basename (no slashes). `index_filename:` is a pure *enumeration* feature — it selects which file is the addressable row per directory and is independent of publishing (ADR 0051).
 
-**Per-leaf publishing (`publish_each:`).** A nested manifest entry MAY declare `publish_each:` to copy every leaf to a templated repo-relative path. `publish_each:` and `publish_to:` are mutually exclusive on the same entry, and `publish_each:` requires `nested: true`. The template substitutes these variables (using `{name}` syntax):
-
-| Variable     | Value                                                                                  |
-|--------------|----------------------------------------------------------------------------------------|
-| `{leaf}`     | Remaining key segments after the entry prefix, joined with `/`.                        |
-| `{basename}` | Last segment only.                                                                     |
-| `{key}`      | Full dotted key.                                                                       |
-| `{ext}`      | Primary extension for the entry's format, without the leading dot (`md`/`json`/`yaml`/`txt`). |
-
-The publish *unit* is derived from the entry's shape, which `index_filename:` already declares (ADR 0046) — there is no separate tree-vs-file key:
-
-- **Entry *without* `index_filename`** — a leaf is a *file*. `publish_each:` names a file target and one file is byte-copied per leaf.
-- **Entry *with* `index_filename`** — a leaf is a *directory*. `publish_each:` names a directory target, and the **whole leaf subtree** is copied: every file under the leaf directory (the index plus its siblings) is byte-copied to `<target_dir>/<path-relative-to-leaf>`, preserving in-leaf layout. Siblings are opaque payload — they are never enumerated, addressable, or proposable; only the index is a key. The entry's `ignore:` globs (§4, ADR 0042) filter the copied set. Each copied file gets its own sentinel. On rebuild, files under the target that are textus-managed but no longer produced by the current source are **pruned** (file + sentinel); files with no sentinel are never deleted.
-
-Validation at manifest load: any unknown variable raises `UsageError`; a computed target outside the repo root is refused at build time with `PublishError`. The discriminator requirement depends on the leaf shape:
-
-- **File-leaf** templates MUST reference at least one of `{leaf}`, `{basename}`, `{key}` (otherwise every leaf would clobber the same target).
-- **Directory-leaf** templates (entry has `index_filename`) MUST reference `{leaf}` or `{key}`, and MUST NOT use `{basename}` or `{ext}` (file-only). Because the target is a directory, the template's final segment MUST NOT be the `index_filename` (the `.../{leaf}/SKILL.md` footgun — it would copy the subtree into a directory literally named `SKILL.md/`) and MUST NOT carry a file extension (e.g. `.../{leaf}.md`); both are rejected at load with a fix-the-template message.
-
-```yaml
-- key: working.skills
-  path: working/skills
-  zone: working
-  schema: skill
-  nested: true
-  index_filename: SKILL.md
-  publish_each: "skills/{leaf}"
-  ignore: ["*.tmp", ".DS_Store"]
-```
-
-A leaf at `working.skills.voice-writer` (a directory `.textus/zones/working/skills/voice-writer/` containing `SKILL.md`, `commands.md`, and `references/*`) publishes its whole subtree under `skills/voice-writer/`, preserving layout.
-
-**Subtree mirror (`publish_tree:`).** A nested manifest entry MAY declare `publish_tree:` to mirror its entire stored subtree (`zones/<path>/**`) to a single target directory, preserving relative layout (case and extension preserved). Unlike `publish_each:`, it is **path-driven, not key-driven**: no keys are enumerated, no template variables are interpreted, and the mirrored files are opaque payload (never addressable). The entry's `ignore:` globs (§4, ADR 0042) filter the walk; each mirrored file gets its own sentinel; and on every build the whole target directory is pruned of textus-managed files the current source no longer produces (unmanaged files are never touched). `publish_tree:` is mutually exclusive with `publish_to:` and `publish_each:`, and incompatible with `index_filename:`. When a `publish_tree:` target directory overlaps a `derived` entry's `publish_to:` (e.g. a derived `SKILL.md` written into the mirrored dir), the `publish_tree:` entry **must** `ignore:` that filename or prune will delete it — `doctor` flags this as `publish.tree_index_overlap`. See ADR 0047.
+**Subtree mirror (`publish_tree:`).** A nested manifest entry MAY declare `publish_tree:` to mirror its entire stored subtree (`zones/<path>/**`) to a single target directory, preserving relative layout (case and extension preserved). It is **path-driven, not key-driven**: no keys are enumerated, no template variables are interpreted, and the mirrored files are opaque payload (never addressable). The entry's `ignore:` globs (§4, ADR 0042) filter the walk; each mirrored file gets its own sentinel; and on every build the whole target directory is pruned of textus-managed files the current source no longer produces (unmanaged files are never touched). `publish_tree:` is mutually exclusive with `publish_to:`, and incompatible with `index_filename:`. When a `publish_tree:` target directory overlaps a `derived` entry's `publish_to:` (e.g. a derived `SKILL.md` written into the mirrored dir), the `publish_tree:` entry **must** `ignore:` that filename or prune will delete it — `doctor` flags this as `publish.tree_index_overlap`. See ADR 0047.
 
 ```yaml
 - key: working.skills
@@ -490,9 +458,7 @@ When the entry is recomputed, textus copies the in-store file byte-for-byte to e
 
 A sentinel is written for each published file at `<store_root>/sentinels/<target-relative-to-repo>.textus-managed.json`, recording `source`, `target`, the target's sha256, and `mode: "copy"`. Sentinels live under the store rather than beside the consumer file so target directories stay clean. The sentinel exists so out-of-band edits can be detected on the next publish — textus refuses to clobber a destination that is not either missing, marked as managed, or **byte-identical to the source being published**. An identical destination is *adopted*: its sentinel is written and management proceeds (the copy is a content no-op), so an artifact tree already on disk onboards without a manual delete. An unmanaged destination whose content **differs**, or any unmanaged symlink, is still refused (ADR 0050). Legacy sibling sentinels (`<target>.textus-managed.json`) are still recognised as managed and are migrated to the new location on the next publish.
 
-**Per-leaf publishing.** A nested entry MAY declare `publish_each:` instead of `publish_to:` (see §4). When the build runs, every leaf reachable under the nested entry is copied to the path produced by substituting `{leaf}` / `{basename}` / `{key}` / `{ext}` in the template, with a sentinel written under `<store_root>/sentinels/` at the mirrored target path. The publish unit follows the entry's `index_filename` (ADR 0046): a file-leaf entry byte-copies one file per leaf; a directory-leaf entry (with `index_filename`) byte-copies the leaf's whole subtree — one row and one sentinel **per file** — applying the entry's `ignore:` filter, and prunes textus-managed files under the target that the current source no longer produces (never touching unmanaged files). The build envelope grows a `published_leaves` array — one row per published file, with `key`, `source`, and `target` — alongside the existing `built` array, plus a `pruned` array listing any orphaned managed files removed on this build. Targets that would resolve outside the repo root are refused.
-
-**Subtree mirror.** A nested entry MAY declare `publish_tree:` instead of `publish_to:` or `publish_each:` (see §4). On every build, textus walks the entry's full stored subtree (`zones/<path>/**`), applies the entry's `ignore:` filter, and byte-copies each file to the target directory, preserving relative layout — one sentinel per file under `<store_root>/sentinels/`. The mirror is path-driven: no keys are enumerated, no template variables are interpreted, and mirrored files are opaque payload (never addressable). On rebuild, the entire target directory is pruned of textus-managed files the current source no longer produces; unmanaged files are never touched. `publish_tree:` is mutually exclusive with `publish_to:` and `publish_each:`, and incompatible with `index_filename:`. When a `publish_tree:` target overlaps a `derived` entry's `publish_to:` (e.g. a derived `SKILL.md` written into the mirrored dir), the `publish_tree:` entry must `ignore:` that filename or prune will delete it — `doctor` flags this as `publish.tree_index_overlap` (ADR 0047).
+**Subtree mirror.** A nested entry MAY declare `publish_tree:` instead of `publish_to:` (see §4). On every build, textus walks the entry's full stored subtree (`zones/<path>/**`), applies the entry's `ignore:` filter, and byte-copies each file to the target directory, preserving relative layout — one sentinel per file under `<store_root>/sentinels/`. The mirror is path-driven: no keys are enumerated, no template variables are interpreted, and mirrored files are opaque payload (never addressable). On rebuild, the entire target directory is pruned of textus-managed files the current source no longer produces; unmanaged files are never touched. The build envelope grows a `published_leaves` array — one row per mirrored file, with `key`, `source`, and `target` — alongside the existing `built` array, plus a `pruned` array listing any orphaned managed files removed on this build. `publish_tree:` is mutually exclusive with `publish_to:`, and incompatible with `index_filename:`. Targets that would resolve outside the repo root are refused. When a `publish_tree:` target overlaps a `derived` entry's `publish_to:` (e.g. a derived `SKILL.md` written into the mirrored dir), the `publish_tree:` entry must `ignore:` that filename or prune will delete it — `doctor` flags this as `publish.tree_index_overlap` (ADR 0047).
 
 ### 5.4 Intake (declared, fetched via registered intake handler)
 

data/docs/reference/conventions.md

@@ -83,7 +83,7 @@ A derived entry declares a `compute:` block with a `kind:` discriminator. Two ki
 
 The build automation is responsible for writing the `generated:` frontmatter block (`by`, `at`, `from`) when it produces the file. `generated.from` SHOULD match `compute.sources` — same list, recorded twice so a diff proves what was consumed.
 
-Full contract for both shapes is in [`../../SPEC.md` §5.2.1 and §5.2.2](../../SPEC.md). Transforms (`compute.transform:`) and per-leaf publishing (`publish_each:`) are also covered there.
+Full contract for both shapes is in [`../../SPEC.md` §5.2.1 and §5.2.2](../../SPEC.md). Transforms (`compute.transform:`) and subtree publishing (`publish_tree:`) are also covered there.
 
 ## Intake and freshness
 

data/lib/textus/boot.rb

@@ -87,7 +87,7 @@ module Textus
       { "name" => "accept",   "summary" => "apply a queued proposal to its target zone; requires the author capability" },
       { "name" => "key",      "summary" => "key operations: 'key mv', 'key uid'" },
       { "name" => "delete",   "summary" => "delete an entry; --as=<role>" },
-      { "name" => "build",    "summary" => "materialize derived entries; publish_to and publish_each fan out copies" },
+      { "name" => "build",    "summary" => "materialize derived entries; publish_to and publish_tree fan out copies" },
       { "name" => "fetch" },
       { "name" => "freshness", "summary" => "per-entry freshness report (status, age, ttl, on_stale)" },
       { "name" => "audit",    "summary" => "query .textus/audit.log with filters (key, role, since, correlation-id, ...)" },
@@ -225,7 +225,6 @@ module Textus
           "derived" => derived,
           "intake" => e.is_a?(Textus::Manifest::Entry::Intake),
           "publish_to" => Array(e.publish_to),
-          "publish_each" => e.publish_each,
         }
       end
     end

data/lib/textus/manifest/entry/base.rb

@@ -43,7 +43,6 @@ module Textus
         def template       = nil
         def inject_boot    = false # rubocop:disable Naming/PredicateMethod
         def events         = {}
-        def publish_each   = nil
         def publish_tree   = nil
         def index_filename = nil
         def ignore         = []

data/lib/textus/manifest/entry/nested.rb

@@ -6,12 +6,11 @@ module Textus
       # Entry::Publish::* — Nested is just the value (attributes + ignore
       # predicate) those modes read.
       class Nested < Base
-        attr_reader :index_filename, :publish_each, :publish_tree, :ignore
+        attr_reader :index_filename, :publish_tree, :ignore
 
-        def initialize(index_filename: nil, publish_each: nil, publish_tree: nil, ignore: nil, **rest)
+        def initialize(index_filename: nil, publish_tree: nil, ignore: nil, **rest)
           super(**rest)
           @index_filename = index_filename
-          @publish_each = publish_each
           @publish_tree = publish_tree
           @ignore = Array(ignore)
         end
@@ -28,7 +27,6 @@ module Textus
         def self.from_raw(common, raw)
           new(
             index_filename: raw["index_filename"],
-            publish_each: raw["publish_each"],
             publish_tree: raw["publish_tree"],
             ignore: raw["ignore"],
             **common,

data/lib/textus/manifest/entry/publish/subtree_mirror.rb

@@ -2,12 +2,12 @@ module Textus
   class Manifest
     class Entry
       module Publish
-        # ADR 0049: the one walk->publish->prune pipeline shared by EachDir
-        # (per-leaf subtree, ADR 0046) and Tree (whole-entry mirror, ADR 0047).
-        # The two used to be near-duplicate methods (publish_subtree +
-        # publish_tree_via, prune_orphans + prune_tree); their only real
-        # difference — whether the prune honors the entry's `ignore` — is now the
-        # explicit `prune_honors_ignore:` parameter.
+        # ADR 0049: the one walk->publish->prune pipeline behind Tree (whole-entry
+        # mirror, ADR 0047). It was once shared with the per-leaf publish_each
+        # mode too; ADR 0051 removed publish_each, leaving Tree the only caller.
+        # The `walk_root`/`prune_honors_ignore:` parameters survive from that
+        # shared shape — Tree always walks at `base` and honors `ignore` in the
+        # prune (ADR 0047 D4, so a derived index in the mirrored dir survives).
         class SubtreeMirror
           def initialize(entry, pctx)
             @entry = entry
@@ -16,8 +16,8 @@ module Textus
 
           # base:       store dir the entry owns — the root `ignored?` globs are
           #             relative to (ADR 0042).
-          # walk_root:  dir the glob is rooted at (a single leaf dir for EachDir,
-          #             == base for Tree). dst paths mirror rel-to-walk_root.
+          # walk_root:  dir the glob is rooted at (== base for Tree). dst paths
+          #             mirror rel-to-walk_root.
           # target_dir: repo-side destination root.
           # key/envelope: emitted per file; envelope is nil for the keyless Tree.
           # prune_honors_ignore: when true a managed file the entry `ignore`s

data/lib/textus/manifest/entry/publish/template.rb

@@ -2,19 +2,13 @@ module Textus
   class Manifest
     class Entry
       module Publish
-        # The publish_each template vocabulary. A publish_each value is a path
-        # with `{leaf}`, `{basename}`, `{key}`, `{ext}` placeholders; a
-        # publish_tree value must be a plain path (any var is an error), so the
-        # modes reuse VAR_RE to detect stray vars there too.
+        # Template-variable detection for publish targets. The only surviving
+        # use after ADR 0051 (which removed publish_each and its `{leaf}`/
+        # `{basename}`/`{key}`/`{ext}` vocabulary) is Tree.validate!, which uses
+        # VAR_RE to reject any `{var}` in a publish_tree value — that key names a
+        # single directory by plain path and interprets no variables.
         module Template
-          KNOWN_VARS = %w[leaf basename key ext].freeze
           VAR_RE = /\{([a-z]+)\}/
-          REQUIRED_DISCRIMINATOR_VARS = %w[leaf basename key].freeze
-
-          # Substitute `{var}` placeholders from a string-keyed hash.
-          def self.expand(template, vars)
-            template.gsub(VAR_RE) { vars.fetch(::Regexp.last_match(1)) }
-          end
         end
       end
     end

data/lib/textus/manifest/entry/publish.rb

@@ -1,24 +1,25 @@
 module Textus
   class Manifest
     class Entry
-      # ADR 0049: the publish design is a three-key concept (ADR 0047 table)
+      # ADR 0049: the publish design is a key-split concept (ADR 0047 table)
       # realized as one resolved sum type. Each directory entry resolves, once,
       # to one Publish::* mode that owns its publish algorithm — no nil-cascade,
-      # no pairwise exclusivity guards, one shared subtree mirror.
+      # no pairwise exclusivity guards, one shared subtree mirror. ADR 0051
+      # removed `publish_each` (both leaf modes); the surface is now two modes:
       #
       #   None      — nothing to publish
       #   ToPaths   — publish_to: 1 stored file -> N fixed repo paths
-      #   EachFile  — publish_each (file leaves): 1 leaf file -> 1 templated path
-      #   EachDir   — publish_each + index_filename: 1 leaf subtree -> 1 templated dir
       #   Tree      — publish_tree: whole entry subtree -> 1 dir, no keys
       module Publish
         # Resolve an entry to its single publish mode. Raises one UsageError if
-        # more than one of {publish_to, publish_each, publish_tree} is set —
-        # exclusivity is structural here, not four scattered pairwise guards.
+        # both publish_to and publish_tree are set — exclusivity is structural
+        # here, not scattered pairwise guards. A removed `publish_each:` key is
+        # rejected loudly with its replacement (ADR 0051).
         def self.resolve(entry)
+          reject_removed_publish_each(entry)
+
           set = []
           set << "publish_to"   unless Array(entry.publish_to).empty?
-          set << "publish_each" unless entry.publish_each.nil?
           set << "publish_tree" unless entry.publish_tree.nil?
 
           if set.length > 1
@@ -30,11 +31,20 @@ module Textus
           mode_for(entry, set.first)
         end
 
+        def self.reject_removed_publish_each(entry)
+          return unless entry.raw["publish_each"]
+
+          raise Textus::UsageError.new(
+            "entry '#{entry.key}': publish_each was removed in 0.42.0 (ADR 0051) — " \
+            "mirror the subtree with publish_tree (and index_filename to keep the index addressable).",
+          )
+        end
+        private_class_method :reject_removed_publish_each
+
         def self.mode_for(entry, key)
           case key
           when "publish_to"   then ToPaths.new(entry)
           when "publish_tree" then Tree.new(entry)
-          when "publish_each" then entry.index_filename ? EachDir.new(entry) : EachFile.new(entry)
           else None.new(entry)
           end
         end

data/lib/textus/manifest/entry/validators/publish.rb

@@ -5,15 +5,15 @@ module Textus
         # ADR 0049: one publish validator. Exclusivity among the publish keys is
         # enforced structurally by Publish.resolve (reached via #publish_mode),
         # and each mode's shape rules run *because that mode resolved* — replacing
-        # the four scattered pairwise "not-both" guards of the old PublishEach +
+        # the scattered pairwise "not-both" guards of the old PublishEach +
         # PublishTree validators. Misuse on a non-nested entry is still caught
-        # here from raw, since the typed attrs stub nil on Base.
+        # here from raw, since the typed attrs stub nil on Base. (publish_each was
+        # removed in 0.42.0 — ADR 0051; Schema rejects it at load.)
         module Publish
           def self.call(entry, policy: nil) # rubocop:disable Lint/UnusedMethodArgument
             unless entry.nested?
-              %w[publish_each publish_tree].each do |key|
-                raise UsageError.new("entry '#{entry.key}': #{key} requires nested: true") if entry.raw[key]
-              end
+              raise UsageError.new("entry '#{entry.key}': publish_tree requires nested: true") if entry.raw["publish_tree"]
+
               return
             end
 

data/lib/textus/manifest/schema.rb

@@ -24,7 +24,7 @@ module Textus
       KIND_REQUIRES_VERB = LANES
       ENTRY_KEYS = %w[
         key path zone kind schema owner nested format
-        compute template publish_to publish_each publish_tree
+        compute template publish_to publish_tree
         intake events inject_boot index_filename ignore tracked
       ].freeze
       COMPUTE_KEYS = %w[kind select pluck sort_by limit transform command sources].freeze
@@ -73,12 +73,25 @@ module Textus
       def self.validate_entries!(entries)
         Array(entries).each_with_index do |e, i|
           path = "$.entries[#{i}]"
+          reject_removed_publish_each!(e, path)
           walk(e, ENTRY_KEYS, path)
           walk(e["compute"], COMPUTE_KEYS, "#{path}.compute") if e["compute"].is_a?(Hash)
           walk(e["intake"], INTAKE_KEYS, "#{path}.intake") if e["intake"].is_a?(Hash)
         end
       end
 
+      # publish_each was removed in 0.42.0 (ADR 0051). It is no longer an allowed
+      # entry key, so `walk` would reject it as merely "unknown"; intercept it
+      # first with the migration path so a pre-0.42 manifest gets a useful error.
+      def self.reject_removed_publish_each!(entry, path)
+        return unless entry.is_a?(Hash) && entry.key?("publish_each")
+
+        raise BadManifest.new(
+          "publish_each was removed in 0.42.0 (ADR 0051) at '#{path}' — " \
+          "mirror the subtree with publish_tree (and index_filename to keep the index addressable).",
+        )
+      end
+
       def self.validate_rules!(rules)
         Array(rules).each_with_index do |r, i|
           path = "$.rules[#{i}]"

data/lib/textus/version.rb

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

data/lib/textus/write/publish.rb

@@ -2,9 +2,9 @@ module Textus
   module Write
     # Single-pass publish use case: dispatches polymorphically to each
     # entry's `publish_via` method. Derived entries materialize their body
-    # via Materializer; Nested entries fan out via publish_each; Leaf and
-    # Intake entries copy their stored body to publish_to targets. The
-    # Publish layer owns wiring (context, accumulation) but not per-kind
+    # via Materializer; Nested entries mirror their subtree via publish_tree;
+    # Leaf and Intake entries copy their stored body to publish_to targets.
+    # The Publish layer owns wiring (context, accumulation) but not per-kind
     # logic.
     #
     # Return shape: { "protocol", "built", "published_leaves" }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.41.0
+  version: 0.42.0
 platform: ruby
 authors:
 - Patrick
@@ -261,9 +261,6 @@ files:
 - lib/textus/manifest/entry/nested.rb
 - lib/textus/manifest/entry/parser.rb
 - lib/textus/manifest/entry/publish.rb
-- lib/textus/manifest/entry/publish/each.rb
-- lib/textus/manifest/entry/publish/each_dir.rb
-- lib/textus/manifest/entry/publish/each_file.rb
 - lib/textus/manifest/entry/publish/mode.rb
 - lib/textus/manifest/entry/publish/none.rb
 - lib/textus/manifest/entry/publish/subtree_mirror.rb

data/lib/textus/manifest/entry/publish/each.rb

@@ -1,83 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Publish
-        # Shared base for the two key-driven publish_each modes (EachFile,
-        # EachDir). Owns the leaf enumeration, the `{...}` target templating, and
-        # the per-leaf repo-escape guard. Subclasses implement `#publish_leaf`,
-        # returning `{ written:, pruned: }`, and the discriminator half of
-        # `#validate!`.
-        class Each < Mode
-          def publish(pctx, prefix: nil)
-            leaves = []
-            pruned = []
-            pctx.manifest.resolver.enumerate(prefix: entry.key).each do |row|
-              next unless row[:manifest_entry].equal?(entry)
-              next if prefix && !row[:key].start_with?(prefix) && row[:key] != prefix
-
-              target_abs = guarded_target(pctx, row)
-              result = publish_leaf(row, target_abs, pctx)
-              pruned.concat(result[:pruned])
-              result[:written].each do |w|
-                leaves << { "key" => row[:key], "source" => w["source"], "target" => w["target"] }
-              end
-            end
-
-            { kind: :leaves, value: leaves, pruned: pruned }
-          end
-
-          # Expand this entry's publish_each template for a full leaf key.
-          def target_for(full_key)
-            entry_segs = entry.key.split(".")
-            key_segs = full_key.split(".")
-            raise UsageError.new("key '#{full_key}' is not under entry '#{entry.key}'") unless key_segs[0, entry_segs.length] == entry_segs
-
-            remaining = key_segs[entry_segs.length..] || []
-            Template.expand(
-              entry.publish_each,
-              "leaf" => remaining.join("/"),
-              "basename" => remaining.last || "",
-              "key" => full_key,
-              "ext" => ext,
-            )
-          end
-
-          private
-
-          def guarded_target(pctx, row)
-            target_rel = target_for(row[:key])
-            target_abs = repo_abs(pctx, target_rel)
-            return target_abs if inside_repo?(pctx, target_abs)
-
-            raise Textus::PublishError.new(
-              "entry '#{entry.key}': publish_each target '#{target_rel}' for key '#{row[:key]}' escapes repo root",
-            )
-          end
-
-          def ext
-            Textus::Entry.for_format(entry.format).extensions.first.to_s.sub(/^\./, "")
-          end
-
-          # publish_each shape rules common to file and directory leaves: a
-          # String value with only known template vars. Returns the used vars so
-          # subclasses can apply their discriminator rule.
-          def validate_template_basics
-            publish_each = entry.publish_each
-            raise UsageError.new("entry '#{entry.key}': publish_each must be a string") unless publish_each.is_a?(String)
-
-            used_vars = publish_each.scan(Template::VAR_RE).flatten
-            unknown = used_vars - Template::KNOWN_VARS
-            unless unknown.empty?
-              raise UsageError.new(
-                "entry '#{entry.key}': publish_each uses unknown template variable(s) " \
-                "#{unknown.map { |v| "{#{v}}" }.join(", ")}. Known: #{Template::KNOWN_VARS.map { |v| "{#{v}}" }.join(", ")}.",
-              )
-            end
-
-            used_vars
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/publish/each_dir.rb

@@ -1,74 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Publish
-        # publish_each + index_filename (ADR 0046): each leaf is a whole subtree
-        # copied into one templated directory, layout preserved, then pruned.
-        # The template names the target DIRECTORY (not the index file).
-        class EachDir < Each
-          def publish_leaf(row, target_abs, pctx)
-            SubtreeMirror.new(entry, pctx).mirror(
-              base: store_base(pctx),
-              walk_root: File.dirname(row[:path]),
-              target_dir: target_abs,
-              key: row[:key],
-              envelope: pctx.reader.call(row[:key]),
-              prune_honors_ignore: false,
-            )
-          end
-
-          def validate!
-            used_vars = validate_template_basics
-            reject_file_only_vars(used_vars)
-            reject_index_filename_segment
-            reject_file_looking_segment
-            return if used_vars.intersect?(%w[leaf key])
-
-            raise UsageError.new(
-              "entry '#{entry.key}': directory-leaf publish_each must reference {leaf} or {key} " \
-              "(else every leaf would clobber the same directory).",
-            )
-          end
-
-          private
-
-          def reject_file_only_vars(used_vars)
-            forbidden = used_vars & %w[basename ext]
-            return if forbidden.empty?
-
-            raise UsageError.new(
-              "entry '#{entry.key}': publish_each names a directory " \
-              "(index_filename: '#{entry.index_filename}'); {basename}/{ext} are file-only — " \
-              "use {leaf} or {key}.",
-            )
-          end
-
-          def reject_index_filename_segment
-            return unless last_segment == entry.index_filename
-
-            raise UsageError.new(
-              "entry '#{entry.key}': directory-leaf publish_each must name the target DIRECTORY, " \
-              "not the index file — drop the trailing '/#{entry.index_filename}' " \
-              "(the whole leaf subtree is copied into the named directory).",
-            )
-          end
-
-          def reject_file_looking_segment
-            ext = File.extname(last_segment)
-            return if ext.empty?
-
-            raise UsageError.new(
-              "entry '#{entry.key}': directory-leaf publish_each names a DIRECTORY target, but its " \
-              "final segment '#{last_segment}' looks like a file (extension '#{ext}') — " \
-              "drop the extension (the whole leaf subtree is copied into the named directory).",
-            )
-          end
-
-          def last_segment
-            entry.publish_each.sub(%r{/\z}, "").split("/").last
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/publish/each_file.rb

@@ -1,29 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Publish
-        # publish_each over file leaves (no index_filename): one stored leaf file
-        # copied to one templated repo path. No prune — each leaf is a single
-        # file, not a subtree.
-        class EachFile < Each
-          def publish_leaf(row, target_abs, pctx)
-            Textus::Ports::Publisher.publish(source: row[:path], target: target_abs, store_root: pctx.root)
-            pctx.emit(:file_published, key: row[:key], envelope: pctx.reader.call(row[:key]),
-                                       source: row[:path], target: target_abs)
-            { written: [{ "source" => row[:path], "target" => target_abs }], pruned: [] }
-          end
-
-          def validate!
-            used_vars = validate_template_basics
-            return if used_vars.intersect?(Template::REQUIRED_DISCRIMINATOR_VARS)
-
-            raise UsageError.new(
-              "entry '#{entry.key}': publish_each must reference at least one of {leaf}, {basename}, or {key} " \
-              "(else every leaf would clobber the same target).",
-            )
-          end
-        end
-      end
-    end
-  end
-end