alembic 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a28b9683aee21510ccc84055b1f946263171af250b924b7fa16b89fe758ae4b
-  data.tar.gz: f64da9c1a64cc8a20fd48aa05e773973fc1eee8d3a8ee222d3d4de5de9d21154
+  metadata.gz: 199da5d98e867968625a2b5c7052a2b9be9be053dae21f2d9335d0985c821934
+  data.tar.gz: d267ef04676182a8973f0d69a50ddb774e26ca8ebe2f252325bb04be8dab62a7
 SHA512:
-  metadata.gz: fffcf2c82312ff28a404fe1d4569572b9908a1f2b9a30295efaf3c869e246fdcf6258125b5295b2b400898f8b0ffb075ca000b0c33686dadf7d7b0d2d19918fd
-  data.tar.gz: 6d71eaad3a26a0c2e77a033a16ff6fb791af402a2ce04efaca9c731c84eb53d86253f003d8e4b44b57f3f9de7682e4ad7dadcde8a9278111a653e6137fb55ef0
+  metadata.gz: c7e095677fe4cf0074adb09b2dc098da95b580c1ef5effc567425e712b6f7ccc9fd812fb17067c1b5971d136764e7e9de31580f241d921da76af18f9dd5e62c3
+  data.tar.gz: b68e766a8b94d801637d278111ceb983e97a7365b4ee8d66219c1cfce334c453f8b531b6db66d499ac76a3540cd181ee27435ac05b85514da5726c78b3295420

data/app/assets/javascripts/alembic/one_page.js

@@ -0,0 +1,39 @@
+(() => {
+  const start = (form) => {
+    if (form.dataset.onePageStarted) return
+    form.dataset.onePageStarted = "true"
+
+    const questions = Array.from(form.querySelectorAll("[data-one-page-question]"))
+    const ready = form.querySelector("[data-one-page-ready]")
+    const show = (index) => {
+      questions.forEach((question, position) => { question.hidden = position !== index })
+      ready.hidden = index < questions.length
+    }
+
+    questions.forEach((question, position) => {
+      question.querySelectorAll("input[type=radio]").forEach((answer) => {
+        answer.addEventListener("change", () => show(position + 1))
+      })
+      const previous = question.querySelector("[data-one-page-previous]")
+      if (previous) {
+        previous.hidden = false
+        previous.addEventListener("click", () => show(position - 1))
+      }
+    })
+
+    const back = ready.querySelector("[data-one-page-previous]")
+    back.hidden = false
+    back.addEventListener("click", () => show(questions.length - 1))
+
+    show(0)
+  }
+
+  const begin = () => document.querySelectorAll("form[data-one-page]").forEach(start)
+
+  document.addEventListener("turbo:load", begin)
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", begin)
+  } else {
+    begin()
+  }
+})()

data/app/controllers/alembic/application_controller.rb

@@ -2,6 +2,8 @@ module Alembic
   class ApplicationController < Alembic.base_controller.constantize
     layout -> { Alembic.layout }
     helper KeystoneUiHelper
+    helper ResultBlocksHelper
+    helper ContentBlocksHelper
 
     rescue_from NotPublished, NotPermitted, Withdrawn, with: :refuse
 

data/app/controllers/alembic/flows_controller.rb

@@ -2,9 +2,40 @@ module Alembic
   class FlowsController < EasyFlow::FlowsController
     hosted_by FLOW_HOST
     include Summarizes
+    helper_method :step_category, :shows_answer_values?
+
+    def step
+      return super unless asked_on_one_page?
+
+      @guide = runner_for(running_definition)
+      @questions = questions_in_order
+      render :one_page
+    end
 
     private
 
