alembic 0.1.0 → 0.3.0

data/app/models/alembic/page/version.rb

@@ -0,0 +1,13 @@
+module Alembic
+  class Page < ApplicationRecord
+    class Version < ApplicationRecord
+      self.table_name = "alembic_page_versions"
+
+      enum :status, { draft: "draft", live: "live", superseded: "superseded" }
+
+      belongs_to :page, class_name: "Alembic::Page"
+
+      validates :number, uniqueness: { scope: :page_id }
+    end
+  end
+end

data/app/models/alembic/page.rb

@@ -6,6 +6,38 @@ module Alembic
 
     block_layout :blocks, kind: :pages
 
+    has_many :versions, class_name: "Alembic::Page::Version", dependent: :destroy, inverse_of: :page
+
     validates :name, presence: true
+    validates :slug, uniqueness: true, allow_nil: true
+
+    def publish
+      transaction do
+        live_version&.update!(status: :superseded)
+        versions.create!(number: next_number, blocks: blocks, status: :live)
+      end
+    end
+
+    def live_version
+      versions.find_by(status: :live)
+    end
+
+    def next_number
+      (versions.maximum(:number) || 0) + 1
+    end
+
+    def self.block(key, drawn_by: nil, options: {}, body: nil, **block_type)
+      refuse_unknown(key, drawn_by)
+      Drawing.record(key, drawn_by)
+      Options.declare(key, options, body: body)
+      KsBlocks.block(key, kind: :pages, **block_type)
+    end
+
+    def self.refuse_unknown(key, component)
+      return if component.nil? || ApplicationController.helpers.respond_to?(component)
+
+      raise ArgumentError, "The #{key} page block names #{component}, which nothing draws"
+    end
+    private_class_method :refuse_unknown
   end
 end

data/app/models/alembic/result_blocks.rb

@@ -0,0 +1,29 @@
+module Alembic
+  module ResultBlocks
+    OUTPUT = { key: :output, label: "Output" }.freeze
+    HEADING = { key: :heading, label: "Heading" }.freeze
+
+    def self.register
+      Page.block(:alembic_score, name: "Score", width: 12, height: 3, drawn_by: :alembic_score_block,
+        fields: [ OUTPUT, { key: :kicker, label: "Label above" }, { key: :caption, label: "Caption" } ],
+        options: { value: { value_of: :output } })
+      Page.block(:alembic_band, name: "Band", width: 12, height: 2, drawn_by: :alembic_band_block,
+        fields: [ OUTPUT, { key: :score, label: "Score output" } ],
+        options: { value: { value_of: :output }, score: { value_of: :score } })
+      Page.block(:alembic_categories, name: "Score per category", width: 12, height: 4, drawn_by: :alembic_categories_block,
+        fields: [ OUTPUT, HEADING ], options: { value: { value_of: :output } })
+      Page.block(:alembic_weakest, name: "Weakest categories", width: 12, height: 4, drawn_by: :alembic_weakest_block,
+        fields: [ OUTPUT, HEADING, { key: :cost_label, label: "Cost label" } ], options: { value: { value_of: :output } })
+      Page.block(:alembic_answers, name: "Answers given", width: 12, height: 4, drawn_by: :alembic_answers_block,
+        fields: [ HEADING ], options: { value: { value: "answers" } })
+      register_lead if Alembic.lead_address
+    end
+
+    def self.register_lead
+      Page.block(:alembic_lead, name: "Lead", width: 12, height: 3, drawn_by: :alembic_lead_block,
+        fields: [ HEADING, { key: :blurb, label: "Text" }, { key: :button, label: "Button" }, { key: :placeholder, label: "Placeholder" } ],
+        options: { slug: { value: "slug" }, note: { value: "note" } })
+    end
+    private_class_method :register_lead
+  end
+end

data/app/models/alembic/summary/report.rb

@@ -13,7 +13,7 @@ module Alembic
           output_type = @registry.fetch(output["type"])
           produced[output["id"]] = output_type.compute(output, run, produced)
 
-          Result.new(id: output["id"], label: label_for(output, output_type), value: produced[output["id"]])
+          Result.new(id: output["id"], type: output["type"], label: label_for(output, output_type), value: produced[output["id"]])
         end
       end
 

data/app/models/alembic/summary/result.rb

