samagotchi 0.150.0 → 0.151.0

data/lib/samagotchi/engine.rb

@@ -961,7 +961,7 @@ module Samagotchi
     ANNOUNCEABLE_EVENTS = %i[turn_enqueued turn_dequeued input_merged prompt_restored continue_offered continue_resolved
                              command_queued command_ran context_added card hook_notice guardrail_warning
                              plugin_init_started plugin_init_finished working_set_updated participants_changed
-                             verdict_recorded objectives_updated turn_rolled_back].freeze
+                             verdict_recorded objectives_updated].freeze
 
     # Put a transport-level event into the ordered event log. Unlike turn
     # events it reaches only persistent observers (no turn sink, no memory
@@ -1107,6 +1107,8 @@ module Samagotchi
     # @raise [ArgumentError] a card without a title, or a bad action
     def show_card(source:, title:, body: "", actions: [], level: :info, id: nil)
       card = Plugin::Card.build(source: source, title: title, body: body, actions: actions, level: level, id: id)
+      command = Thread.current[running_command_key]
+      card[:command] = command if command
       @event_routes.route(card, **EventRoutes::CARD_MARKS)
       card[:id]
     end
@@ -1126,6 +1128,20 @@ module Samagotchi
       Thread.current[key] = outer
     end
 
+    # Run a session command's dispatch: a card shown on this thread says
+    # it's that command's (:card's command:), for a reload that no longer has
+    # the command's line above it (Bridge::CardStore). A thread of its own
+    # isn't the command, nor a card shown after it.
+    # @param name [String] the command, "/short"
+    # @return the block's value
+    def running_command(name)
+      outer = Thread.current[running_command_key]
+      Thread.current[running_command_key] = name
+      yield
+    ensure
+      Thread.current[running_command_key] = outer
+    end
+
     # Whether an anytime command (/btw) still runs on its thread.
     def anytime_running?
       @lifecycle_mutex.synchronize { @anytime_threads.any?(&:alive?) }
@@ -2266,7 +2282,7 @@ module Samagotchi
 
       messages = @session&.messages || []
       covered = state[:covered].to_i
-      turns_since = Array(messages).drop(covered).count { |m| Steer.turn_prompt?(m) }
+      turns_since = Array(messages).drop(covered).count { |m| Steer.turn_opening?(m) }
       { text: state[:text], covered: covered, turns_since: turns_since, created_at: state[:created_at] }
     end
 
@@ -2974,6 +2990,8 @@ module Samagotchi
 
     private
 
+    def running_command_key = :"samagotchi_command_#{object_id}"
+
     # The one named seam for replacing a session's conversation (the
     # array is replaced, never mutated in place). No lock: a reader gets
     # the old array or the new one, and both are whole.

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -269,7 +269,7 @@ module Samagotchi
           raise Installer::InstallError, "the manifest names scripts/#{file}, which the bundle doesn't have" unless File.file?(src)
           raise Installer::InstallError, "scripts/#{file} is a symlink (not installed)" if linked?(src)
 
-          @warnings << "scripts/#{file} is not executable; chmod +x #{src}" if @dev && !File.executable?(src)
+          @warnings << "scripts/#{file} is not executable; chmod +x #{src}" if @dev && !File.executable?(src) && !page_only?(file)
         end
         return {} if @dry_run
 
@@ -300,6 +300,12 @@ module Samagotchi
         end
       end
 
+      # A file only a block renderer's load names: the page loads it, nothing runs it.
+      def page_only?(file)
+        @manifest.block_renderers.any? { |renderer| renderer.load.include?(file) } &&
+          @manifest.context_providers.none? { |provider| provider.cmd.include?(file) }
+      end
+
       # Copies +src+ to +dest+, or (a dev install) links +dest+ to it. An
       # existing link goes first: a copy over it would write into the source.
       def place(src, dest)

data/lib/samagotchi/memory_bundle/builder.rb