+    def asked_on_one_page?
+      run.nil? && params[:answers].blank? && Flow::Summaries.new(flow).asks_on_one_page?
+    end
+
+    def questions_in_order
+      state = {}
+      questions = []
+      while (question = @guide.next_step(state))
+        questions << question
+        state[question.id.to_s] = "asked"
+      end
+      questions
+    end
+
+    def shows_answer_values?
+      Flow::Summaries.new(run&.flow || flow).shows_answer_values?
+    end
+
+    def step_category(question)
+      EasyFlow::Steps::Question.category_of(@guide.step(question.id)&.config)
+    end
+
     def run_location(run)
       alembic.run_path(run)
     end

data/app/controllers/alembic/manage/base_controller.rb

@@ -12,6 +12,15 @@ module Alembic
       helper KeystoneUi::React::MountHelper
       helper KsBlocks::ContentHelper
       helper Alembic::PagesHelper
+      helper Alembic::ResultBlocksHelper
+      helper Alembic::ContentBlocksHelper
+      helper_method :preview_values
+
+      private
+
+      def preview_values(page)
+        @preview_values ||= Page::Preview.values_for(page, session.dig(:alembic_preview, page.id.to_s))
+      end
     end
   end
 end

data/app/controllers/alembic/manage/flows_controller.rb

@@ -2,16 +2,50 @@ module Alembic
   module Manage
     class FlowsController < EasyFlow::Manage::FlowsController
       hosted_by FLOW_HOST
+      helper Alembic::ApplicationHelper
       def edit
         super
-        @summary = Flow::Summaries.new(@flow).text
+        summaries = Flow::Summaries.new(@flow)
+        @summary = summaries.text
+        @summary_page = summaries.summary_page
+        @intro_page = summaries.intro_page
+        @outputs = Array(summaries.document.to_h["outputs"])
+        @uncategorised = scored_by_category?(@outputs) ? questions_of(@flow).reject { |node| EasyFlow::Steps::Question.category_of(node).present? } : []
+        @categories = questions_of(@flow).filter_map { |node| EasyFlow::Steps::Question.category_of(node) }.uniq
+        @shows_answer_values = summaries.shows_answer_values?
+        @asks_on_one_page = summaries.asks_on_one_page?
+        @branches = summaries.branches?
+        @published_pages = Page.where(id: Page::Version.live.select(:page_id)).order(:name)
       end
 
       def update
-        summary = params.require(:flow)[:summary]
-        Flow::Summaries.new(flow_host.flows.find(params[:id])).describe(summary) unless summary.nil?
+        details = params.require(:flow)
+        summaries = Flow::Summaries.new(flow_host.flows.find(params[:id]))
+        summaries.describe(details[:summary]) unless details[:summary].nil?
+        summaries.start_on(Page.find_by(id: details[:intro_page_id])) unless details[:intro_page_id].nil?
+        summaries.finish_on(Page.find_by(id: details[:summary_page_id])) unless details[:summary_page_id].nil?
+        summaries.show_answer_values(details[:shows_answer_values] == "1") unless details[:shows_answer_values].nil?
+        summaries.ask_on_one_page(details[:asks_on_one_page] == "1") unless details[:asks_on_one_page].nil?
+        record_outputs(summaries, details[:outputs]) if details[:outputs]
 
         super
+      rescue Summary::UnknownOutputType => refused
+        redirect_to easy_flow.edit_manage_flow_path(params[:id]), alert: refused.message
+      end
+
+      private
+
+      def scored_by_category?(outputs)
+        outputs.any? { |output| %w[grouped lowest].include?(output["type"]) }
+      end
+
+      def questions_of(flow)
+        Array(flow.definition.to_h["nodes"]).select { |node| node["type"] == "question" }
+      end
+
+      def record_outputs(summaries, submitted)
+        edited = Flow::OutputForm.edited(Array(summaries.document.to_h["outputs"]), submitted.permit!.to_h)
+        summaries.record(summaries.document.to_h.merge("outputs" => edited))
       end
     end
   end

data/app/controllers/alembic/manage/page_blocks_controller.rb

@@ -12,7 +12,7 @@ module Alembic
       end
 
       def block_content(block)