@@ -1,5 +1,5 @@
 module Alembic
   module Summary
-    Result = Data.define(:id, :label, :value)
+    Result = Data.define(:id, :type, :label, :value)
   end
 end

data/app/views/alembic/blocks/_answers.html.erb

@@ -0,0 +1,11 @@
+<div>
+  <h2 class="text-xs font-semibold uppercase tracking-wider text-gray-500 mb-4"><%= heading %></h2>
+  <ul class="divide-y divide-gray-100 border-y border-gray-100">
+    <% answers.each do |question, answer| %>
+      <li class="flex items-baseline justify-between gap-6 py-3">
+        <span class="text-gray-600"><%= question %></span>
+        <span class="shrink-0 font-semibold text-gray-900"><%= answer %></span>
+      </li>
+    <% end %>
+  </ul>
+</div>

data/app/views/alembic/blocks/_band.html.erb

@@ -0,0 +1,6 @@
+<div class="text-center">
+  <span class="inline-block mt-5 px-4 py-1.5 rounded-full text-sm font-semibold text-white <%= tone %>"><%= band["name"] %></span>
+  <% if band["description"].present? %>
+    <p class="text-gray-600 leading-relaxed max-w-lg mx-auto mt-4"><%= band["description"] %></p>
+  <% end %>
+</div>

data/app/views/alembic/blocks/_categories.html.erb

@@ -0,0 +1,11 @@
+<div>
+  <h2 class="text-xs font-semibold uppercase tracking-wider text-gray-500 mb-4"><%= heading %></h2>
+  <% shares.each do |name, share| %>
+    <div class="flex items-center gap-3 mb-2.5">
+      <span class="text-sm text-gray-600 w-44 shrink-0"><%= name %></span>
+      <span class="flex-1 h-2 bg-gray-100 rounded-full overflow-hidden">
+        <span class="block h-full rounded-full <%= alembic_tone(share) %>" style="width:<%= [ share.to_i, 4 ].max %>%"></span>
+      </span>
+    </div>
+  <% end %>
+</div>

data/app/views/alembic/blocks/_lead.html.erb

@@ -0,0 +1,15 @@
+<%= ui_panel(padding: :lg) do %>
+  <h2 class="text-xl font-semibold text-gray-900 mb-2"><%= heading %></h2>
+  <% if blurb.present? %>
+    <p class="text-gray-600 mb-5"><%= blurb %></p>
+  <% end %>
+  <%= form_with url: address, method: :post, class: "flex flex-col sm:flex-row gap-3" do %>
+    <%= render Alembic.lead_fields_partial if Alembic.lead_fields_partial %>
+    <%= hidden_field_tag "slug", slug %>
+    <%= hidden_field_tag "note", note %>
+    <div class="flex-1">
+      <%= ui_input(name: "email", type: :email, placeholder: placeholder) %>
+    </div>
+    <button type="submit" class="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 whitespace-nowrap"><%= button %></button>
+  <% end %>
+<% end %>

data/app/views/alembic/blocks/_score.html.erb

@@ -0,0 +1,7 @@
+<div class="text-center">
+  <p class="text-xs font-semibold uppercase tracking-widest text-accent-600 mb-4"><%= kicker %></p>
+  <div class="text-7xl md:text-8xl font-bold tracking-tight text-gray-900"><%= value.nil? ? "—" : "#{value}%" %></div>
+  <% if caption.present? %>
+    <p class="text-sm text-gray-500 mt-1"><%= caption %></p>
+  <% end %>
+</div>

data/app/views/alembic/blocks/_weakest.html.erb

@@ -0,0 +1,12 @@
+<div>
+  <h2 class="text-xs font-semibold uppercase tracking-wider text-gray-500 mb-4"><%= heading %></h2>
+  <div class="space-y-4">
+    <% categories.each do |category| %>
+      <%= ui_panel(padding: :lg) do %>
+        <h3 class="text-lg font-semibold text-gray-900 mb-1.5"><%= category["name"] %></h3>
+        <p class="text-gray-700 mb-2"><%= category["miss"] %></p>
+        <p class="text-sm text-accent-700"><span class="font-semibold"><%= cost_label %></span> <%= category["cost"] %></p>
+      <% end %>
+    <% end %>
+  </div>
+</div>

data/app/views/alembic/flows/complete.html.erb