@@ -30,8 +30,8 @@ module Samagotchi
       #   hooks       basename => BundleHook; hook_files basename => path
       #   rules       guardrails/*.yml paths
       #   plugin      the installed plugin file, nil without one
-      #   scripts     file name => path; context_providers the parsed list
-      InstalledParts = Data.define(:record, :hooks, :hook_files, :rules, :plugin, :scripts, :context_providers)
+      #   scripts     file name => path; context_providers, block_renderers the parsed lists
+      InstalledParts = Data.define(:record, :hooks, :hook_files, :rules, :plugin, :scripts, :context_providers, :block_renderers)
 
       attr_reader :built_files, :warnings, :placeholder_warnings, :out_path, :staging_dir
 
@@ -179,7 +179,8 @@ module Samagotchi
           rules: Dir.exist?(rules_dir) ? Dir.glob(File.join(rules_dir, "*.yml")).sort : [],
           plugin: plugin && File.file?(plugin) ? plugin : nil,
           scripts: installed_scripts(prov, record),
-          context_providers: record ? ContextProviders.parse_list(record.context_providers) : []
+          context_providers: record ? ContextProviders.parse_list(record.context_providers) : [],
+          block_renderers: record ? BlockRenderers.parse_list(record.block_renderers) : []
         )
       end
 
@@ -223,6 +224,7 @@ module Samagotchi
           needs: record&.needs,
           scripts: parts.scripts.transform_values { |src| "sha256:#{Digest::SHA256.hexdigest(File.binread(src))}" },
           context_providers: parts.context_providers,
+          block_renderers: parts.block_renderers,
           file_descriptions: file_descriptions(record, files_map),
           session_settings: record&.session_settings || [],
           session_setting_types: record&.session_setting_types || {},

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -26,9 +26,9 @@ module Samagotchi
     #   guardrails  basename => recorded sha256 ("" when none)
     #   scripts     file name => recorded sha256 ("" when none)
     #   plugin      PluginRef, nil without one
-    #   needs, context_providers
-    #               the lists as recorded (nil when absent): Manifest.parse_needs
-    #               and ContextProviders.parse_list check them
+    #   needs, context_providers, block_renderers
+    #               the lists as recorded (nil when absent): Manifest.parse_needs,
+    #               ContextProviders.parse_list and BlockRenderers.parse_list check them
     #   includes    a profile's recorded members, nil for a plain bundle
     #   session_settings
     #               the keys a session may set (chi --set), [] when none
@@ -43,12 +43,12 @@ module Samagotchi
     #   error       why manifest.json couldn't be read (the rest empty), else nil
     class InstalledBundle < Data.define(:name, :version, :scope, :source, :installed_at, :trust_level, :source_commit,
                                         :requires_chi, :files, :hooks, :guardrails, :scripts, :plugin, :needs,
-                                        :includes, :context_providers, :session_settings, :session_setting_types, :settings,
+                                        :includes, :context_providers, :block_renderers, :session_settings, :session_setting_types, :settings,
                                         :setting_types, :dev,
                                         :error)
       OPTIONAL = { version: nil, scope: nil, source: nil, installed_at: nil, trust_level: nil, source_commit: nil,
                    requires_chi: nil, files: {}, hooks: {}, guardrails: {}, scripts: {}, plugin: nil, needs: nil,
-                   includes: nil, context_providers: nil, session_settings: [], session_setting_types: {}, settings: nil, setting_types: {}, dev: false,
+                   includes: nil, context_providers: nil, block_renderers: nil, session_settings: [], session_setting_types: {}, settings: nil, setting_types: {}, dev: false,
                    error: nil }.freeze
 
       def initialize(name:, **fields)
@@ -86,6 +86,7 @@ module Samagotchi
             guardrails: mapping(h["guardrails"]) { |meta| sha(meta) },
             scripts: mapping(h["scripts"]) { |meta| sha(meta) },
             plugin: PluginRef.parse(h["plugin"]), needs: h["needs"], context_providers: h["context_providers"],