-        render_to_string(partial: "alembic/manage/pages/block_content", locals: { block: block }, formats: [ :html ])
+        render_to_string(partial: "alembic/manage/pages/block_content", locals: { block: block, page: block_layout_record }, formats: [ :html ])
       end
     end
   end

data/app/controllers/alembic/manage/pages_controller.rb

@@ -27,6 +27,13 @@ module Alembic
         redirect_to manage_page_path(page)
       end
 
+      def preview
+        page = Page.find(params[:id])
+        session[:alembic_preview] = session.fetch(:alembic_preview, {}).merge(page.id.to_s => params[:choice].presence)
+
+        redirect_to manage_page_path(page)
+      end
+
       private
 
       def payload(page)

data/app/controllers/concerns/alembic/summarizes.rb

@@ -5,7 +5,11 @@ module Alembic
     included do
       layout -> { Alembic.layout }
       helper ApplicationHelper
-      helper_method :flow_summary, :first_step_path
+      helper PagesHelper
+      helper ResultBlocksHelper
+      helper ContentBlocksHelper
+      helper KsBlocks::LayoutHelper
+      helper_method :flow_summary, :first_step_path, :summary_values, :intro_values
     end
 
     private
@@ -25,7 +29,36 @@ module Alembic
     def finished(answers, finished_run)
       @outputs = outputs_of(answers.transform_keys(&:to_s))
       Flow::Summaries.new(flow).pin(finished_run) if finished_run && run.nil?
-      render template: "alembic/flows/complete"
+      @summary_page = Flow::Summaries.new(run&.flow || flow).summary_page
+      render template: @summary_page&.live_version ? "alembic/flows/summary_page" : "alembic/flows/complete"
+    end
+
+    def intro_values
+      starts_a_run = @flow.each_step? && !previewing?
+      { "title" => @flow.title.presence || @flow.slug, "summary" => flow_summary(@flow),
+        "question_count" => question_count, "starts_a_run" => starts_a_run,
+        "start_path" => starts_a_run ? alembic.flow_runs_path(@flow.slug) : first_step_path(@flow.slug) }
+    end
+
+    def question_count
+      Array(@flow.live_definition.to_h["nodes"]).count { |node| node["type"] == "question" }
+    end
+
+    def summary_values
+      @outputs.to_h { |output| [ output.id, output.value ] }
+        .merge("slug" => @guide.slug, "note" => result_note, "answers" => answers_given)
+    end
+
+    def answers_given
+      @answered.map { |step, value| [ @guide.question_text(step), @guide.choice_label(step, value) ] }
+    end
+
+    def result_note
+      finished_flow = run&.flow || flow
+      return Alembic.lead_note.call(finished_flow.title, @outputs.to_h { |output| [ output.id, output.value ] }) if Alembic.lead_note
+
+      [ finished_flow.title, *@outputs.map { |output| "#{output.label}: #{helpers.alembic_output_lines(output.value).join(', ')}" } ]
+        .compact_blank.join(". ")
     end
 
     def outputs_of(state)

data/app/helpers/alembic/application_helper.rb

@@ -1,9 +1,24 @@
 module Alembic
   module ApplicationHelper
+    def alembic_rules_text(rules)
+      Array(rules).map do |rule|
+        conditions = Array(rule["when"]).map do |condition|
+          condition.key?("is_not") ? "#{condition['step']} is not #{condition['is_not']}" : "#{condition['step']} is #{condition['is']}"
+        end
+        "#{rule['entry']}: #{conditions.join(', ')}".strip
+      end.join("\n")
+    end
+
+    def alembic_entry_texts(entry)
+      { "facts_text" => Array(entry["facts"]).map { |pair| pair.join(" | ") }.join("\n"),
+        "sections_text" => Array(entry["sections"]).map { |section| section.values_at("heading", "text", "note").compact.join(" | ") }.join("\n"),
+        "steps_text" => Array(entry["steps"]).map { |step| "#{step['title']}\n#{step['code']}" }.join("\n---\n") }
+    end
+
     def alembic_output_lines(value)
       case value