@@ -11,22 +11,28 @@
 
   <% if @outputs.any? %>
     <%= ui_section do %>
-      <%= ui_grid(cols: { default: 1, sm: 2 }, gap: :lg) do %>
+      <div class="space-y-10">
         <% @outputs.each do |output| %>
           <div data-output="<%= output.id %>">
-            <%= ui_stat_card(label: output.label, value: alembic_output_lines(output.value).join(" · ")) %>
+            <%= alembic_default_result(output, @outputs) %>
           </div>
         <% end %>
-      <% end %>
+      </div>
+    <% end %>
+  <% end %>
+
+  <% if Alembic.lead_address %>
+    <%= ui_section do %>
+      <%= alembic_lead_block(slug: summary_values["slug"], note: summary_values["note"]) %>
     <% end %>
   <% end %>
 
   <%= ui_section(title: @outputs.any? ? "What you told us" : nil) do %>
-    <ul class="divide-y divide-gray-100 border-y border-gray-100">
+    <ul class="divide-y divide-(color:--ks-color-divider) border-y border-(color:--ks-color-divider) dark:divide-(color:--ks-color-divider-dark) dark:border-(color:--ks-color-divider-dark)">
       <% @answered.each do |step, value| %>
         <li data-answer="<%= step %>" class="flex items-baseline justify-between gap-6 py-3">
-          <span class="text-gray-600"><%= @guide.question_text(step) %></span>
-          <span class="shrink-0 font-medium text-gray-900"><%= @guide.choice_label(step, value) %></span>
+          <span class="ks-tone-muted"><%= @guide.question_text(step) %></span>
+          <span class="shrink-0 font-(weight:--ks-font-weight-medium) ks-tone-neutral"><%= @guide.choice_label(step, value) %></span>
         </li>
       <% end %>
     </ul>

data/app/views/alembic/flows/show.html.erb

@@ -1,16 +1,16 @@
-<% content_for(:title, @diagnostic.title.presence || @diagnostic.slug) %>
+<% content_for(:title, @flow.title.presence || @flow.slug) %>
 
 <%= ui_page(max_width: :md) do %>
-  <%= ui_page_header(title: @diagnostic.title.presence || @diagnostic.slug, subtitle: @diagnostic.summary) %>
+  <%= ui_page_header(title: @flow.title.presence || @flow.slug, subtitle: flow_summary(@flow)) %>
 
   <%= ui_section do %>
     <div class="flex flex-wrap items-center gap-3">
-      <% if @diagnostic.each_step? && @diagnostic.definition.present? && !previewing? %>
-        <%= ui_form(action: alembic.flow_runs_path(@diagnostic.slug), method: :post) do %>
-          <%= ui_button(label: @diagnostic.start_label.presence || "Start", type: :submit) %>
+      <% if @flow.each_step? && @flow.definition.present? && !previewing? %>
+        <%= ui_form(action: alembic.flow_runs_path(@flow.slug), method: :post) do %>
+          <%= ui_button(label: @flow.start_label.presence || "Start", type: :submit) %>
         <% end %>
       <% else %>
-        <%= ui_button(label: @diagnostic.start_label.presence || "Start", href: flow_step_path(@diagnostic.slug)) %>
+        <%= ui_button(label: @flow.start_label.presence || "Start", href: first_step_path(@flow.slug)) %>
       <% end %>
     </div>
   <% end %>

data/app/views/alembic/flows/summary_page.html.erb

@@ -0,0 +1,5 @@
+<% content_for :head do %>
+  <%= stylesheet_link_tag "ks_blocks" %>
+<% end %>
+
+<%= drawn_page(@summary_page, values: summary_values) %>

data/app/views/alembic/manage/flows/edit.html.erb

@@ -1,24 +1,30 @@
 <%= ui_page(max_width: :lg) do %>
   <p class="mb-4">
-    <%= link_to "← Back to the flow", alembic.manage_flow_path(@diagnostic), class: "text-sm text-accent-600 hover:text-accent-700" %>
+    <%= link_to "← Back to the flow", easy_flow.manage_flow_path(@flow), class: "text-sm text-(color:--ks-color-link) hover:text-(color:--ks-color-link-hover) dark:text-(color:--ks-color-link-dark) dark:hover:text-(color:--ks-color-link-hover-dark)" %>
   </p>
 