+            block_renderers: h["block_renderers"],
             includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil,
             session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [],
             session_setting_types: mapping(h["session_setting_types"]) { |type| type.to_s },
@@ -164,6 +165,8 @@ module Samagotchi
       def needs? = needs.is_a?(Array) && !needs.empty?
 
       def context_providers? = context_providers.is_a?(Array) && !context_providers.empty?
+
+      def block_renderers? = block_renderers.is_a?(Array) && !block_renderers.empty?
     end
   end
 end

data/lib/samagotchi/memory_bundle/installed_copy.rb

@@ -42,6 +42,7 @@ module Samagotchi
           requires_chi: bundle.requires_chi, needs: bundle.needs,
           # A record read with symbol keys: back to what a manifest.yml holds.
           context_providers: JSON.parse(JSON.generate(Array(bundle.context_providers))),
+          block_renderers: JSON.parse(JSON.generate(Array(bundle.block_renderers))),
           session_settings: bundle.session_settings, session_setting_types: bundle.session_setting_types,
           settings: bundle.settings, setting_types: bundle.setting_types
         )

data/lib/samagotchi/memory_bundle/installer.rb

@@ -516,6 +516,7 @@ module Samagotchi
           incoming_dir: @bundle_dir,
           scripts_files: installed.script_files,
           context_providers: @manifest.context_providers,
+          block_renderers: @manifest.block_renderers,
           file_descriptions: @manifest.file_descriptions,
           session_settings: @manifest.session_settings,
           session_setting_types: @manifest.session_setting_types,

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -7,6 +7,8 @@ require_relative "../context_providers"
 require_relative "bundle_hook"
 
 module Samagotchi
+  autoload :BlockRenderers, File.expand_path("../block_renderers", __dir__)
+
   module MemoryBundle
     # Parses and validates a bundle manifest.yml.
     #
@@ -41,6 +43,9 @@ module Samagotchi
     #       cmd: '{ruby} {bundle_dir}/scripts/pr_context.rb {url}'
     #       why: GitHub PR      #   optional
     #       every_seconds: 300  #   optional
+    #   block_renderers:       # optional — a fence's language → the scripts/
+    #     - lang: mermaid      #   files chi web's page loads to draw it
+    #       load: [lib.js, draw.js]   # (BlockRenderers); each one a scripts: key
     #   session_settings: [cap] # optional — the settings a session may set
     #                          #   (chi --set cost-cap.cap=3), read by the
     #                          #   plugin from ctx.settings at call time;
@@ -71,7 +76,7 @@ module Samagotchi
       # the description a mapping gave, for the files that have one; hooks:
       # name → BundleHook.
       attr_reader :name, :version, :scope, :description, :files, :file_descriptions, :hooks, :trust_level, :plugin, :requires_chi, :needs, :includes,
-                  :scripts, :context_providers, :session_settings, :session_setting_types, :settings, :setting_types
+                  :scripts, :context_providers, :block_renderers, :session_settings, :session_setting_types, :settings, :setting_types
 
       def initialize(path:)
         @path = path
@@ -94,6 +99,7 @@ module Samagotchi
         @needs = self.class.parse_needs(raw["needs"])
         @scripts = parse_scripts(raw["scripts"])
         @context_providers = parse_context_providers(raw["context_providers"])
+        @block_renderers = parse_block_renderers(raw["block_renderers"])
         @includes = parse_includes(raw["includes"])
         @session_settings = self.class.parse_session_settings(raw["session_settings"])
         @session_setting_types = self.class.parse_session_setting_types(raw["session_settings"])