-      when Hash then value.map { |name, share| "#{name}: #{share}" }
-      when Array then value
+      when Hash then value.key?("name") ? [ value["name"] ] : value.map { |name, share| "#{name}: #{share}" }
+      when Array then value.map { |item| item.is_a?(Hash) ? item["name"] : item }
       else [ value ]
       end
     end

data/app/helpers/alembic/content_blocks_helper.rb

@@ -0,0 +1,31 @@
+module Alembic
+  module ContentBlocksHelper
+    def alembic_hero_block(headline: nil, kicker: nil, text: nil)
+      render "alembic/blocks/hero", headline: headline, kicker: kicker, text: text
+    end
+
+    def alembic_facts_block(question_count: nil)
+      facts = yield.to_s.lines.map(&:strip).compact_blank.map do |line|
+        line.gsub("{question_count}", question_count.to_s).split("|", 2).map(&:strip)
+      end
+      render "alembic/blocks/facts", facts: facts
+    end
+
+    START_LOOK = "inline-flex items-center justify-center font-semibold rounded-lg bg-accent-600 text-white hover:bg-accent-500 px-6 py-3 cursor-pointer".freeze
+
+    def alembic_start_block(start_path:, label: "Start →", starts_a_run: false)
+      return button_to(label, start_path, method: :post, class: START_LOOK) if starts_a_run
+
+      link_to label, start_path, class: START_LOOK
+    end
+
+    def alembic_code_block
+      render "alembic/blocks/code", code: yield.to_s
+    end
+
+    def alembic_table_block
+      heading, *rows = yield.to_s.lines.map(&:strip).compact_blank.map { |line| line.split("|").map(&:strip) }
+      render "alembic/blocks/table", heading: heading.to_a, rows: rows
+    end
+  end
+end

data/app/helpers/alembic/pages_helper.rb

@@ -4,28 +4,29 @@ module Alembic
   module PagesHelper
     UNDRAWABLE = "This block cannot be drawn until its fields are filled in.".freeze
 
-    def drawn_page(page, being_edited: false)
+    def drawn_page(page, being_edited: false, values: {})
       blocks = being_edited ? page.blocks : page.live_version&.blocks.to_a
-      drawn = blocks.to_h { |block| [ block["id"], drawn_block(block) ] }.compact
+      drawn = blocks.to_h { |block| [ block["id"], drawn_block(block, values: values) ] }.compact
 
       block_layout(blocks.select { |block| drawn.key?(block["id"]) }, kind: :pages) do |block|
         drawn.fetch(block["id"])
       end
     end
 
-    def drawn_block(block)
+    def drawn_block(block, values: {})
       component = Page::Drawing.of(block["type"])
       return unless component
 
+      options = Page::Options.for(block, values: values)
       body = Page::Options.body_for(block)
-      body.nil? ? send(component, **Page::Options.for(block)) : send(component, **Page::Options.for(block)) { body }
+      body.nil? ? send(component, **options) : send(component, **options) { body }
     rescue StandardError => undrawable
       Rails.logger.error("Alembic could not draw the #{block['type']} block: #{undrawable.message}")
       nil
     end
 
-    def shown_block(block)
-      drawn_block(block) || undrawn_block(block)
+    def shown_block(block, values: {})
+      drawn_block(block, values: values) || undrawn_block(block)
     end
 
     private

data/app/helpers/alembic/result_blocks_helper.rb

