samagotchi 0.149.0 → 0.151.0

data/lib/samagotchi/update_command.rb

@@ -9,6 +9,7 @@ require_relative "desktop"
 require_relative "gem_update"
 require_relative "installed_gem"
 require_relative "live_versions"
+require_relative "memory_bundle/file_standing"
 require_relative "memory_bundle/shipped_update"
 require_relative "memory_bundle/system_bundle"
 require_relative "session"
@@ -20,8 +21,8 @@ require "json"
 module Samagotchi
   # `chi update`: brings an installed chi up to date in one go: the system
   # bundle, the shipped bundles the user installed, and the macOS helper.
-  # Unedited things update; edited ones are kept (.md) or replaced and
-  # reported (hooks, plugin, rules, which didn't load once edited). Live
+  # Unedited things update; edited ones merge or stay behind (.md) or are replaced
+  # and reported (hooks, plugin, rules, which didn't load once edited). Live
   # workers and a running chi web are reported, never restarted. The bundles
   # chi didn't ship are only checked, under the chi that will run them
   # (BundleCommand::InstalledCheck): what it finds is rows that fail nothing.
@@ -34,10 +35,15 @@ module Samagotchi
         Updates this chi's install: the gem (from rubygems.org), then the
         system bundle, the bundles chi ships that you installed (chi bundle
         list), and the desktop helper (macOS; rebuilt only when its sources
-        changed). Edited memory files are kept and reported; nothing is
-        installed that isn't already, and old gem versions stay. The bundles
-        chi doesn't ship are never changed: the new chi checks them and adds
-        a row per warning or error (these don't fail the update).
+        changed). A memory file you edited takes the update in a text merge
+        (the old file goes to the bundle trash), or stays behind as it is when
+        no merge is possible, and the table says which and why; each run
+        retries a file left behind, though one an older chi marked, with a base
+        no installed chi shipped, merges only if the bundle takes out or rewords
+        no line it still holds. Nothing is
+        installed that isn't already, and old gem versions stay. The bundles chi doesn't ship are
+        never changed: the new chi checks them and adds a row per warning or
+        error (these don't fail the update).
         --dry-run      show what would change; change nothing (with a newer
                        gem to install, bundles chi doesn't ship aren't checked:
                        that chi would)
@@ -76,8 +82,11 @@ module Samagotchi
 
     # A table row. info rows (live workers, chi web) say what runs; they
     # never fail. level ("warn", "error"; else nil) marks a finding on a bundle
-    # chi didn't ship: it reports, changes nothing and fails nothing.
-    Row = Struct.new(:component, :from, :to, :status, :failed, :kept, :level, keyword_init: true)
+    # chi didn't ship: it reports, changes nothing and fails nothing. kept: the
+    # memory files that stay behind; merged: the ones that took the update;
+    # trash_copy: where their old copies went, in full (the table's short: --json
+    # has the path); earlier: the files of the earlier merges the row names.
+    Row = Struct.new(:component, :from, :to, :status, :failed, :kept, :merged, :earlier, :trash_copy, :level, keyword_init: true)
 
     # What a row says after a change, and in a dry run.
     VERBS = { update: ["updated", "would update"], install: ["installed", "would install"],
@@ -95,6 +104,7 @@ module Samagotchi
                    gem_update: nil, exec: nil, bundler: nil, home: ChiHome, env: ENV)
       @home = home
       @in_home = env.delete(IN_HOME_ENV) == "1"
+      @unattended = env[ChildEnv::UNATTENDED_UPDATE] == "1"
       # Built after the home is known: its install env goes into the home.
       @gem_update_given = gem_update
       @exec = exec || ->(argv) { Kernel.exec(*argv) }
@@ -147,7 +157,7 @@ module Samagotchi
       gem = gem_row(options)
       rows = [gem, system_bundle_row, *bundle_rows(options), *external_rows(options), desktop_row(options), *live_rows].compact
       if options[:json]
-        @stdout.puts(JSON.generate(rows.map { |row| row.to_h.merge(failed: !!row.failed, kept: row.kept || []) }))
+        @stdout.puts(JSON.generate(rows.map { |row| row.to_h.merge(failed: !!row.failed, kept: row.kept || [], merged: row.merged || [], earlier: row.earlier || []) }))
       else
         print_table(rows)
         footers(options, rows).each { |line| @stdout.puts(line) }
@@ -279,17 +289,24 @@ module Samagotchi
     end
 
     def system_bundle_row
-      result = MemoryBundle::SystemBundle.sync(dry_run: @dry_run)
+      system = MemoryBundle::SystemBundle
+      earlier = system.merge_notes
+      result = system.sync(dry_run: @dry_run)
+      # These rows have no place for the notes, which wait for one that has.
+      earlier = [] if %i[installed skipped failed].include?(result.status)
       row = Row.new(component: "system bundle", from: result.from, to: result.to)
+      notes = file_notes(row, system::BUNDLE_NAME, result.to, result.merged, result.behind, result.trash_copy, earlier: earlier)
       case result.status
       when :installed then done(row, :install)
-      when :updated then done(row, :update, kept(row, result.kept, MemoryBundle::SystemBundle::BUNDLE_NAME))
-      when :restored then done(row, :restore).tap { |r| r.to = nil }
-      when :up_to_date then up_to_date(row)
-      when :newer_installed then skipped(row, "newer than this chi's #{result.to}: left").tap { |r| r.to = nil }
+      when :updated then done(row, :update, notes.empty? ? nil : notes.join("; "))
+      when :restored then done(row, :restore, notes.empty? ? nil : notes.join("; ")).tap { |r| r.to = nil }
+      when :merged, :up_to_date then same_version(row, notes + result.warnings, changed: result.merged.any?)
+      when :newer_installed then skipped(row, ["newer than this chi's #{result.to}: left", *notes].join("; ")).tap { |r| r.to = nil }
       when :skipped then skipped(row, result.error)
       else failed(row, result.error)
       end
+      system.clear_merge_notes(earlier, files: result.merged) if read_by_someone?
+      row
     end
 
     def bundle_rows(options)
@@ -320,14 +337,50 @@ module Samagotchi
 
     def bundle_row(update)
       row = Row.new(component: update.name, from: update.from, to: update.to)
+      earlier = update.status == :failed ? [] : Array(update.earlier)
+      notes = file_notes(row, update.name, update.to || update.from, update.merged, update.behind, update.trash_copy, earlier: earlier)
       case update.status
       when :would_update, :updated
-        notes = [adds(update.adds), kept(row, update.kept, update.name), replaced(update.replaced), *update.kept_own].compact
+        notes = [adds(update.adds), *notes, replaced(update.replaced), *update.kept_own].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
-      when :up_to_date then up_to_date(row)
-      when :skipped then skipped(row, update.note)
-      else failed(row, update.note)
+      when :would_merge, :merged, :up_to_date then same_version(row, [*notes, update.note].compact, changed: Array(update.merged).any?)
+      when :skipped then skipped(row, [update.note, *notes].join("; "))
+      else failed(row, [update.note, *notes].compact.join("; "))
       end
+      # A failed row keeps them: the run didn't finish, and the next says what stands.
+      MemoryBundle::Provenance.new(name: update.name).clear_merge_notes(earlier, files: row.merged) if read_by_someone? && update.status != :failed
+      row
+    end
+
+    # What one bundle's memory files did, in FileStanding's words; the row keeps
+    # the file names and the trash copy's full line for --json. merged is what
+    # this run merged, earlier the files of the notes it shows.
+    # @return [Array<String>] the row's clauses
+    def file_notes(row, bundle, version, merged, behind, trash_copy, earlier: [])
+      merged = Array(merged)
+      behind = Array(behind)
+      row.merged = merged
+      row.earlier = earlier.map(&:file)
+      row.kept = behind.map(&:file)
+      @unsure_behind ||= behind.any?(&:unsure)
+      row.trash_copy = trash_copy
+      notes = MemoryBundle::FileStanding.clauses(bundle, version, merged: merged, behind: behind, earlier: earlier, dry_run: @dry_run)
+      trash_copy || earlier.any?(&:trash) ? [*notes, MemoryBundle::FileStanding::IN_THE_TRASH] : notes
+    end
+
+    # Whether a row printed now ends the notes for what it printed, this run's
+    # merges too. A dry run changes nothing, and an automatic update's rows may be
+    # read by no one (ChildEnv::UNATTENDED_UPDATE).
+    def read_by_someone? = !@dry_run && !@unattended
+
+    # A row at the same version: up to date only when nothing merged and nothing
+    # stays behind. No to, and no verb of its own: the clauses say it all.
+    def same_version(row, notes, changed:)
+      return up_to_date(row, notes.join("; ")) unless changed || row.kept.any?
+
+      row.to = nil
+      row.status = notes.join("; ")
+      row
     end
 
     def desktop_row(options)
@@ -420,6 +473,9 @@ module Samagotchi
       return "(dry run: nothing was changed)" if @dry_run
       return "some parts failed (see above)" if rows.any?(&:failed)
 
+      behind = rows.sum { |row| Array(row.kept).size }
+      return "#{MemoryBundle::FileStanding.stay_behind(behind, unsure: @unsure_behind)} (see above)" if behind.positive?
+
       # A finding on a bundle chi didn't ship repeats until its bundle changes; it isn't a change.
       changes = rows.reject(&:level)
       changes.all? { |r| r.status.start_with?("up to date", "skipped", "not installed", "couldn't check") } ? "everything is up to date" : "done"
@@ -434,9 +490,9 @@ module Samagotchi
       row
     end
 
-    def up_to_date(row)
+    def up_to_date(row, note = nil)
       row.to = nil
-      row.status = "up to date"
+      row.status = note.to_s.empty? ? "up to date" : "up to date (#{note})"
       row
     end
 
@@ -456,14 +512,6 @@ module Samagotchi
       members.nil? || members.empty? ? nil : "+ #{members.join(", ")}"
     end
 
-    def kept(row, files, bundle)
-      row.kept = files.dup
-      return nil if row.kept.empty?
-
-      verb = @dry_run ? "would keep" : "kept"
-      "#{verb} your edits in #{row.kept.join(", ")}: chi bundle diff #{bundle} #{row.kept.first}"
-    end
-
     def replaced(files)
       return nil if files.empty?
 

data/lib/samagotchi/update_hint.rb

@@ -43,7 +43,10 @@ module Samagotchi
     end
 
     def message(version, shipped_dir:, helper:)
-      bundles = MemoryBundle::ShippedUpdate.plan(shipped_dir: shipped_dir).count { |r| r.status == :would_update }
+      # A retry that would merge is an update too; one that only records a reason isn't.
+      bundles = MemoryBundle::ShippedUpdate.plan(shipped_dir: shipped_dir).count do |r|
+        r.status == :would_update || (r.status == :would_merge && r.merged.any?)
+      end
       parts = []
       parts << (bundles == 1 ? "1 bundle" : "#{bundles} bundles") if bundles.positive?
       parts << "the desktop helper" if helper&.stale?

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.149.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/auto_update.rb

@@ -197,7 +197,7 @@ module Samagotchi
       end
 
       # A newer chi this didn't install, settled: a run of its own from here.
-      # The terminal's table already told what `chi update` kept.
+      # The terminal's table already told what `chi update` merged or left behind.
       def adopt_installed
         return unless @restart == "idle" && @seen
 
@@ -215,10 +215,10 @@ module Samagotchi
         return Log.info(:web, "auto_update_deferred", version: version, why: result) if result.is_a?(Symbol)
 
         rows = result.rows
-        record = AutoUpdateRecord.new(version: version, from: VERSION, at: @clock.call.iso8601, kept: kept_files(rows),
-                                      phase: "installed")
+        record = AutoUpdateRecord.new(version: version, from: VERSION, at: @clock.call.iso8601, kept: files_in(rows, "kept"),
+                                      merged: files_in(rows, "merged"), phase: "installed")
         if result.done?
-          Log.info(:web, "auto_update_installed", version: version, kept: record.kept.size)
+          Log.info(:web, "auto_update_installed", version: version, kept: record.kept.size, merged: record.merged.size)
           installed(record)
         else
           failed(record, rows)
@@ -232,7 +232,7 @@ module Samagotchi
         return carry_on(save(record)) unless @restart == "never"
 
         save(record.with(phase: "done", pushed: true))
-        @hub.publish_notice(kind: "installed", version: record.version, kept: record.kept.size)
+        @hub.publish_notice(kind: "installed", version: record.version, kept: record.kept.size, merged: record.merged.size)
       end
 
       # The next step of a run on record.
@@ -328,7 +328,7 @@ module Samagotchi
         record = restart_workers(record) || record
         Log.info(:web, "auto_update_done", version: record.version, restarted: record.restarted, left: record.left)
         save(record.with(phase: record.left_to_try?(@clock.call, RETRY_FOR) ? RETRYING : "done", pushed: true))
-        @hub.publish_notice(kind: "updated", version: record.version, kept: record.kept.size,
+        @hub.publish_notice(kind: "updated", version: record.version, kept: record.kept.size, merged: record.merged.size,
                             restarted: record.restarted, left: record.left)
       end
 
@@ -366,8 +366,8 @@ module Samagotchi
                             installed: gem_installed)
       end
 
-      def kept_files(rows)
-        rows.flat_map { |row| Array(row["kept"]).map(&:to_s) }.uniq
+      def files_in(rows, field)
+        rows.flat_map { |row| Array(row[field]).map(&:to_s) }.uniq
       end
     end
   end

data/lib/samagotchi/web/auto_update_record.rb

@@ -13,8 +13,10 @@ module Samagotchi
     # +phase+: installed, workers, web (AutoUpdate::OPEN_PHASES), retrying,
     # done or failed. +restarted+ and +left+ count the stale workers (`workers` in
     # the file); +at+ is when the install ended, an ISO 8601 string.
-    AutoUpdateRecord = Data.define(:version, :from, :at, :kept, :phase, :restarted, :left, :detail, :pushed) do
-      def initialize(version:, phase:, from: nil, at: nil, kept: [], restarted: 0, left: 0, detail: nil, pushed: false)
+    # +kept+ and +merged+ name the edited memory files that stayed behind and
+    # that took the update (chi update --json's).
+    AutoUpdateRecord = Data.define(:version, :from, :at, :kept, :merged, :phase, :restarted, :left, :detail, :pushed) do
+      def initialize(version:, phase:, from: nil, at: nil, kept: [], merged: [], restarted: 0, left: 0, detail: nil, pushed: false)
         super
       end
 
@@ -30,14 +32,14 @@ module Samagotchi
 
         workers = hash["workers"].is_a?(Hash) ? hash["workers"] : {}
         new(version: version, phase: phase, from: hash["from"], at: hash["at"],
-            kept: Array(hash["kept"]).grep(String), restarted: workers["restarted"].to_i, left: workers["left"].to_i,
+            kept: Array(hash["kept"]).grep(String), merged: Array(hash["merged"]).grep(String), restarted: workers["restarted"].to_i, left: workers["left"].to_i,
             detail: hash["detail"], pushed: hash["pushed"] == true)
       end
 
       # What goes in the file, for .from_h to read back.
       # @return [Hash{String => Object}]
       def to_store
-        { "version" => version, "from" => from, "at" => at, "kept" => kept, "phase" => phase,
+        { "version" => version, "from" => from, "at" => at, "kept" => kept, "merged" => merged, "phase" => phase,
           "workers" => { "restarted" => restarted, "left" => left }, "detail" => detail,
           "pushed" => pushed ? true : nil }.compact
       end

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

data/lib/samagotchi/web/markdown_renderer.rb

@@ -2,6 +2,7 @@
 
 require "nokogiri"
 require "uri"
+require_relative "../block_renderers"
 
 module Samagotchi
   module Web
@@ -17,6 +18,12 @@ module Samagotchi
       ALLOWED_ELEMENTS = %w[a blockquote br code del em h1 h2 h3 h4 h5 h6 hr li ol p pre s strong span table tbody td th thead tr ul].freeze
       DROP_ELEMENTS = %w[iframe object script style svg].freeze
       ALLOWED_PROTOCOLS = %w[http https mailto].freeze
+      # Both Commonmarker calls take these: the parse that reads the fences has
+      # to see the blocks #render's own parse does.
+      OPTIONS = {
+        render: { escape: true }, # escape raw HTML from source; highlighter output is still emitted
+        extension: { header_ids: nil }
+      }.freeze
 
       def initialize(enabled: false)
         @enabled = enabled
@@ -46,10 +53,7 @@ module Samagotchi
       def render(markdown)
         return nil unless available?
 
-        html = Commonmarker.to_html(markdown.to_s, options: {
-          render: { escape: true }, # escape raw HTML from source; highlighter output is still emitted
-          extension: { header_ids: nil }
-        }, plugins: {
+        html = Commonmarker.to_html(markdown.to_s, options: OPTIONS, plugins: {
           # An empty theme makes syntect emit scope classes (`keyword`, `string`, ...)
           # instead of inline colours from one fixed theme, so the page's light and
           # dark palettes colour code blocks (the --code-* tokens in index.html).
@@ -57,7 +61,7 @@ module Samagotchi
         })
         return nil unless html
 
-        sanitize(html)
+        sanitize(html, fence_languages(markdown.to_s))
       end
 
       private
@@ -77,7 +81,35 @@ module Samagotchi
         @commonmarker_installed = Gem::Specification.find_all_by_name("commonmarker").any?
       end
 
-      def sanitize(html)
+      # Every code block's language, in document order (nil for an indented block
+      # or a bare fence): the highlighter drops it from the HTML, the parse tree
+      # has it. [] for a text with no fence: its blocks have no language.
+      def fence_languages(markdown)
+        return [] unless markdown.include?("```") || markdown.include?("~~~")
+
+        languages = []
+        Commonmarker.parse(markdown, options: OPTIONS).walk do |node|
+          languages << language_of(node.fence_info) if node.type == :code_block
+        end
+        languages
+      end
+
+      def language_of(info)
+        word = info.to_s.split.first.to_s.downcase
+        word if word.match?(BlockRenderers::LANG)
+      end
+
+      # After the walk, which drops every attribute it doesn't know. Blocks and
+      # languages pair by position; a count that differs says the two parses
+      # disagree, and then no block gets one (it shows as source).
+      def mark_languages(fragment, languages)
+        blocks = fragment.css("pre")
+        return unless blocks.size == languages.size
+
+        blocks.zip(languages) { |pre, language| pre["data-lang"] = language if language }
+      end
+
+      def sanitize(html, languages)
         fragment = Nokogiri::HTML5.fragment(html)
         fragment.traverse do |node|
           next unless node.element?
@@ -90,6 +122,7 @@ module Samagotchi
             sanitize_attributes(node)
           end
         end
+        mark_languages(fragment, languages)
         fragment.to_html
       end
 

data/lib/samagotchi/web/message_display.rb

@@ -59,7 +59,7 @@ module Samagotchi
         return nil unless saved
 
         messages = Array(session.messages)
-        since = messages.drop(saved[:covered].to_i).count { |m| Samagotchi::Steer.turn_prompt?(m) }
+        since = messages.drop(saved[:covered].to_i).count { |m| Samagotchi::Steer.turn_opening?(m) }
         { text: saved[:text], turns_since: since, created_at: saved[:created_at] }.compact
       rescue StandardError
         nil
@@ -288,8 +288,8 @@ module Samagotchi
       end
 
       # As JSON has them (string keys and values), like a snapshot's.
-      def saved_cards(id)
-        JSON.parse(JSON.generate(Samagotchi::Bridge::CardStore.saved(Session.session_dir(id, state_dir: default_state_dir))))
+      def saved_cards(id, messages: nil)
+        JSON.parse(JSON.generate(Samagotchi::Bridge::CardStore.saved(Session.session_dir(id, state_dir: default_state_dir), messages: messages)))
       rescue StandardError
         []
       end

data/lib/samagotchi/web/public/app.js

@@ -71,6 +71,7 @@ import { createAnnotateBar } from "./annotate_bar.js";
 import { VERIFY_PRESET, VERIFY_UNAVAILABLE, verifyWorkerUnavailable, withVerify } from "./verify_preset.js";
 import { OWNER_FINAL, verifyTurnOf } from "./verify_target.js";
 import { actionLine, annotationActions, composerWithAction } from "./annotate_actions.js";
+import { createBlockHost } from "./block_host.js";
 import { copyText, installCopy } from "./copy.js";
 import { installAnswerFold, sweepAnswerFolds } from "./answer_fold.js";
 import { installDetailsMotion } from "./details_motion.js";
@@ -1188,8 +1189,9 @@ function renderSessionView(data, { kept = [] } = {}) {
   restoreCommandBubbles(historyEl, kept);
   // A failed turn's prompt went back to the user: shown after the
   // conversation, marked failed, as it was live (prompt_restored).
-  if (data.failed_turn) {
-    makeUserBubble(data.failed_turn.prompt, { state: "failed" }).dataset.failedTurn = "1";
+  const failedPrompt = data.failed_turn ? makeUserBubble(data.failed_turn.prompt, { state: "failed" }) : null;
+  if (failedPrompt) {
+    failedPrompt.dataset.failedTurn = "1";
     addEndBubble(failedTurnText(data.failed_turn));
   }
   seedSeenFromDom();
@@ -1203,7 +1205,8 @@ function renderSessionView(data, { kept = [] } = {}) {
   // A live worker's last cards and between-turns notices, where they
   // arrived; the running turn's go into its step once it is drawn.
   const snapshotCards = splitSnapshotCards(data.cards, pageCapabilities);
-  placeSnapshotCards(snapshotCards.placed);
+  // Above a failed turn's prompt: it came after them, and it is no turn.
+  placeSnapshotCards(snapshotCards.placed, { before: failedPrompt });
   // The recap saved with the session (also a stopped one's), else a live
   // worker's from before saved_recap existed. After the cards: the last
   // turn's check-in notice goes to the end, and the recap closes the page.
@@ -2117,6 +2120,7 @@ historyEl.addEventListener("click", (e) => {
 });
 turnDom.scrollEl.addEventListener("scroll", annotateBar.schedule, true);
 turnRoots().forEach((root) => installCopy(root));
+createBlockHost({ roots: turnRoots(), sessionId: () => store.selected });
 // A steps block, a thinking block and the recap open and close by hand
 // with their height animated (details_motion.js), in the history and on
 // the stage.