@@ -163,7 +169,7 @@ module Samagotchi
       # Writes a fresh manifest.yml from computed checksums at `dir`.
       # +file_descriptions+ (name → text) writes those files as mappings.
       def self.write(dir:, name:, version:, files:, scope: nil, description: "", hooks: nil, trust_level: nil,
-                     plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [], file_descriptions: {},
+                     plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [], block_renderers: [], file_descriptions: {},
                      session_settings: [], session_setting_types: {}, settings: nil, setting_types: {})
         FileUtils.mkdir_p(dir)
         manifest = {
@@ -187,6 +193,7 @@ module Samagotchi
         manifest["needs"] = needs.map { |n| n.transform_keys(&:to_s).compact } unless needs.empty?
         manifest["scripts"] = scripts.transform_keys(&:to_s) unless scripts.empty?
         manifest["context_providers"] = context_providers.map(&:to_h) unless context_providers.empty?
+        manifest["block_renderers"] = block_renderers.map(&:to_h) unless block_renderers.empty?
         manifest["session_settings"] = session_settings_entry(session_settings, session_setting_types) unless Array(session_settings).empty?
         manifest["settings"] = session_settings_entry(settings, setting_types) unless settings.nil?
         File.write(File.join(dir, "manifest.yml"), YAML.dump(manifest))
@@ -362,6 +369,20 @@ module Samagotchi
         raise ValidationError, e.message
       end
 
+      # @return [Array<BlockRenderers::Renderer>] each load is a scripts: key
+      def parse_block_renderers(raw)
+        return [] if raw.nil?
+
+        renderers = BlockRenderers.parse_list(raw)
+        renderers.each do |renderer|
+          missing = renderer.load - @scripts.keys
+          raise ValidationError, "block_renderers: #{renderer.lang} loads #{missing.join(", ")}, not under scripts:" unless missing.empty?
+        end
+        renderers
+      rescue BlockRenderers::Invalid => e
+        raise ValidationError, e.message
+      end
+
       # includes: → the names in order, duplicates dropped; [] when absent.
       # A meta ships nothing of its own, so files, hooks or a plugin next
       # to it is a ValidationError.

data/lib/samagotchi/memory_bundle/provenance.rb

@@ -92,7 +92,7 @@ module Samagotchi
 
           begin
             data = JSON.parse(File.read(mjson), symbolize_names: true)
-          rescue JSON::ParserError, SystemCallError => e
+          rescue JSON::ParserError, EncodingError, SystemCallError => e # a key that isn't UTF-8 can't be a symbol
             if holding.nil? || Dir.exist?(File.join(dir, name, holding.to_s))
               yield name, InstalledBundle.unreadable(name, "manifest.json is unreadable: #{e.message}")
             end
@@ -172,11 +172,12 @@ module Samagotchi
       # @param scripts_files [Hash] file name => installed script; the
       #   sha256 of each is recorded (ContextFetch checks it before a run)
       # @param context_providers [Array<ContextProviders::Provider>]
+      # @param block_renderers [Array<BlockRenderers::Renderer>]
       # @param dev [Boolean] a dev install: its files are links to the
       #   source, recorded as DEV_SHA (no sha256 check) with "dev": true
       def write(files:, scope:, version:, source_path:, hooks: {}, trust_level: nil, source_commit: nil, hooks_files: {},
                 guardrails_files: {}, plugin_file: nil, requires_chi: nil, needs: nil, marks: [], incoming_dir: nil, includes: nil,
-                scripts_files: {}, context_providers: [], file_descriptions: {}, session_settings: [], session_setting_types: {}, settings: nil, setting_types: {},
+                scripts_files: {}, context_providers: [], block_renderers: [], file_descriptions: {}, session_settings: [], session_setting_types: {}, settings: nil, setting_types: {},
                 dev: false)
         FileUtils.mkdir_p(@bundle_dir)
         bases_dir = File.join(@bundle_dir, "bases")
@@ -289,6 +290,7 @@ module Samagotchi
           end
         end
         manifest_data["context_providers"] = context_providers.map(&:to_h) unless context_providers.empty?
+        manifest_data["block_renderers"] = block_renderers.map(&:to_h) unless block_renderers.empty?
         manifest_data["session_settings"] = Array(session_settings).map(&:to_s) unless Array(session_settings).empty?
         manifest_data["session_setting_types"] = session_setting_types.to_h { |k, v| [k.to_s, v.to_s] } unless session_setting_types.to_h.empty?
         manifest_data["settings"] = settings.map(&:to_s) unless settings.nil?

data/lib/samagotchi/session_chain.rb

@@ -129,7 +129,7 @@ module Samagotchi
     # A turn's opening, not a `!shell` line: a command the user ran after
     # the answer leaves it the last word.
     def later_turn?(message)
-      Steer.turn_prompt?(message) && !shell_line?(message)
+      Steer.turn_opening?(message)
     end
 
     # At most +max+ bytes of +text+'s start, cut on a character.
@@ -181,18 +181,13 @@ module Samagotchi
 
         text = msg[:content]
         next unless text.is_a?(String) && !text.strip.empty?
-        next if shell_line?(msg)
+        next if Steer.shell_line?(msg)
 
         return text.strip
       end
       nil
     end
 
-    # A stored `!shell` line: "!(cmd)\n<output>", no turn_id.
-    def shell_line?(message)
-      message[:turn_id].nil? && message[:content].is_a?(String) && message[:content].start_with?("!(")
-    end
-
     def clock(iso)
       iso && Time.iso8601(iso.to_s).localtime.strftime("%Y-%m-%d %H:%M")
     rescue ArgumentError

data/lib/samagotchi/session_commands.rb

@@ -317,16 +317,9 @@ module Samagotchi
       text = line.to_s.strip
       entry = @registry.lookup(text)
       return nil unless entry&.handler
-      return run_bundle_command(entry, text, confirm: confirm) unless entry.source == "core"
 
-      # Only commands that may ask take the flag.
-      return send(entry.id, text, confirm: confirm) if CONFIRMING.include?(entry.id)
-      # Who sent it goes to its handler per call, never through an ivar:
-      # an anytime command runs on another thread against this instance.
-      return continue_command(text, as_parent: as_parent) if entry.id == :continue
-      return parent_answers(text, user_ui: user_ui) if entry.id == :parent_answers
-
-      instance_exec(text, &entry.handler)
+      # A card it shows names it (Engine#running_command).
+      @engine.running_command(entry.name) { dispatch(entry, text, confirm:, as_parent:, user_ui:) }
     end
 
     # /continue [yes|no|no, <reason>]: the continue offer's answer.
@@ -367,6 +360,19 @@ module Samagotchi
 
     private
 
+    def dispatch(entry, text, confirm:, as_parent:, user_ui:)
+      return run_bundle_command(entry, text, confirm: confirm) unless entry.source == "core"
+
+      # Only commands that may ask take the flag.
+      return send(entry.id, text, confirm: confirm) if CONFIRMING.include?(entry.id)
+      # Who sent it goes to its handler per call, never through an ivar:
+      # an anytime command runs on another thread against this instance.
+      return continue_command(text, as_parent: as_parent) if entry.id == :continue
+      return parent_answers(text, user_ui: user_ui) if entry.id == :parent_answers
+
+      instance_exec(text, &entry.handler)
+    end
+
     # The resolved ref (what the session stores and --alias/--default write).
     def model_name = @engine.effective_model_ref
 

data/lib/samagotchi/session_manager.rb

@@ -1018,15 +1018,18 @@ module Samagotchi
       turns.is_a?(Array) && turns.empty?
     end
 
-    # A folder's cards.json is empty only when it is a JSON object whose
-    # turns is an integer zero. Anything unreadable, not JSON, not an
-    # object, the wrong type, or turns not an integer reads as "not empty":
-    # a broken or wrong-shape cards file keeps the folder instead of
-    # raising (Array#/Hash#to_i) or reading as empty.
+    # A folder's cards.json is empty only when it is a JSON object with no
+    # turn in it: an empty turn_log, or an older file's (Bridge::CardStore
+    # version 1) turns an integer zero. Anything unreadable, not JSON, not an
+    # object, the wrong type, or neither of those reads as "not empty": a
+    # broken or wrong-shape cards file keeps the folder instead of raising
+    # (Array#/Hash#to_i) or reading as empty.
     def self.cards_empty?(path)
       data = read_json(path)
-      turns = data.is_a?(Hash) ? data["turns"] : nil
-      turns.is_a?(Integer) && turns.zero?
+      return false unless data.is_a?(Hash)
+
+      turns = data["turns"]
+      data["turn_log"] == [] || (turns.is_a?(Integer) && turns.zero?)
     end
 
     # A session-dir JSON file's contents, or nil when it is missing,

data/lib/samagotchi/steer.rb

@@ -336,6 +336,23 @@ module Samagotchi
       prompt?(message) && (!input?(message) || start)
     end
 
+    # A stored `!shell` line: "!(cmd)\n<output>", no turn id. A user message,
+    # so #turn_prompt? takes it; no turn ran.
+    def shell_line?(message)
+      return false unless message.is_a?(Hash)
+
+      content = message[:content] || message["content"]
+      (message[:turn_id] || message["turn_id"]).nil? && content.is_a?(String) && content.start_with?("!(")
+    end
+
+    # A turn's opening as the page draws it (TURN_PROMPT, bubbles.js): a prompt
+    # or a wake turn's note or report, not a `!shell` line. What the recap, the
+    # cards' count and "a later turn" go by. #turn_prompt? stays what bounds a
+    # turn's slice, where a `!shell` line ends one.
+    def turn_opening?(message)
+      turn_prompt?(message) && !shell_line?(message)
+    end
+
     # Call a loop's drain: +at_answer+ goes only to a drain that takes it
     # (the Engine's); a caller's own drain (a queue's #drain) is called bare.
     # A failing drain drains nothing (the loop keeps going).

data/lib/samagotchi/terminal_ui.rb

@@ -544,13 +544,13 @@ module Samagotchi
 
     # The session's cards.json and pending_card.json, kept as a worker's
     # Bridge keeps them (it owns the session as a worker would): this REPL's
-    # kept turns count on from the saved count, so a card an earlier worker
-    # showed stays that many turns back, and its own cards and notices are
-    # saved for the next; an open card with actions is on disk, where
+    # turns go on the same turn log, so a card an earlier worker showed keeps its
+    # place above the turns after it, and its own cards and notices are saved
+    # for the next; an open card with actions is on disk, where
     # `chi web`'s session hub reads it to mark the session as waiting.
     def keep_cards(session)
       path = File.join(Session.session_dir(session.id), Bridge::CardStore::FILE)
-      @cards_handle ||= @engine.subscribe(observer: Bridge::CardStore.new(path: path))
+      @cards_handle ||= @engine.subscribe(observer: Bridge::CardStore.new(path: path, messages: -> { @engine.session&.messages }))
       keep_pending_card(session)
     end
 

data/lib/samagotchi/turn_checkpoint.rb

@@ -171,17 +171,20 @@ module Samagotchi
 
     # A turn begins (before Engine#run_turn and the worker's running save):
     # the overlay starts as the history plus +prompt+ (text only: no
-    # images, no turn id), marked at iteration 0, so a worker killed before
-    # the loop's first boundary leaves the prompt and a mark the next one
-    # settles. A continue turn (no prompt) is the history, marked.
+    # images), marked at iteration 0, so a worker killed before the loop's
+    # first boundary leaves the prompt and a mark the next one settles. The
+    # prompt carries +turn_id+, as the first boundary's copy does: a card's
+    # place counts from it (Bridge::CardStore). A continue turn (no prompt)
+    # is the history, marked.
     # Every mark of the turn carries +enqueued_id+ and a participant's
     # +author+ (InterruptedTurn's).
     # @param prompt [String, nil]
+    # @param turn_id [String, nil] the id the turn runs under
     # @param enqueued_id [String, nil] the input the turn runs
     # @param author [Hash] a participant's prompt's author fields
     #   (Engine#author_fields), so a kill before the first boundary leaves
     #   it theirs; {} for the owner's
-    def begin_turn(prompt: nil, enqueued_id: nil, author: {})
+    def begin_turn(prompt: nil, turn_id: nil, enqueued_id: nil, author: {})
       @boundaries = 0
       @enqueued_id = enqueued_id.to_s.empty? ? nil : enqueued_id.to_s
       @author = author[:author]
@@ -190,7 +193,10 @@ module Samagotchi
       messages = Array(@session.messages).dup
       # Stamped by the wall clock here, a moment before the turn's own
       # stamp (Engine's Turn#wall), which the turn's first boundary saves.
-      messages << { role: "user", content: prompt, **author, MessageTime::KEY => MessageTime.iso(MessageTime.now) } unless prompt.to_s.empty?
+      unless prompt.to_s.empty?
+        messages << { role: "user", content: prompt, **(turn_id ? { turn_id: turn_id } : {}), **author,
+                      MessageTime::KEY => MessageTime.iso(MessageTime.now) }
+      end
       @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0,
                                                                                    enqueued_id: @enqueued_id, author: @author) }
     end