@@ -0,0 +1,57 @@
+module Alembic
+  module ResultBlocksHelper
+    def alembic_score_block(value: nil, caption: nil, kicker: "Your result")
+      render "alembic/blocks/score", value: value, caption: caption, kicker: kicker
+    end
+
+    def alembic_band_block(value: nil, score: nil)
+      render "alembic/blocks/band", band: value.to_h, tone: alembic_tone(score)
+    end
+
+    def alembic_categories_block(value: nil, heading: "Where you stand, area by area")
+      render "alembic/blocks/categories", shares: value.to_h, heading: heading
+    end
+
+    def alembic_weakest_block(value: nil, heading: "Your biggest blind spots", cost_label: "What it likely costs you:")
+      render "alembic/blocks/weakest", categories: Array(value), heading: heading, cost_label: cost_label
+    end
+
+    def alembic_answers_block(value: nil, heading: "What you told us")
+      render "alembic/blocks/answers", answers: Array(value), heading: heading
+    end
+
+    def alembic_lead_block(slug:, note: nil, heading: "The next step", blurb: nil, button: "Send", placeholder: "you@example.com")
+      render "alembic/blocks/lead", address: Alembic.lead_address.call(slug), slug: slug, note: note,
+        heading: heading, blurb: blurb, button: button, placeholder: placeholder
+    end
+
+    def alembic_default_result(output, outputs = [])
+      case output.type
+      when "percentage" then alembic_score_block(value: output.value, caption: output.label)
+      when "band" then alembic_band_block(value: output.value, score: outputs.find { |other| other.type == "percentage" }&.value)
+      when "grouped" then alembic_categories_block(value: output.value)
+      when "lowest" then alembic_weakest_block(value: output.value)
+      when "outcome" then alembic_outcome_block(value: output.value)
+      else ui_stat_card(label: output.label, value: alembic_output_lines(output.value).join(" · "))
+      end
+    end
+
+    def alembic_outcome_block(value: nil)
+      chosen = value.to_h["chosen"]
+      return "" if chosen.nil?
+
+      render "alembic/blocks/outcome_entry", entry: chosen, open: true
+    end
+
+    def alembic_outcomes_block(value: nil, heading: nil)
+      render "alembic/blocks/outcomes", entries: Array(value.to_h["entries"]), heading: heading
+    end
+
+    def alembic_tone(percentage)
+      return "bg-red-500" if percentage.to_i < 40
+      return "bg-amber-500" if percentage.to_i < 70
+
+      "bg-emerald-500"
+    end
+  end
+end

data/app/models/alembic/flow/definition_summary.rb

@@ -4,6 +4,8 @@ module Alembic
       self.table_name = "alembic_flow_definition_summaries"
 
       belongs_to :flow, class_name: "EasyFlow::Definition"
+      belongs_to :summary_page, class_name: "Alembic::Page", optional: true
+      belongs_to :intro_page, class_name: "Alembic::Page", optional: true
     end
   end
 end

data/app/models/alembic/flow/output_form.rb

