textus 0.3.0 → 0.5.0

data/lib/textus/manifest.rb

@@ -17,23 +17,8 @@ module Textus
 
     attr_reader :root, :entries, :raw
 
-    LEGACY_ZONES = {
-      "fixed" => ["human"],
-      "state" => %w[human ai script],
-      "derived" => ["build"],
-    }.freeze
-
     def zones
-      @zones ||= begin
-        declared = Array(@raw["zones"])
-        if declared.empty?
-          LEGACY_ZONES.transform_values(&:dup)
-        else
-          declared.to_h do |z|
-            [z["name"], Array(z["writable_by"])]
-          end
-        end
-      end
+      @zones ||= Array(@raw["zones"]).to_h { |z| [z["name"], Array(z["writable_by"])] }
     end
 
     def zone_writers(zone_name)
@@ -45,7 +30,14 @@ module Textus
       raise IoError.new("manifest not found: #{manifest_path}") unless File.exist?(manifest_path)
 
       raw = YAML.safe_load_file(manifest_path, aliases: false)
-      raise BadFrontmatter.new(manifest_path, "unsupported manifest version #{raw["version"].inspect}") unless raw["version"] == PROTOCOL
+      unless raw["version"] == PROTOCOL
+        msg = if raw["version"] == "textus/1"
+                "manifest is textus/1; run 'textus migrate v2' to upgrade. See SPEC §15."
+              else
+                "unsupported manifest version #{raw["version"].inspect}"
+              end
+        raise BadFrontmatter.new(manifest_path, msg)
+      end
 
       new(root, raw)
     end
@@ -53,6 +45,8 @@ module Textus
     def initialize(root, raw)
       @root = root
       @raw = raw
+      raise BadFrontmatter.new(File.join(root, "manifest.yaml"), "manifest must declare zones:") if Array(raw["zones"]).empty?
+
       @entries = Array(raw["entries"]).map { |e| ManifestEntry.new(self, e) }
       validate_declared_keys!
     end
@@ -193,202 +187,4 @@ module Textus
       end
     end
   end