data/lib/samagotchi/turn_flow.rb

@@ -191,8 +191,8 @@ module Samagotchi
     # Restore the pre-turn checkpoint (!rollback after a Ctrl-C). A pending
     # offer goes too: the turn it offered to continue is gone. (The REPL
     # reads every line as an answer while an offer is pending; a worker
-    # also takes !rollback then.) :turn_rolled_back tells the cards' count
-    # (Bridge::CardStore) that the turn's prompt is gone.
+    # also takes !rollback then.) The cards' places follow the messages
+    # (Bridge::CardStore).
     # @return [Boolean] false when there is none
     def rollback!
       return false unless @checkpoint
@@ -200,7 +200,6 @@ module Samagotchi
       restore(@checkpoint)
       @checkpoint = nil
       @offer = nil
-      @engine.announce({ type: :turn_rolled_back })
       true
     end
 

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.150.0"
+  VERSION = "0.151.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -74,6 +74,7 @@ require_relative "session_create"
 require_relative "session_control"
 require_relative "verify_fresh_routes"
 require_relative "push_routes"
+require_relative "block_renderer_routes"
 require_relative "update_check"
 require_relative "update_ops"
 require_relative "proxy_gate"
@@ -107,6 +108,7 @@ module Samagotchi
       include SessionControl
       include VerifyFreshRoutes
       include PushRoutes