@@ -0,0 +1,74 @@
+module Alembic
+  module Flow
+    module OutputForm
+      def self.edited(current, submitted)
+        edited = submitted.sort_by { |index, _| index.to_i }.map do |index, output|
+          current.fetch(index.to_i, {}).merge(output.except("rules_text")).merge(listed_bands(output)).merge(counted(output))
+            .merge(ruled(output)).merge(listed_entries(output))
+        end
+        edited.select { |output| output["id"].present? }
+      end
+
+      def self.listed_entries(output)
+        return {} unless output["entries"].is_a?(Hash)
+
+        entries = output["entries"].sort_by { |position, _| position.to_i }.map(&:last).select { |entry| entry["key"].present? }
+        { "entries" => entries.map { |entry| entry_from(entry) } }
+      end
+
+      def self.entry_from(entry)
+        entry.except("facts_text", "sections_text", "steps_text")
+          .merge("facts" => pairs(entry["facts_text"]), "sections" => sections(entry["sections_text"]), "steps" => steps(entry["steps_text"]))
+      end
+
+      def self.steps(text)
+        text.to_s.split(/^---\s*$/).map(&:strip).compact_blank.map do |block|
+          title, code = block.split("\n", 2)
+          { "title" => title.strip, "code" => code.to_s.strip }
+        end
+      end
+
+      def self.sections(text)
+        text.to_s.lines.map(&:strip).compact_blank.map do |line|
+          heading, body, note = line.split("|", 3).map(&:strip)
+          { "heading" => heading, "text" => body, "note" => note }
+        end
+      end
+
+      def self.pairs(text)
+        text.to_s.lines.map(&:strip).compact_blank.map { |line| line.split("|", 2).map(&:strip) }
+      end
+
+      def self.ruled(output)
+        return {} unless output.key?("rules_text")
+
+        rules = output["rules_text"].to_s.lines.map(&:strip).compact_blank.map do |line|
+          entry, conditions = line.split(":", 2)
+          { "entry" => entry.strip, "when" => conditions.to_s.split(",").map(&:strip).compact_blank.map { |condition| condition_from(condition) } }
+        end
+        { "rules" => rules }
+      end
+
+      def self.condition_from(text)
+        step, answer = text.split(/\s+is not\s+/, 2)
+        return { "step" => step, "is_not" => answer } if answer
+
+        step, answer = text.split(/\s+is\s+/, 2)
+        { "step" => step, "is" => answer }
+      end
+
+      def self.counted(output)
+        output.key?("count") ? { "count" => output["count"].presence&.to_i } : {}
+      end
+
+      def self.listed_bands(output)
+        return {} unless output["bands"].is_a?(Hash)
+
+        named = output["bands"].sort_by { |position, _| position.to_i }.map(&:last).select { |band| band["name"].present? }
+        { "bands" => named.map { |band| band.merge("ceiling" => band["ceiling"].presence&.to_i) } }
+      end
+
+      private_class_method :counted, :listed_bands, :ruled, :condition_from, :listed_entries, :pairs, :entry_from, :sections, :steps
+    end
+  end
+end

data/app/models/alembic/flow/preview_values.rb

@@ -0,0 +1,47 @@
+module Alembic
+  module Flow
+    module PreviewValues
+      def self.values(page, choice)
+        flow = flow_for(page)
+        return {} if flow.nil?
+
+        summaries = Summaries.new(flow)
+        state = finished_runs(flow).find { |run| run.id.to_s == choice.to_s }&.recorded || sample_state(flow)
+        introduced(flow, summaries).merge(summaries.of(state).to_h { |result| [ result.id, result.value ] })
+      end
+
+      def self.finished_runs(flow)
+        EasyFlow::Run.where(flow: flow).order(created_at: :desc).limit(20).select { |run| run.next_step(run.recorded).nil? }
+      end
+
+      def self.introduced(flow, summaries)
+        questions = Array(flow.live_definition.to_h["nodes"]).count { |node| node["type"] == "question" }
+        { "title" => flow.title.presence || flow.slug, "summary" => summaries.text, "question_count" => questions,
+          "slug" => flow.slug, "start_path" => "#", "starts_a_run" => false }
+      end
+
+      def self.choices(page)
+        flow = flow_for(page)
+        return [] if flow.nil?
+
+        finished_runs(flow).map { |run| [ "Run of #{I18n.l(run.created_at, format: :short)}", run.id.to_s ] }
+      end
+
+      def self.flow_for(page)
+        DefinitionSummary.where(summary_page: page).or(DefinitionSummary.where(intro_page: page)).first&.flow
+      end
+
+      def self.sample_state(flow)
+        questions = Array(flow.live_definition.to_h["nodes"]).select { |node| node["type"] == "question" }
+        questions.each_with_index.filter_map do |question, index|
+          answers = EasyFlow::Steps::Question.answers_of(question)
+          next if answers.empty?
+
+          [ question["id"], answers[index % answers.size].then { |answer| answer.is_a?(Hash) ? answer["value"] : answer } ]
+        end.to_h
+      end
+
+      private_class_method :flow_for, :introduced, :finished_runs
+    end
+  end
+end

data/app/models/alembic/flow/summaries.rb

@@ -14,6 +14,7 @@ module Alembic
       end
 
       def record(payload)