-  <%= ui_form_page(title: "Edit details", back_url: alembic.manage_flow_path(@diagnostic)) %>
+  <%= ui_form_page(title: "Edit details", back_url: easy_flow.manage_flow_path(@flow)) %>
 
-  <%= ui_form(action: alembic.manage_flow_path(@diagnostic), method: :patch) do %>
+  <%= ui_form(action: easy_flow.manage_flow_path(@flow), method: :patch) do %>
     <%= ui_section(title: "How this is introduced") do %>
-      <label class="block text-sm font-medium mb-1">Title</label>
-      <%= ui_input(name: "flow[title]", value: @diagnostic.title) %>
+      <label class="ks-label mb-1">Title</label>
+      <%= ui_input(name: "flow[title]", value: @flow.title) %>
 
-      <label class="block text-sm font-medium mb-1 mt-4">Summary</label>
-      <%= ui_textarea(name: "flow[summary]", value: @diagnostic.summary, rows: 4) %>
+      <label class="ks-label mb-1 mt-4">Summary</label>
+      <%= ui_textarea(name: "flow[summary]", value: @summary, rows: 4) %>
 
-      <label class="block text-sm font-medium mb-1 mt-4">Start label</label>
-      <%= ui_input(name: "flow[start_label]", value: @diagnostic.start_label) %>
+      <label class="ks-label mb-1 mt-4">Start label</label>
+      <%= ui_input(name: "flow[start_label]", value: @flow.start_label) %>
+    <% end %>
+
+    <%= ui_section(title: "Where this finishes") do %>
+      <%= ui_select(name: "flow[summary_page_id]", selected: @summary_page&.id,
+            include_blank: "Alembic's default summary page",
+            options: @published_pages.map { |page| [ page.name, page.id ] }) %>
     <% end %>
 
     <%= ui_section(title: "What this keeps of a run") do %>