+      include BlockRendererRoutes
       include ProxyGate
 
       DEFAULT_HOST = BridgeClient::HOST
@@ -222,8 +224,11 @@ module Samagotchi
       private
 
       # No page of chi web's may be framed by another (clickjacking): every
-      # HTML answer says so. The page's full CSP is a later change.
-      FRAME_HEADERS = { "X-Frame-Options" => "DENY", "Content-Security-Policy" => "frame-ancestors 'none'" }.freeze
+      # HTML answer says so. frame-src 'none': a page's own frames can't navigate
+      # anywhere, which a block renderer's frame's own CSP doesn't stop (a srcdoc
+      # frame still loads under it; docs/internals/block-renderers.md). The page's
+      # full CSP is a later change.
+      FRAME_HEADERS = { "X-Frame-Options" => "DENY", "Content-Security-Policy" => "frame-ancestors 'none'; frame-src 'none'" }.freeze
       FRAME_DESTS = %w[iframe frame embed object].freeze
 
       def unframed(response)
@@ -315,6 +320,8 @@ module Samagotchi
         ["DELETE", %r{\A/api/push/subscriptions/([^/]+)\z}, :handle_push_remove, :owner],
         ["POST", %r{\A/api/push/test\z}, :handle_push_test, :owner],
         ["POST", %r{\A/api/push/presence\z}, :handle_push_presence, :owner],