+        Array(payload.to_h["outputs"]).each { |output| Summary.registry.fetch(output["type"]) if output["type"].present? }
         versions.create!(number: next_number, summary: payload)
           .tap { |version| details.update!(summary_cursor: version.number) }
       end
@@ -34,6 +35,44 @@ module Alembic
         details.update!(summary: text)
       end
 
+      def summary_page
+        details.summary_page
+      end
+
+      def shows_answer_values?
+        details.shows_answer_values
+      end
+
+      def show_answer_values(shown)
+        details.update!(shows_answer_values: shown)
+      end
+
+      def asks_on_one_page?
+        details.asks_on_one_page
+      end
+
+      def ask_on_one_page(asked)
+        details.update!(asks_on_one_page: asked && !branches?)
+      end
+
+      def branches?
+        Array(@flow.definition.to_h["nodes"]).any? do |node|
+          EasyFlow.registry.registered?(node["type"]) && EasyFlow.registry.fetch(node["type"]).routes?
+        end
+      end
+
+      def intro_page
+        details.intro_page
+      end
+
+      def start_on(page)
+        details.update!(intro_page: page)
+      end
+
+      def finish_on(page)
+        details.update!(summary_page: page)
+      end
+
       def pin(run)
         RunSummary.create!(run: run, summary_version: current_version) if current_version
       end

data/app/models/alembic/outputs/band.rb

@@ -15,7 +15,7 @@ module Alembic
       def self.covering(config, number)
         ordered = Array(config["bands"]).sort_by { |band| band["ceiling"] || Float::INFINITY }
 
-        ordered.find { |band| band["ceiling"].nil? || number < band["ceiling"] }&.fetch("name", nil)
+        ordered.find { |band| band["ceiling"].nil? || number < band["ceiling"] }&.slice("name", "description")
       end
     end
   end

data/app/models/alembic/outputs/lowest.rb

@@ -4,7 +4,7 @@ module Alembic
       def self.output_type
         Summary::OutputType.define(:lowest) do
           label "Weakest"
-          compute { |config, _run, so_far| Lowest.of(so_far[config["of"]], config["count"]) }
+          compute { |config, _run, so_far| Lowest.of(so_far[config["of"]], config["count"], config["copy"]) }
         end
       end
 
@@ -12,8 +12,10 @@ module Alembic
         registry.register(output_type)
       end
 
-      def self.of(shares, count)
-        shares.to_h.sort_by { |_name, share| share }.first(count.presence&.to_i || 1).map(&:first)
+      def self.of(shares, count, copy = nil)
+        weakest = shares.to_h.sort_by { |_name, share| share }.first(count.presence&.to_i || 1).map(&:first)
+
+        weakest.map { |name| { "name" => name, **copy.to_h.fetch(name, {}).slice("miss", "cost") } }
       end
     end
   end

data/app/models/alembic/outputs/outcome.rb

@@ -0,0 +1,33 @@
+module Alembic
+  module Outputs
+    module Outcome
+      def self.output_type
+        Summary::OutputType.define(:outcome) do
+          label "Outcome"
+          compute { |config, run, _so_far| Outcome.placed(config, run.state) }
+        end
+      end
+
+      def self.register(registry = Summary.registry)
+        registry.register(output_type)
+      end
+
+      def self.placed(config, state)
+        entries = Array(config["entries"])
+        rule = Array(config["rules"]).find { |candidate| holds?(candidate, state) }
+
+        { "chosen" => entries.find { |entry| entry["key"] == rule&.dig("entry") }, "entries" => entries }
+      end
+
+      def self.holds?(rule, state)
+        Array(rule["when"]).all? { |condition| met?(condition, state[condition["step"]].to_s) }
+      end
+
+      def self.met?(condition, answer)
+        return answer != condition["is_not"].to_s if condition.key?("is_not")
+
+        answer == condition["is"].to_s
+      end
+    end
+  end
+end