-      <%= ui_select(name: "flow[persists]", selected: @diagnostic.persists,
+      <%= ui_select(name: "flow[persists]", selected: @flow.persists,
             options: [ [ "Nothing", "unsaved" ],
                        [ "Every answer as it is given", "each_step" ],
                        [ "The whole run once it finishes", "on_finish" ] ]) %>

data/app/views/alembic/manage/pages/_block_content.html.erb

@@ -1 +1 @@
-<%= KsBlocks.registry.block_types(kind: :pages).find { |type| type.key.to_s == block["type"] }&.name %>
+<%= shown_block(block) %>

data/app/views/alembic/manage/pages/index.html.erb

@@ -11,9 +11,12 @@
 
   <%= ui_section(title: "Create a page") do %>
     <%= ui_form(action: alembic.manage_pages_path, method: :post) do %>
-      <label class="block text-sm font-medium mb-1">Name</label>
+      <label class="ks-label mb-1">Name</label>
       <%= ui_input(name: "page[name]", placeholder: "e.g. Welcome") %>
 
+      <label class="ks-label mb-1">Address</label>
+      <%= ui_input(name: "page[slug]", placeholder: "e.g. welcome") %>
+
       <%= ui_button(label: "Create", type: :submit, variant: :secondary) %>
     <% end %>
   <% end %>

data/app/views/alembic/manage/pages/show.html.erb

@@ -4,7 +4,13 @@
   <%= javascript_include_tag "alembic/page_builder", defer: true %>
 <% end %>
 
-<%= react_ui("alembic/page-builder", @payload.merge(token: form_authenticity_token)) %>
+<%= ui_form(action: alembic.publish_manage_page_path(@page), method: :post) do %>
+  <%= ui_button(label: "Publish", type: :submit, variant: :secondary) %>
+<% end %>
+
+<%= ui_panel do %>
+  <%= react_ui("alembic/page-builder", @payload.merge(token: form_authenticity_token)) %>
+<% end %>
 
 <%= block_contents(@page.blocks) do |block| %>
   <%= render "alembic/manage/pages/block_content", block: block %>

data/app/views/alembic/pages/show.html.erb

@@ -0,0 +1,5 @@
+<% content_for :head do %>
+  <%= stylesheet_link_tag "ks_blocks" %>
+<% end %>
+
+<%= drawn_page(@page) %>

data/config/routes.rb

@@ -1,6 +1,7 @@
 Alembic::Engine.routes.draw do
   namespace :manage do
     resources :pages, only: [ :index, :create, :show ] do
+      post "publish", on: :member
       get "layout", to: "page_blocks#layout", as: :layout
       post "blocks", to: "page_blocks#add_block", as: :blocks
       patch "blocks", to: "page_blocks#place_blocks"
@@ -8,35 +9,23 @@ Alembic::Engine.routes.draw do
       delete "blocks/:block_id", to: "page_blocks#remove_block", as: :block
     end
 
-    resources :flows, only: [ :index, :create, :show, :edit, :update, :destroy ] do
-      resource :definition, only: [ :edit, :update ]
+    resources :flows, only: [ :edit, :update ] do
       resource :preview, only: :show, controller: "previews" do
         get :step
       end
-      resources :versions, only: :index do
-        post :return, on: :member
-      end
-
-      resource :canvas, only: :show, controller: "canvas" do
-        post   "steps",       action: :add_step
-        patch  "steps/:step", action: :configure_step
-        delete "steps/:step",      action: :remove_step
-        patch  "steps/:step/move", action: :move_step
-        post   "versions",    action: :create
-        post   "publish",     action: :publish
-        patch  "details",     action: :details
-        post   "undo",        action: :undo
-        post   "redo",        action: :redo
-        post   "edges",       action: :connect
-        delete "edges",       action: :disconnect
-      end
     end
   end
 
+  constraints(->(request) { request.path_info.match?(%r{\A/manage/flows(/|\z)}) }) do
+    mount EasyFlow::Engine, at: "/", defaults: { easy_flow_host: Alembic::FLOW_HOST.to_s }
+  end
+
   post ":slug/runs", to: "flows#start", as: :flow_runs
   get "runs/:id", to: "flows#step", as: :run
   patch "runs/:id", to: "flows#update"
 
+  get "pages/:slug", to: "pages#show", as: :page
+
   get ":slug", to: "flows#show", as: :flow
   get ":slug/step", to: "flows#step", as: :flow_step
 end

data/db/migrate/20260825224538_remove_published_version_from_alembic_diagnostics.rb

@@ -1,5 +1,25 @@
 class RemovePublishedVersionFromAlembicDiagnostics < ActiveRecord::Migration[8.1]
-  def change
+  class Diagnostic < ActiveRecord::Base
+    self.table_name = "alembic_diagnostics"
+  end
+
+  class DefinitionVersion < ActiveRecord::Base
+    self.table_name = "alembic_definition_versions"
+  end
+
+  def up
+    [ Diagnostic, DefinitionVersion ].each(&:reset_column_information)
+    DefinitionVersion.where(id: Diagnostic.where.not(published_version_id: nil).select(:published_version_id)).update_all(status: "live")
+
     remove_reference :alembic_diagnostics, :published_version, foreign_key: { to_table: :alembic_definition_versions }
   end
+
+  def down
+    add_reference :alembic_diagnostics, :published_version, foreign_key: { to_table: :alembic_definition_versions }
+
+    [ Diagnostic, DefinitionVersion ].each(&:reset_column_information)
+    DefinitionVersion.where(status: "live").find_each do |version|
+      Diagnostic.where(id: version.diagnostic_id).update_all(published_version_id: version.id)
+    end
+  end
 end

data/db/migrate/20260922120000_add_slug_to_alembic_pages.rb

@@ -0,0 +1,6 @@
+class AddSlugToAlembicPages < ActiveRecord::Migration[8.1]
+  def change
+    add_column :alembic_pages, :slug, :string
+    add_index :alembic_pages, :slug, unique: true
+  end
+end

data/db/migrate/20260922130000_create_alembic_page_versions.rb

@@ -0,0 +1,16 @@
+class CreateAlembicPageVersions < ActiveRecord::Migration[8.1]
+  def change
+    create_table :alembic_page_versions do |t|
+      t.references :page, null: false, foreign_key: { to_table: :alembic_pages }
+      t.integer :number, null: false
+      t.json :blocks, default: [], null: false
+      t.string :status, null: false, default: "draft"
+
+      t.timestamps
+    end
+
+    add_index :alembic_page_versions, [ :page_id, :number ], unique: true
+    add_index :alembic_page_versions, :page_id, unique: true, where: "status = 'live'",
+      name: "index_alembic_page_versions_on_one_live_per_page"
+  end
+end

data/db/migrate/20260924220000_move_flows_onto_easy_flow.rb

@@ -0,0 +1,166 @@
+class MoveFlowsOntoEasyFlow < ActiveRecord::Migration[8.1]
+  HOST = "alembic"
+  FLOW_COLUMNS = %w[slug title start_label kind status persists document definition_cursor
+    changes_since_version undo_history undone_changes created_at updated_at].freeze
+
+  class OldFlow < ActiveRecord::Base
+    self.table_name = "alembic_flows"
+  end
+
+  class Definition < ActiveRecord::Base
+    self.table_name = "easy_flow_definitions"
+  end
+
+  class OldVersion < ActiveRecord::Base
+    self.table_name = "alembic_flow_versions"
+  end
+
+  class Version < ActiveRecord::Base
+    self.table_name = "easy_flow_versions"
+  end
+
+  class OldRun < ActiveRecord::Base
+    self.table_name = "alembic_flow_runs"
+  end
+
+  class Run < ActiveRecord::Base
+    self.table_name = "easy_flow_runs"
+  end
+
+  class SummaryVersion < ActiveRecord::Base
+    self.table_name = "alembic_flow_summaries"
+  end
+
+  class DefinitionSummary < ActiveRecord::Base
+    self.table_name = "alembic_flow_definition_summaries"
+  end
+
+  class RunSummary < ActiveRecord::Base
+    self.table_name = "alembic_flow_run_summaries"
+  end
+
+  def up
+    [ OldFlow, Definition, OldVersion, Version, OldRun, Run, SummaryVersion ].each(&:reset_column_information)
+    flows = copy_flows
+    versions = copy_versions(flows)
+    runs = copy_runs(flows, versions)
+    summaries = OldFlow.pluck(:id, :summary, :summary_cursor)
+    pins = OldRun.where.not(summary_version_id: nil).pluck(:id, :summary_version_id)
+
+    drop_table :alembic_flow_runs
+    remove_foreign_key :alembic_flow_summaries, column: :flow_id
+    repoint_summary_versions(flows)
+    drop_table :alembic_flow_versions
+    drop_table :alembic_flows
+    add_foreign_key :alembic_flow_summaries, :easy_flow_definitions, column: :flow_id, on_delete: :cascade
+
+    create_table :alembic_flow_definition_summaries do |t|
+      t.references :flow, null: false, index: { unique: true },
+        foreign_key: { to_table: :easy_flow_definitions, on_delete: :cascade }
+      t.text :summary
+      t.integer :summary_cursor
+      t.timestamps
+    end
+    restore_summaries(summaries, flows)
+
+    create_table :alembic_flow_run_summaries do |t|
+      t.references :run, null: false, index: { unique: true },
+        foreign_key: { to_table: :easy_flow_runs, on_delete: :cascade }
+      t.references :summary_version, null: false,
+        foreign_key: { to_table: :alembic_flow_summaries, on_delete: :cascade }
+      t.timestamps
+    end
+    restore_pins(pins, runs)
+  end
+
+  def down
+    drop_table :alembic_flow_run_summaries
+    drop_table :alembic_flow_definition_summaries
+    remove_foreign_key :alembic_flow_summaries, column: :flow_id
+    execute "DELETE FROM alembic_flow_summaries"
+
+    create_table :alembic_flows do |t|
+      t.string :slug
+      t.string :title
+      t.text :summary
+      t.string :start_label
+      t.string :kind
+      t.string :status, null: false, default: "active"
+      t.string :persists, null: false, default: "unsaved"
+      t.json :document
+      t.integer :definition_cursor
+      t.integer :summary_cursor
+      t.json :changes_since_version
+      t.json :undo_history
+      t.json :undone_changes
+      t.timestamps
+    end
+    add_index :alembic_flows, :slug, unique: true
+
+    create_table :alembic_flow_versions do |t|
+      t.references :flow, null: false, foreign_key: { to_table: :alembic_flows }
+      t.integer :number, null: false
+      t.json :definition
+      t.json :changes_captured
+      t.string :status, null: false, default: "draft"
+      t.datetime :created_at, null: false
+    end
+    add_index :alembic_flow_versions, [ :flow_id, :number ], unique: true
+    add_index :alembic_flow_versions, :flow_id, unique: true, where: "status = 'live'",
+      name: "index_alembic_flow_versions_on_one_live_per_flow"
+
+    add_foreign_key :alembic_flow_summaries, :alembic_flows, column: :flow_id
+
+    create_table :alembic_flow_runs do |t|
+      t.references :flow, null: false, foreign_key: { to_table: :alembic_flows }
+      t.references :definition_version, null: false, foreign_key: { to_table: :alembic_flow_versions }
+      t.references :summary_version, foreign_key: { to_table: :alembic_flow_summaries }
+      t.references :owner, polymorphic: true
+      t.json :recorded
+      t.string :label
+      t.string :status
+      t.timestamps
+    end
+  end
+
+  private
+
+  def copy_flows
+    OldFlow.order(:id).to_h do |flow|
+      [ flow.id, Definition.create!(flow.attributes.slice(*FLOW_COLUMNS).merge("host" => HOST)).id ]
+    end
+  end
+
+  def copy_versions(flows)
+    OldVersion.order(:id).to_h do |version|
+      copied = version.attributes.slice("number", "definition", "changes_captured", "status", "created_at")
+      [ version.id, Version.create!(copied.merge("flow_id" => flows.fetch(version.flow_id))).id ]
+    end
+  end
+
+  def copy_runs(flows, versions)
+    OldRun.order(:id).to_h do |run|
+      copied = run.attributes.slice("owner_type", "owner_id", "recorded", "label", "status", "created_at", "updated_at")
+      moved = copied.merge("flow_id" => flows.fetch(run.flow_id), "definition_version_id" => versions.fetch(run.definition_version_id))
+      [ run.id, Run.create!(moved).id ]
+    end
+  end
+
+  def restore_summaries(summaries, flows)
+    DefinitionSummary.reset_column_information
+    summaries.each do |flow_id, summary, cursor|
+      next if summary.nil? && cursor.nil?
+
+      DefinitionSummary.create!(flow_id: flows.fetch(flow_id), summary: summary, summary_cursor: cursor)
+    end
+  end
+
+  def restore_pins(pins, runs)
+    RunSummary.reset_column_information
+    pins.each { |run_id, summary_version_id| RunSummary.create!(run_id: runs.fetch(run_id), summary_version_id: summary_version_id) }
+  end
+
+  def repoint_summary_versions(flows)
+    SummaryVersion.find_each { |version| version.update_columns(flow_id: flows.fetch(version.flow_id)) }
+  end
+end

data/db/migrate/20260930120000_add_summary_page_to_alembic_flow_definition_summaries.rb

@@ -0,0 +1,6 @@
+class AddSummaryPageToAlembicFlowDefinitionSummaries < ActiveRecord::Migration[8.1]
+  def change
+    add_reference :alembic_flow_definition_summaries, :summary_page,
+      foreign_key: { to_table: :alembic_pages, on_delete: :nullify }
+  end
+end

data/lib/alembic/engine.rb

@@ -1,6 +1,7 @@
 require "alembic/leftover_stylesheet"
 require "keystone_ui-blocks"
 require "keystone_ui-react"
+require "easy_flow"
 
 module Alembic
   class Engine < ::Rails::Engine
@@ -19,18 +20,8 @@ module Alembic
       KeystoneUi.configuration.tailwind_sources << root.join("app/assets/builds/alembic/*.js").to_s
     end
 
-    initializer "alembic.step_types" do |app|
+    initializer "alembic.output_types" do |app|
       app.config.to_prepare do
-        Alembic::Flow::Start.register
-        Alembic::Flow::Terminal.register
-
-        Alembic::Steps::Question.register
-        Alembic::Flow::Condition.register
-        Alembic::Flow::Switch.register
-
-        Alembic::Flow.check(:unrouted_value)
-        Alembic::Flow.check(:unfollowed_path)
-        Alembic::Flow.check(:dead_end)
         Alembic::Outputs::WeightedSum.register
         Alembic::Outputs::Percentage.register
         Alembic::Outputs::Grouped.register
@@ -39,5 +30,9 @@ module Alembic
         Alembic::Outputs::Band.register
       end
     end
+
+    initializer "alembic.result_blocks" do |app|
+      app.config.to_prepare { Alembic::ResultBlocks.register }
+    end
   end
 end

data/lib/alembic/version.rb

@@ -1,3 +1,3 @@
 module Alembic
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end