+        ["GET", %r{\A/api/block_renderers\z}, :handle_block_renderers, :owner],
+        ["GET", %r{\A/api/block_renderers/([^/]+)/([^/]+)\z}, :handle_block_renderer_file, :owner],
         ["GET", %r{\A/api/sessions/([^/]+)\z}, :handle_show, :participant, :session],
         ["DELETE", %r{\A/api/sessions/([^/]+)\z}, :handle_delete, :owner, :session]
       ].freeze
@@ -1800,21 +1807,24 @@ module Samagotchi
         rel = rel.split("/").reject { |p| p == ".." || p.empty? }.join("/")
         full = File.join(@public_dir, rel)
         if File.file?(full) && full.start_with?(@public_dir)
-          body = File.binread(full)
-          # no-cache + a content ETag: the browser revalidates every asset
-          # (the ES-module imports too) and gets a cheap 304 while it is
-          # unchanged, so a gem upgrade + chi web restart takes effect on the
-          # next load instead of after max-age runs out.
-          etag = %("#{Digest::SHA256.hexdigest(body)[0, 32]}")
-          headers = { "Cache-Control" => "no-cache", "ETag" => etag }
-          return [304, headers, []] if etag_match?(req.get_header("HTTP_IF_NONE_MATCH"), etag)
-
-          [200, headers.merge("Content-Type" => mime_type(full), "Content-Length" => body.bytesize.to_s), [body]]
+          revalidated_body(req, File.binread(full), mime_type(full))
         else
           not_found(path: req.path_info)
         end
       end
 