-
-  class ManifestEntry
-    PUBLISH_EACH_VARS = %w[leaf basename key ext].freeze
-    PUBLISH_EACH_VAR_RE = /\{([a-z]+)\}/
-
-    attr_reader :key, :path, :zone, :schema, :owner, :nested, :generator, :raw, :format,
-                :projection, :template, :publish_to, :publish_each, :fetcher, :fetcher_config, :ttl, :events,
-                :inject_intro
-
-    def initialize(manifest, raw)
-      @manifest = manifest
-      @raw = raw
-      @key = raw["key"] or raise UsageError.new("manifest entry missing key")
-      @path = raw["path"] or raise UsageError.new("manifest entry '#{@key}' missing path")
-      @zone = raw["zone"] or raise UsageError.new("manifest entry '#{@key}' missing zone")
-      @schema = raw["schema"]
-      @owner = raw["owner"]
-      @nested = raw["nested"] == true
-      @generator = raw["generator"]
-      @projection = raw["projection"]
-      @template = raw["template"]
-      @publish_to = Array(raw["publish_to"])
-      @publish_each = raw["publish_each"]
-      @events = raw["events"] || {}
-      @inject_intro = raw["inject_intro"] == true
-      @format = resolve_format!(raw["format"])
-
-      reject_legacy!(raw)
-      parse_source!(raw["source"])
-      validate_format_matrix!
-      validate_publish_each!
-      validate_inject_intro!
-    end
-
-    # Resolves the per-leaf target path (relative to repo root) for a full
-    # dotted key under this entry's prefix. Returns nil if this entry has no
-    # publish_each template.
-    def publish_target_for(full_key)
-      return nil if @publish_each.nil?
-
-      entry_segs = @key.split(".")
-      key_segs = full_key.split(".")
-      raise UsageError.new("key '#{full_key}' is not under entry '#{@key}'") unless key_segs[0, entry_segs.length] == entry_segs
-
-      remaining = key_segs[entry_segs.length..] || []
-      leaf = remaining.join("/")
-      basename = remaining.last || ""
-      ext = Entry.for_format(@format).extensions.first.to_s.sub(/^\./, "")
-
-      vars = { "leaf" => leaf, "basename" => basename, "key" => full_key, "ext" => ext }
-      @publish_each.gsub(PUBLISH_EACH_VAR_RE) { vars.fetch(::Regexp.last_match(1)) }
-    end
-
-    def derived?
-      writers = @manifest.zone_writers(@zone)
-      writers.include?("build")
-    rescue UsageError => e
-      raise UsageError.new("entry '#{@key}': #{e.message}")
-    end
-
-    private
-
-    def validate_inject_intro!
-      return unless @inject_intro
-
-      unless derived?
-        raise UsageError.new(
-          "entry '#{@key}': inject_intro: is only valid on derived entries",
-        )
-      end
-      return unless @template.nil?
-
-      raise UsageError.new(
-        "entry '#{@key}': inject_intro: requires a template:",
-      )
-    end
-
-    def validate_publish_each!
-      return if @publish_each.nil?
-
-      raise UsageError.new("entry '#{@key}': publish_each requires nested: true") unless @nested
-      raise UsageError.new("entry '#{@key}': publish_to and publish_each are mutually exclusive") unless @publish_to.empty?
-      raise UsageError.new("entry '#{@key}': publish_each must be a string") unless @publish_each.is_a?(String)
-
-      used_vars = @publish_each.scan(PUBLISH_EACH_VAR_RE).flatten
-      unknown = used_vars - PUBLISH_EACH_VARS
-      unless unknown.empty?
-        raise UsageError.new(
-          "entry '#{@key}': publish_each uses unknown template variable(s) " \
-          "#{unknown.map { |v| "{#{v}}" }.join(", ")}. Known: #{PUBLISH_EACH_VARS.map { |v| "{#{v}}" }.join(", ")}.",
-        )
-      end
-
-      required = %w[leaf basename key]
-      return if used_vars.any? { |v| required.include?(v) }
-
-      raise UsageError.new(
-        "entry '#{@key}': publish_each must reference at least one of {leaf}, {basename}, or {key} " \
-        "(else every leaf would clobber the same target).",
-      )
-    end
-
-    def resolve_format!(declared)
-      ext = File.extname(@path)
-      inferred = Manifest::EXT_TO_FORMAT[ext]
-
-      if declared.nil?
-        return inferred if inferred
-        # No extension: nested defaults to markdown, leaf with no ext also markdown.
-        return "markdown" if ext == "" && @nested
-        return "markdown" if ext == ""
-      else
-        raise UsageError.new("entry '#{@key}': unknown format #{declared.inspect}") unless Manifest::EXT_TO_FORMAT.values.include?(declared)
-        # If the path has an extension, the declared format must match.
-        if ext != "" && inferred && inferred != declared
-          raise UsageError.new(
-            "entry '#{@key}': path extension #{ext.inspect} does not match declared format #{declared.inspect}",
-          )
-        end
-        return declared
-      end
-
-      "markdown"
-    end
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def validate_format_matrix!
-      ext = File.extname(@path)
-
-      case @format
-      when "markdown"
-        # .md, or no extension (will be appended). Anything else is a mismatch caught above.
-        raise UsageError.new("entry '#{@key}': markdown format requires '.md' path (got #{ext.inspect})") if ext != "" && ext != ".md"
-      when "json"
-        if @nested
-          # nested json: path is a directory; ext must be empty.
-          raise UsageError.new("entry '#{@key}': nested json path must not have an extension") if ext != ""
-        elsif ext != ".json"
-          raise UsageError.new("entry '#{@key}': json format requires '.json' path (got #{ext.inspect})")
-        end
-      when "yaml"
-        if @nested
-          raise UsageError.new("entry '#{@key}': nested yaml path must not have an extension") if ext != ""
-        elsif ext != ".yaml" && ext != ".yml"
-          raise UsageError.new("entry '#{@key}': yaml format requires '.yaml' or '.yml' path (got #{ext.inspect})")
-        end
-      when "text"
-        if @nested
-          raise UsageError.new("entry '#{@key}': nested text path must not have an extension") if ext != ""
-        elsif ext != ".txt" && ext != ""
-          raise UsageError.new("entry '#{@key}': text format requires '.txt' or no extension (got #{ext.inspect})")
-        end
-      end
-
-      # Schema rules.
-      raise UsageError.new("entry '#{@key}': text format must not declare a schema") if @format == "text" && !@schema.nil?
-
-      # Template-required-for-derived rules. Skipped for entries materialized by an
-      # external generator: command (those produce the bytes themselves).
-      if derived? && @template.nil? && @generator.nil? &&
-         (@format == "markdown" || @format == "text") && !@nested
-        raise UsageError.new("entry '#{@key}': derived #{@format} entries require a template")
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    def parse_source!(src)
-      src ||= {}
-      @fetcher = src["fetcher"]
-      @fetcher_config = src["config"] || {}
-      @ttl = src["ttl"]
-    end
-
-    def reject_legacy!(raw)
-      src = raw["source"] || {}
-      if src.key?("parse") || src.key?("from")
-        raise UsageError.new(
-          "entry '#{@key}': source.parse/source.from removed in 0.2; " \
-          "use source.fetcher (+ source.config). See SPEC §5.4.",
-        )
-      end
-      if raw.key?("hooks")
-        raise UsageError.new(
-          "entry '#{@key}': 'hooks:' renamed to 'events:' in 0.2; " \
-          "remove on_ prefix from event names. See SPEC §5.10.",
-        )
-      end
-
-      @events.each_key do |evt|
-        next if ExtensionRegistry::EVENTS.include?(evt.to_sym)
-
-        raise UsageError.new(
-          "entry '#{@key}': unknown event '#{evt}' in events: block. " \
-          "Known events: #{ExtensionRegistry::EVENTS.join(", ")}.",
-        )
-      end
-    end
-  end
 end

data/lib/textus/manifest_entry.rb

@@ -0,0 +1,185 @@
+module Textus
+  class ManifestEntry
+    PUBLISH_EACH_VARS = %w[leaf basename key ext].freeze
+    PUBLISH_EACH_VAR_RE = /\{([a-z]+)\}/
+
+    attr_reader :key, :path, :zone, :schema, :owner, :nested, :generator, :raw, :format,
+                :projection, :template, :publish_to, :publish_each, :action, :action_config, :ttl, :events,
+                :inject_intro
+
+    def initialize(manifest, raw)
+      @manifest = manifest
+      @raw = raw
+      @key = raw["key"] or raise UsageError.new("manifest entry missing key")
+      @path = raw["path"] or raise UsageError.new("manifest entry '#{@key}' missing path")
+      @zone = raw["zone"] or raise UsageError.new("manifest entry '#{@key}' missing zone")
+      @schema = raw["schema"]
+      @owner = raw["owner"]
+      @nested = raw["nested"] == true
+      @generator = raw["generator"]
+      @projection = raw["projection"]
+      @template = raw["template"]
+      @publish_to = Array(raw["publish_to"])
+      @publish_each = raw["publish_each"]
+      @events = raw["events"] || {}
+      @inject_intro = raw["inject_intro"] == true
+      @format = resolve_format!(raw["format"])
+
+      validate_events!
+      parse_source!(raw["source"])
+      validate_format_matrix!
+      validate_publish_each!
+      validate_inject_intro!
+    end
+
+    # Resolves the per-leaf target path (relative to repo root) for a full
+    # dotted key under this entry's prefix. Returns nil if this entry has no
+    # publish_each template.
+    def publish_target_for(full_key)
+      return nil if @publish_each.nil?
+
+      entry_segs = @key.split(".")
+      key_segs = full_key.split(".")
+      raise UsageError.new("key '#{full_key}' is not under entry '#{@key}'") unless key_segs[0, entry_segs.length] == entry_segs
+
+      remaining = key_segs[entry_segs.length..] || []
+      leaf = remaining.join("/")
+      basename = remaining.last || ""
+      ext = Entry.for_format(@format).extensions.first.to_s.sub(/^\./, "")
+
+      vars = { "leaf" => leaf, "basename" => basename, "key" => full_key, "ext" => ext }
+      @publish_each.gsub(PUBLISH_EACH_VAR_RE) { vars.fetch(::Regexp.last_match(1)) }
+    end
+
+    def derived?
+      writers = @manifest.zone_writers(@zone)
+      writers.include?("build")
+    rescue UsageError => e
+      raise UsageError.new("entry '#{@key}': #{e.message}")
+    end
+
+    private
+
+    def validate_inject_intro!
+      return unless @inject_intro
+
+      unless derived?
+        raise UsageError.new(
+          "entry '#{@key}': inject_intro: is only valid on derived entries",
+        )
+      end
+      return unless @template.nil?
+
+      raise UsageError.new(
+        "entry '#{@key}': inject_intro: requires a template:",
+      )
+    end
+
+    def validate_publish_each!
+      return if @publish_each.nil?
+
+      raise UsageError.new("entry '#{@key}': publish_each requires nested: true") unless @nested
+      raise UsageError.new("entry '#{@key}': publish_to and publish_each are mutually exclusive") unless @publish_to.empty?
+      raise UsageError.new("entry '#{@key}': publish_each must be a string") unless @publish_each.is_a?(String)
+
+      used_vars = @publish_each.scan(PUBLISH_EACH_VAR_RE).flatten
+      unknown = used_vars - PUBLISH_EACH_VARS
+      unless unknown.empty?
+        raise UsageError.new(
+          "entry '#{@key}': publish_each uses unknown template variable(s) " \
+          "#{unknown.map { |v| "{#{v}}" }.join(", ")}. Known: #{PUBLISH_EACH_VARS.map { |v| "{#{v}}" }.join(", ")}.",
+        )
+      end
+
+      required = %w[leaf basename key]
+      return if used_vars.any? { |v| required.include?(v) }
+
+      raise UsageError.new(
+        "entry '#{@key}': publish_each must reference at least one of {leaf}, {basename}, or {key} " \
+        "(else every leaf would clobber the same target).",
+      )
+    end
+
+    def resolve_format!(declared)
+      ext = File.extname(@path)
+      inferred = Manifest::EXT_TO_FORMAT[ext]
+
+      if declared.nil?
+        return inferred if inferred
+        # No extension: nested defaults to markdown, leaf with no ext also markdown.
+        return "markdown" if ext == "" && @nested
+        return "markdown" if ext == ""
+      else
+        raise UsageError.new("entry '#{@key}': unknown format #{declared.inspect}") unless Manifest::EXT_TO_FORMAT.values.include?(declared)
+        # If the path has an extension, the declared format must match.
+        if ext != "" && inferred && inferred != declared
+          raise UsageError.new(
+            "entry '#{@key}': path extension #{ext.inspect} does not match declared format #{declared.inspect}",
+          )
+        end
+        return declared
+      end
+
+      "markdown"
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def validate_format_matrix!
+      ext = File.extname(@path)
+
+      case @format
+      when "markdown"
+        # .md, or no extension (will be appended). Anything else is a mismatch caught above.
+        raise UsageError.new("entry '#{@key}': markdown format requires '.md' path (got #{ext.inspect})") if ext != "" && ext != ".md"
+      when "json"
+        if @nested
+          # nested json: path is a directory; ext must be empty.
+          raise UsageError.new("entry '#{@key}': nested json path must not have an extension") if ext != ""
+        elsif ext != ".json"
+          raise UsageError.new("entry '#{@key}': json format requires '.json' path (got #{ext.inspect})")
+        end
+      when "yaml"
+        if @nested
+          raise UsageError.new("entry '#{@key}': nested yaml path must not have an extension") if ext != ""
+        elsif ext != ".yaml" && ext != ".yml"
+          raise UsageError.new("entry '#{@key}': yaml format requires '.yaml' or '.yml' path (got #{ext.inspect})")
+        end
+      when "text"
+        if @nested
+          raise UsageError.new("entry '#{@key}': nested text path must not have an extension") if ext != ""
+        elsif ext != ".txt" && ext != ""
+          raise UsageError.new("entry '#{@key}': text format requires '.txt' or no extension (got #{ext.inspect})")
+        end
+      end
+
+      # Schema rules.
+      raise UsageError.new("entry '#{@key}': text format must not declare a schema") if @format == "text" && !@schema.nil?
+
+      # Template-required-for-derived rules. Skipped for entries materialized by an
+      # external generator: command (those produce the bytes themselves).
+      if derived? && @template.nil? && @generator.nil? &&
+         (@format == "markdown" || @format == "text") && !@nested
+        raise UsageError.new("entry '#{@key}': derived #{@format} entries require a template")
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def parse_source!(src)
+      src ||= {}
+      @action = src["action"]
+      @action_config = src["config"] || {}
+      @ttl = src["ttl"]
+    end
+
+    def validate_events!
+      @events.each_key do |evt|
+        next if ExtensionRegistry::EVENTS.include?(evt.to_sym)
+
+        raise UsageError.new(
+          "entry '#{@key}': unknown event '#{evt}' in events: block. " \
+          "Known events: #{ExtensionRegistry::EVENTS.join(", ")}.",
+        )
+      end
+    end
+  end
+end

data/lib/textus/migrate_v2.rb

@@ -0,0 +1,27 @@
+require "yaml"
+
+module Textus
+  # One-shot migration: rewrites the manifest version string from textus/1
+  # to textus/2. On-disk entry file shapes are unchanged — the only change
+  # needed is the version: line in manifest.yaml.
+  module MigrateV2
+    def self.run(root)
+      manifest_path = File.join(root, "manifest.yaml")
+      raise IoError.new("manifest not found: #{manifest_path}") unless File.exist?(manifest_path)
+
+      content = File.read(manifest_path)
+      raw = YAML.safe_load(content, aliases: false)
+
+      case raw["version"]
+      when PROTOCOL
+        { "protocol" => PROTOCOL, "ok" => true, "no_op" => true, "message" => "already #{PROTOCOL}" }
+      when "textus/1"
+        new_content = content.sub(%r{^version:\s*textus/1\s*$}, "version: #{PROTOCOL}")
+        File.write(manifest_path, new_content)
+        { "protocol" => PROTOCOL, "ok" => true, "from" => "textus/1", "to" => PROTOCOL }
+      else
+        raise UsageError.new("cannot migrate from #{raw["version"].inspect}")
+      end
+    end
+  end
+end

data/lib/textus/projection.rb

@@ -18,7 +18,7 @@ module Textus
       explicit_pluck = !@spec["pluck"].nil? && @spec["pluck"] != "*"
       rows = keys.map do |key|
         env = @store.get(key)
-        row = pluck(env["frontmatter"], env["body"])
+        row = pluck(env["_meta"], env["body"])
         explicit_pluck ? row : row.merge("_key" => key)
       end
       reduced = apply_reducer(rows)

data/lib/textus/proposal.rb

@@ -4,15 +4,15 @@ module Textus
       raise ProposalError.new("only human role can accept proposals; got '#{as}'") unless as == "human"
 
       env = store.get(pending_key)
-      proposal = env["frontmatter"]["proposal"] or raise ProposalError.new("entry has no proposal block: #{pending_key}")
+      proposal = env["_meta"]["proposal"] or raise ProposalError.new("entry has no proposal block: #{pending_key}")
       target = proposal["target_key"] or raise ProposalError.new("proposal missing target_key")
       action = proposal["action"] || "put"
 
       case action
       when "put"
-        target_fm = env["frontmatter"]["frontmatter"] || {}
+        target_meta = env["_meta"]["frontmatter"] || {}
         target_body = env["body"]
-        store.put(target, frontmatter: target_fm, body: target_body, as: "human")
+        store.put(target, meta: target_meta, body: target_body, as: "human")
       when "delete"
         store.delete(target, as: "human")
       else

data/lib/textus/refresh.rb

@@ -2,30 +2,32 @@ require "timeout"
 
 module Textus
   module Refresh
-    FETCHER_TIMEOUT_SECONDS = 2
+    ACTION_TIMEOUT_SECONDS = 2
 
     def self.call(store, key, as:)
       mentry, path, = store.manifest.resolve(key)
-      raise UsageError.new("no fetcher declared for '#{key}'") unless mentry.fetcher
+      raise UsageError.new("no action declared for '#{key}'") unless mentry.action
 
       before_etag = File.exist?(path) ? Etag.for_file(path) : nil
-      callable = store.registry.fetcher(mentry.fetcher)
-      view = StoreView.new(store)
+      callable = store.registry.action(mentry.action)
+      view = StoreView.new(store, writable: true, as: as)
       result =
         begin
-          Timeout.timeout(FETCHER_TIMEOUT_SECONDS) { callable.call(config: mentry.fetcher_config, store: view) }
+          Timeout.timeout(ACTION_TIMEOUT_SECONDS) do
+            callable.call(config: mentry.action_config, store: view, args: {})
+          end
         rescue Timeout::Error
-          raise UsageError.new("fetcher '#{mentry.fetcher}' exceeded #{FETCHER_TIMEOUT_SECONDS}s timeout")
+          raise UsageError.new("action '#{mentry.action}' exceeded #{ACTION_TIMEOUT_SECONDS}s timeout")
         rescue Textus::Error
           raise
         rescue StandardError => e
-          raise UsageError.new("fetcher '#{mentry.fetcher}' raised: #{e.class}: #{e.message}")
+          raise UsageError.new("action '#{mentry.action}' raised: #{e.class}: #{e.message}")
         end
 
-      normalized = normalize_fetcher_result(result, format: mentry.format)
+      normalized = normalize_action_result(result, format: mentry.format)
       envelope = store.put(
         key,
-        frontmatter: normalized[:frontmatter],
+        meta: normalized[:meta],
         body: normalized[:body],
         content: normalized[:content],
         as: as,
@@ -43,29 +45,28 @@ module Textus
       envelope
     end
 
-    # Normalize the three accepted fetcher return shapes into the store's
-    # internal {frontmatter, body, content} representation. See plan-1.2 §7.
-    def self.normalize_fetcher_result(res, format:)
+    # Normalize the three accepted action return shapes into the store's
+    # internal {frontmatter, body, content} representation.
+    def self.normalize_action_result(res, format:)
       res = res.transform_keys(&:to_s) if res.is_a?(Hash)
       res ||= {}
-      fm      = res["frontmatter"]
+      # Accept both legacy :frontmatter/:_meta key names from actions.
+      meta_val = res["_meta"] || res["frontmatter"]
       body    = res["body"]
       content = res["content"]
 
       case format
       when "markdown"
-        { frontmatter: fm || {}, body: body.to_s, content: nil }
+        { meta: meta_val || {}, body: body.to_s, content: nil }
       when "text"
-        { frontmatter: {}, body: body.to_s, content: nil }
+        { meta: {}, body: body.to_s, content: nil }
       when "json", "yaml"
         if !content.nil?
-          meta = content.is_a?(Hash) && content["_meta"].is_a?(Hash) ? content["_meta"] : {}
-          { frontmatter: meta, body: nil, content: content }
+          { meta: meta_val || {}, body: nil, content: content }
         elsif !body.nil?
-          # Store#put will re-parse and validate the bytes.
-          { frontmatter: {}, body: body.to_s, content: nil }
+          { meta: {}, body: body.to_s, content: nil }
         else
-          raise UsageError.new("fetcher for #{format} returned neither content nor body")
+          raise UsageError.new("action for #{format} returned neither content nor body")
         end
       else
         raise UsageError.new("unknown format #{format.inspect}")

data/lib/textus/schema_tools.rb

@@ -6,12 +6,12 @@ module Textus
     # textus schema-init NAME --from=KEY  → infer YAML schema from an entry's frontmatter
     def self.init(store, name:, from:)
       env = store.get(from)
-      fm = env["frontmatter"]
+      meta = env["_meta"]
       schema = {
         "name" => name,
-        "required" => fm.keys,
+        "required" => meta.keys,
         "optional" => [],
-        "fields" => fm.each_with_object({}) { |(k, v), h| h[k] = { "type" => infer_type(v) } },
+        "fields" => meta.each_with_object({}) { |(k, v), h| h[k] = { "type" => infer_type(v) } },
       }
       FileUtils.mkdir_p(File.join(store.root, "schemas"))
       target = File.join(store.root, "schemas", "#{name}.yaml")
@@ -26,7 +26,7 @@ module Textus
       store.manifest.enumerate.each do |row|
         env = store.get(row[:key])
         begin
-          schema.validate!(env["frontmatter"])
+          schema.validate!(env["_meta"])
         rescue SchemaViolation => e
           drift << { "key" => row[:key], "details" => e.details }
         end
@@ -51,17 +51,17 @@ module Textus
       touched = []
       store.manifest.enumerate.each do |row|
         env = store.get(row[:key])
-        fm = env["frontmatter"]
+        meta = env["_meta"]
         changed = false
         renames.each do |old, new|
-          if fm.key?(old)
-            fm[new] = fm.delete(old)
+          if meta.key?(old)
+            meta[new] = meta.delete(old)
             changed = true
           end
         end
         next unless changed
 
-        store.put(row[:key], frontmatter: fm, body: env["body"], as: "human")
+        store.put(row[:key], meta: meta, body: env["body"], as: "human")
         touched << row[:key]
       end
       { "protocol" => PROTOCOL, "migrated" => touched, "renames" => renames }

data/lib/textus/store/events.rb

@@ -0,0 +1,31 @@
+require "timeout"
+
+module Textus
+  class Store
+    class Events
+      HOOK_TIMEOUT_SECONDS = 2
+
+      def initialize(store)
+        @store = store
+      end
+
+      def call(event, **kwargs)
+        view = StoreView.new(@store)
+        @store.registry.hooks(event).each do |entry|
+          name = entry[:name]
+          Timeout.timeout(HOOK_TIMEOUT_SECONDS) { entry[:callable].call(store: view, **kwargs) }
+        rescue StandardError => e
+          extras = { "event" => event.to_s, "hook" => name.to_s, "error" => "#{e.class}: #{e.message}" }
+          extras["target_key"]  = kwargs[:target_key]  if kwargs.key?(:target_key)
+          extras["pending_key"] = kwargs[:pending_key] if kwargs.key?(:pending_key)
+          @store.audit_log.append(
+            role: "script", verb: "event_error",
+            key: kwargs[:key] || kwargs[:target_key] || kwargs[:pending_key] || "-",
+            etag_before: nil, etag_after: nil,
+            extras: extras
+          )
+        end
+      end
+    end
+  end
+end