+      # no-cache + a content ETag: the browser revalidates every asset
+      # (the ES-module imports too) and gets a cheap 304 while it is
+      # unchanged, so a gem upgrade + chi web restart takes effect on the
+      # next load instead of after max-age runs out.
+      def revalidated_body(req, body, content_type)
+        etag = %("#{Digest::SHA256.hexdigest(body)[0, 32]}")
+        headers = { "Cache-Control" => "no-cache", "ETag" => etag }
+        return [304, headers, []] if etag_match?(req.get_header("HTTP_IF_NONE_MATCH"), etag)
+
+        [200, headers.merge("Content-Type" => content_type, "Content-Length" => body.bytesize.to_s), [body]]
+      end
+
       def etag_match?(if_none_match, etag)
         return false if if_none_match.nil?
 

data/lib/samagotchi/web/block_renderer_routes.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../block_renderers"
+
+module Samagotchi
+  module Web
+    # What the owner's page asks to draw a fenced block (App::ROUTES, :owner
+    # rows; a participant's page shows the source). Included in App: its helpers
+    # answer. docs/internals/block-renderers.md.
+    module BlockRendererRoutes
+      private
+
+      # {renderers: [{lang, bundle, files}]}
+      def handle_block_renderers(_req)
+        json_response(200, { renderers: BlockRenderers.for_installed.map(&:to_h) })
+      end
+
+      # One of a renderer's files. The captures are the URL's and unchecked:
+      # BlockRenderers.script_path never makes a path of one that isn't a
+      # renderer's. A file changed since the install gets an error, so the page
+      # keeps the block as source.
+      def handle_block_renderer_file(req, bundle, file)
+        path = BlockRenderers.script_path(bundle, file)
+        return not_found(path: req.path_info) unless path
+
+        revalidated_body(req, File.binread(path), "text/javascript; charset=utf-8")
+      rescue BlockRenderers::Invalid => e
+        error_response(409, "renderer_changed", e.message)
+      end
+    end
+  end
+end