plum-cms 0.2.1 → 0.2.2

data/app/services/plum/draft_diff.rb

@@ -0,0 +1,177 @@
+module Plum
+  # Field-by-field comparison between an entry's live content and its working
+  # draft, tokenized for git-style rendering (equal / deleted / inserted
+  # segments). Rich text is compared as readable text, structured fields as
+  # pretty-printed JSON.
+  class DraftDiff
+    # Beyond this many differing tokens, fall back to a wholesale
+    # replaced-block diff instead of an O(n*m) LCS table.
+    TOKEN_LIMIT = 1500
+
+    FieldChange = Struct.new(:handle, :label, :segments, keyword_init: true)
+
+    def initialize(entry)
+      @entry = entry
+      @content_type = entry.content_type
+    end
+
+    def changes
+      @changes ||= build_changes
+    end
+
+    def any?
+      changes.any?
+    end
+
+    # Word-level diff as [[op, text], ...] with op in :eq/:del/:ins.
+    # Whitespace is kept as tokens so spacing survives reconstruction.
+    def self.word_diff(old_text, new_text)
+      a = tokenize(old_text)
+      b = tokenize(new_text)
+
+      prefix = common_prefix_length(a, b)
+      suffix = common_suffix_length(a, b, prefix)
+      middle_a = a[prefix...(a.length - suffix)]
+      middle_b = b[prefix...(b.length - suffix)]
+
+      segments = []
+      segments << [ :eq, a.first(prefix).join ] if prefix.positive?
+      segments.concat(diff_middle(middle_a, middle_b))
+      segments << [ :eq, a.last(suffix).join ] if suffix.positive?
+      merge_segments(segments)
+    end
+
+    private
+
+    attr_reader :entry, :content_type
+
+    def build_changes
+      list = []
+
+      if entry.draft_title.to_s != entry.title.to_s
+        list << FieldChange.new(handle: "title", label: "Title",
+                                segments: self.class.word_diff(entry.title.to_s, entry.draft_title.to_s))
+      end
+
+      live_data = entry.data.to_h
+      draft_data = entry.draft_data.to_h["data"] || {}
+
+      (live_data.keys | draft_data.keys).each do |handle|
+        field = field_definition(handle)
+        live = normalize(live_data[handle], field)
+        draft = normalize(draft_data.key?(handle) ? draft_data[handle] : live_data[handle], field)
+        next if live == draft
+
+        list << FieldChange.new(handle: handle, label: label_for(handle, field),
+                                segments: self.class.word_diff(live, draft))
+      end
+
+      list
+    end
+
+    def field_definition(handle)
+      content_type.fields.find { |field| field["handle"].to_s == handle }
+    end
+
+    def label_for(handle, field)
+      field&.dig("label").presence || handle.humanize
+    end
+
+    def normalize(value, field)
+      case value
+      when nil then ""
+      when Hash, Array then JSON.pretty_generate(value)
+      when String
+        field&.dig("type") == "rich_text" ? html_to_text(value) : value
+      else value.to_s
+      end
+    end
+
+    def html_to_text(html)
+      text = html.gsub(%r{<(br|/p|/h[1-6]|/li|/blockquote|/div|/tr|/figcaption)[^>]*>}i, "\n")
+      text = ActionController::Base.helpers.strip_tags(text).to_s
+      text.split("\n").map(&:strip).join("\n").gsub(/\n{3,}/, "\n\n").strip
+    end
+
+    class << self
+      private
+
+      def tokenize(text)
+        text.to_s.scan(/\S+|\s+/)
+      end
+
+      def common_prefix_length(a, b)
+        limit = [ a.length, b.length ].min
+        (0...limit).each { |i| return i if a[i] != b[i] }
+        limit
+      end
+
+      def common_suffix_length(a, b, prefix)
+        limit = [ a.length, b.length ].min - prefix
+        (0...limit).each { |i| return i if a[a.length - 1 - i] != b[b.length - 1 - i] }
+        limit
+      end
+
+      def diff_middle(a, b)
+        return [] if a.empty? && b.empty?
+        return [ [ :ins, b.join ] ] if a.empty?
+        return [ [ :del, a.join ] ] if b.empty?
+        if a.length > TOKEN_LIMIT || b.length > TOKEN_LIMIT
+          return [ [ :del, a.join ], [ :ins, b.join ] ]
+        end
+
+        lcs_segments(a, b)
+      end
+
+      # Standard LCS dynamic program with backtracking; inputs are bounded by
+      # TOKEN_LIMIT after prefix/suffix trimming.
+      def lcs_segments(a, b)
+        rows = a.length + 1
+        cols = b.length + 1
+        table = Array.new(rows) { Array.new(cols, 0) }
+
+        (a.length - 1).downto(0) do |i|
+          (b.length - 1).downto(0) do |j|
+            table[i][j] = if a[i] == b[j]
+              table[i + 1][j + 1] + 1
+            else
+              [ table[i + 1][j], table[i][j + 1] ].max
+            end
+          end
+        end
+
+        segments = []
+        i = 0
+        j = 0
+        while i < a.length && j < b.length
+          if a[i] == b[j]
+            segments << [ :eq, a[i] ]
+            i += 1
+            j += 1
+          elsif table[i + 1][j] >= table[i][j + 1]
+            segments << [ :del, a[i] ]
+            i += 1
+          else
+            segments << [ :ins, b[j] ]
+            j += 1
+          end
+        end
+        segments.concat(a[i..].map { |token| [ :del, token ] })
+        segments.concat(b[j..].map { |token| [ :ins, token ] })
+        segments
+      end
+
+      def merge_segments(segments)
+        segments.each_with_object([]) do |(op, text), merged|
+          next if text.empty?
+
+          if merged.last && merged.last[0] == op
+            merged.last[1] += text
+          else
+            merged << [ op, text.dup ]
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/plum/form_renderer.rb

@@ -24,11 +24,22 @@ module Plum
 
     def hidden_inputs
       [
-        hidden_input(form["csrf_param"], form["csrf_token"]),
+        honeypot_input,
         hidden_input("return_to", form["return_to"])
       ].compact.join("\n  ")
     end
 
+    # Spam trap instead of a CSRF token: tokens are per-session, which would
+    # both break under static caching and force a session cookie onto every
+    # visitor. Bots fill this in; humans never see it.
+    def honeypot_input
+      <<~HTML.strip
+        <div style="position:absolute;left:-9999px;top:-9999px" aria-hidden="true">
+          <input type="text" name="form_submission[website]" tabindex="-1" autocomplete="off">
+        </div>
+      HTML
+    end
+
     def fields_html
       Array(form["fields"]).map { |field| field_html(field) }.join("\n  ")
     end

data/app/services/plum/liquid_context.rb

@@ -125,8 +125,6 @@ module Plum
           "handle" => form.handle,
           "fields" => form.form_fields,
           "action" => public_form_path(form),
-          "csrf_token" => form_authenticity_token,
-          "csrf_param" => "authenticity_token",
           "return_to" => controller.request.fullpath
         }
       end

data/app/views/layouts/plum/write.html.erb

@@ -0,0 +1,140 @@
+<!DOCTYPE html>
+<html lang="en" class="h-full">
+<head>
+  <title>Writing — <%= Plum.configuration.cp_name %></title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  <%= favicon_link_tag "plum-mark.svg", type: "image/svg+xml" %>
+  <%= stylesheet_link_tag "plum/control_panel", "data-turbo-track": "reload" %>
+  <%= stylesheet_link_tag "lexxy", "data-turbo-track": "reload" %>
+  <%= javascript_importmap_tags %>
+  <script type="module">import "plum/application"</script>
+  <style>
+    :root { --plum-accent: <%= Plum.configuration.cp_accent_color %>; }
+
+    body.plum-write {
+      background: #faf9f7;
+      color: #1f2937;
+    }
+
+    .plum-write-bar {
+      position: fixed;
+      inset: 0 0 auto 0;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 0.875rem 1.5rem;
+      background: linear-gradient(to bottom, rgba(250,249,247,0.97), rgba(250,249,247,0.85) 70%, rgba(250,249,247,0));
+      z-index: 10;
+      opacity: 0.35;
+      transition: opacity 0.25s ease;
+    }
+    .plum-write-bar:hover, .plum-write-bar:focus-within,
+    .plum-write-bar.plum-write-bar--active { opacity: 1; }
+
+    .plum-write-save-state {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.45rem;
+      padding: 0.3rem 0.75rem;
+      border-radius: 9999px;
+      font-size: 0.8125rem;
+      font-weight: 500;
+      color: #6b7280;
+      background: rgba(0,0,0,0.04);
+      transition: color 0.2s ease, background 0.2s ease;
+    }
+    .plum-write-save-state::before {
+      content: "";
+      width: 0.5rem;
+      height: 0.5rem;
+      border-radius: 9999px;
+      background: #9ca3af;
+      flex-shrink: 0;
+      transition: background 0.2s ease;
+    }
+    .plum-write-save-state[data-state="dirty"]::before { background: #f59e0b; }
+    .plum-write-save-state[data-state="saving"]::before {
+      background: #f59e0b;
+      animation: plum-write-pulse 1s ease-in-out infinite;
+    }
+    .plum-write-save-state[data-state="saved"] { color: #047857; background: #ecfdf5; }
+    .plum-write-save-state[data-state="saved"]::before { background: #10b981; }
+    .plum-write-save-state[data-state="error"] { color: #b91c1c; background: #fef2f2; }
+    .plum-write-save-state[data-state="error"]::before { background: #ef4444; }
+
+    @keyframes plum-write-pulse {
+      50% { opacity: 0.3; }
+    }
+
+    .plum-write-page {
+      max-width: 44rem;
+      margin: 0 auto;
+      padding: 6.5rem 1.5rem 40vh;
+    }
+
+    .plum-write-title {
+      width: 100%;
+      border: 0;
+      background: transparent;
+      resize: none;
+      overflow: hidden;
+      font-family: "Iowan Old Style", "Palatino Linotype", Palatino, Georgia, serif;
+      font-size: 2.75rem;
+      line-height: 1.15;
+      font-weight: 700;
+      color: #111827;
+      outline: none;
+      padding: 0;
+    }
+    .plum-write-title::placeholder { color: #d1d5db; }
+
+    .plum-write-body { margin-top: 2rem; }
+    .plum-write-body lexxy-editor {
+      display: block;
+      border: 0;
+      background: transparent;
+      box-shadow: none;
+    }
+    .plum-write-body .lexxy-content,
+    .plum-write-body lexxy-editor [contenteditable] {
+      font-family: "Iowan Old Style", "Palatino Linotype", Palatino, Georgia, serif;
+      font-size: 1.3125rem;
+      line-height: 1.8;
+      color: #1f2937;
+      min-height: 55vh;
+      border: 0 !important;
+      box-shadow: none !important;
+      background: transparent !important;
+      padding: 0;
+      outline: none;
+    }
+    .plum-write-body lexxy-toolbar {
+      position: sticky;
+      top: 0;
+      opacity: 0.25;
+      transition: opacity 0.25s ease;
+      background: transparent;
+      border: 0;
+    }
+    .plum-write-body:hover lexxy-toolbar,
+    .plum-write-body:focus-within lexxy-toolbar { opacity: 1; }
+
+    .plum-write-status {
+      position: fixed;
+      right: 1.5rem;
+      bottom: 1.25rem;
+      display: flex;
+      gap: 1rem;
+      font-size: 0.75rem;
+      letter-spacing: 0.02em;
+      color: #9ca3af;
+      z-index: 10;
+    }
+  </style>
+</head>
+<body class="plum-write h-full">
+  <%= yield %>
+</body>
+</html>

data/app/views/plum/cp/dashboard/show.html.erb

@@ -1,6 +1,13 @@
-<div class="mb-8">
-  <h1 class="text-2xl font-bold text-gray-900">Dashboard</h1>
-  <p class="mt-1 text-sm text-gray-500">Welcome back<%= ", #{current_user_label}" if current_user_label %></p>
+<div class="mb-8 flex items-start justify-between">
+  <div>
+    <h1 class="text-2xl font-bold text-gray-900">Dashboard</h1>
+    <p class="mt-1 text-sm text-gray-500">Welcome back<%= ", #{current_user_label}" if current_user_label %></p>
+  </div>
+  <% if Plum::StaticCache.enabled? %>
+    <%= button_to "Clear page cache", cp_static_cache_path, method: :delete,
+        data: { turbo_confirm: "Clear the cached pages for this site? They re-render on the next visit." },
+        class: "px-4 py-2 border border-gray-300 rounded-md shadow-sm text-sm font-medium text-gray-700 bg-white hover:bg-gray-50 cursor-pointer" %>
+  <% end %>
 </div>
 
 <div class="grid grid-cols-1 md:grid-cols-3 gap-6 mb-8">

data/app/views/plum/cp/entries/_form.html.erb

@@ -17,7 +17,7 @@
           <div class="space-y-6">
             <div>
               <%= f.label :title, class: "block text-sm font-medium text-gray-700" %>
-              <%= f.text_field :title, class: "mt-1 block w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-purple-500 focus:border-purple-500" %>
+              <%= f.text_field :title, value: entry.draft_title, class: "mt-1 block w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-purple-500 focus:border-purple-500" %>
             </div>
 
             <div>
@@ -35,7 +35,7 @@
           <% @content_type.fields.each do |field| %>
             <% field_handle = field["handle"].to_s %>
             <% field_id = "entry_data_#{field_handle.parameterize}" %>
-            <% field_value = entry.data&.dig(field_handle) %>
+            <% field_value = entry.draft_field_value(field_handle) %>
             <% field_value = field["default"] if entry.new_record? && field_value.nil? && field.key?("default") %>
             <% condition = field["condition"].presence %>
             <div class="<%= 'border-b border-gray-200 pb-2 pt-4' if field['type'] == 'section' %>" style="grid-column: span <%= field['type'] == 'section' ? 12 : (field['width'].presence || 12) %> / span <%= field['type'] == 'section' ? 12 : (field['width'].presence || 12) %>;"<% if condition %> data-field-condition="<%= condition.to_json %>"<% end %>>

data/app/views/plum/cp/entries/diff.html.erb

@@ -0,0 +1,40 @@
+<div class="mb-8 flex flex-wrap items-center justify-between gap-4">
+  <div>
+    <h1 class="text-2xl font-bold text-gray-900">Review draft changes</h1>
+    <p class="mt-1 text-sm text-gray-500">
+      <%= @entry.title %> &mdash;
+      <span class="inline-flex items-center gap-3">
+        <span><span class="inline-block h-2.5 w-2.5 rounded-sm bg-red-200 align-middle"></span> removed from live</span>
+        <span><span class="inline-block h-2.5 w-2.5 rounded-sm bg-green-200 align-middle"></span> added in draft</span>
+      </span>
+    </p>
+  </div>
+  <div class="flex items-center gap-3">
+    <%= link_to "Back to editor", edit_cp_content_type_entry_path(@content_type, @entry),
+        class: "inline-flex items-center px-4 py-2 border border-gray-300 rounded-md shadow-sm text-sm font-medium text-gray-700 bg-white hover:bg-gray-50" %>
+    <%= link_to "Continue writing", write_cp_content_type_entry_path(@content_type, @entry),
+        class: "inline-flex items-center px-4 py-2 border border-gray-300 rounded-md shadow-sm text-sm font-medium text-gray-700 bg-white hover:bg-gray-50" %>
+    <%= button_to "Discard draft", discard_draft_cp_content_type_entry_path(@content_type, @entry), method: :delete,
+        data: { turbo_confirm: "Discard the draft changes and go back to the published version?" },
+        class: "inline-flex items-center px-4 py-2 border border-red-300 rounded-md shadow-sm text-sm font-medium text-red-700 bg-white hover:bg-red-50 cursor-pointer" %>
+    <%= button_to "Publish changes", publish_draft_cp_content_type_entry_path(@content_type, @entry),
+        class: "inline-flex items-center px-4 py-2 border border-transparent rounded-md shadow-sm text-sm font-medium text-white bg-purple-600 hover:bg-purple-700 cursor-pointer" %>
+  </div>
+</div>
+
+<% if @diff.any? %>
+  <div class="space-y-6">
+    <% @diff.changes.each do |change| %>
+      <div class="bg-white shadow rounded-lg overflow-hidden">
+        <div class="px-6 py-3 border-b border-gray-200 bg-gray-50">
+          <h2 class="text-sm font-semibold text-gray-700"><%= change.label %></h2>
+        </div>
+        <div class="px-6 py-5 text-[0.9375rem] leading-7 text-gray-800" style="white-space: pre-wrap; overflow-wrap: anywhere;"><% change.segments.each do |op, text| %><% case op %><% when :eq %><%= text %><% when :del %><del class="rounded-sm bg-red-100 px-0.5 text-red-800 decoration-red-400"><%= text %></del><% when :ins %><ins class="rounded-sm bg-green-100 px-0.5 text-green-800 no-underline"><%= text %></ins><% end %><% end %></div>
+      </div>
+    <% end %>
+  </div>
+<% else %>
+  <div class="bg-white shadow rounded-lg p-10 text-center">
+    <p class="text-sm text-gray-500">The draft matches the live version &mdash; nothing to review.</p>
+  </div>
+<% end %>

data/app/views/plum/cp/entries/edit.html.erb

@@ -1,6 +1,13 @@
 <div class="flex items-center justify-between mb-8">
   <h1 class="text-2xl font-bold text-gray-900">Edit <%= @entry.title %></h1>
   <div class="flex items-center gap-3">
+    <% if @content_type.fields.any? { |field| field["type"] == "rich_text" && field["handle"].present? } %>
+      <%= link_to write_cp_content_type_entry_path(@content_type, @entry),
+          class: "inline-flex items-center gap-1.5 px-4 py-2 border border-gray-300 rounded-md shadow-sm text-sm font-medium text-gray-700 bg-white hover:bg-gray-50" do %>
+        <svg class="h-4 w-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M16.862 4.487l1.687-1.688a1.875 1.875 0 112.652 2.652L6.832 19.82a4.5 4.5 0 01-1.897 1.13l-2.685.8.8-2.685a4.5 4.5 0 011.13-1.897L16.862 4.487z"/></svg>
+        Write
+      <% end %>
+    <% end %>
     <%= link_to "History (#{@entry.revisions.count})", cp_content_type_entry_revisions_path(@content_type, @entry),
         class: "inline-flex items-center px-4 py-2 border border-gray-300 rounded-md shadow-sm text-sm font-medium text-gray-700 bg-white hover:bg-gray-50" %>
   <% if @entry.published? %>
@@ -10,6 +17,23 @@
   </div>
 </div>
 
+<% if @entry.has_draft? %>
+  <div class="mb-6 rounded-lg border border-amber-200 bg-amber-50 px-4 py-3 flex flex-wrap items-center justify-between gap-3">
+    <p class="text-sm text-amber-800">
+      You're seeing unpublished draft changes. The live site still shows the last published version &mdash; <strong>Save</strong> publishes what's below.
+    </p>
+    <div class="flex items-center gap-2">
+      <%= link_to "Review changes", diff_cp_content_type_entry_path(@content_type, @entry),
+          class: "px-3 py-1.5 rounded-md border border-amber-300 bg-white text-sm font-medium text-amber-800 hover:bg-amber-100" %>
+      <%= link_to "Continue writing", write_cp_content_type_entry_path(@content_type, @entry),
+          class: "px-3 py-1.5 rounded-md border border-amber-300 bg-white text-sm font-medium text-amber-800 hover:bg-amber-100" %>
+      <%= button_to "Discard draft", discard_draft_cp_content_type_entry_path(@content_type, @entry), method: :delete,
+          data: { turbo_confirm: "Discard the draft changes and go back to the published version?" },
+          class: "px-3 py-1.5 rounded-md border border-amber-300 bg-white text-sm font-medium text-amber-800 hover:bg-amber-100 cursor-pointer" %>
+    </div>
+  </div>
+<% end %>
+
 <%= render "form", entry: @entry %>
 
 <div class="mt-6 rounded-lg bg-white p-6 shadow">

data/app/views/plum/cp/entries/index.html.erb

@@ -29,6 +29,9 @@
               <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium <%= entry.published? ? 'bg-green-100 text-green-800' : 'bg-yellow-100 text-yellow-800' %>">
                 <%= entry.status %>
               </span>
+              <% if entry.has_draft? %>
+                <span class="ml-1 inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-amber-100 text-amber-800" title="Has unpublished draft changes">draft edits</span>
+              <% end %>
             </td>
             <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500"><%= entry.updated_at.strftime("%b %d, %Y") %></td>
             <td class="px-6 py-4 whitespace-nowrap text-right text-sm font-medium">

data/app/views/plum/cp/entries/write.html.erb

@@ -0,0 +1,60 @@
+<% field_handle = @field["handle"].to_s %>
+<% field_value = @entry.draft_field_value(field_handle) %>
+<% drafting = @entry.published? %>
+
+<div data-controller="plum--write"
+     data-plum--write-publish-url-value="<%= publish_draft_cp_content_type_entry_path(@content_type, @entry) %>">
+  <header class="plum-write-bar" data-plum--write-target="bar">
+    <%= link_to "&larr; Back to editor".html_safe, edit_cp_content_type_entry_path(@content_type, @entry),
+        class: "text-sm font-medium text-gray-500 hover:text-gray-900" %>
+    <div class="flex items-center gap-4">
+      <span class="plum-write-save-state" data-plum--write-target="status" data-state="idle">
+        <span data-plum--write-target="statusText"><%= @entry.has_draft? ? "Draft saved" : "Saved" %></span>
+      </span>
+      <% if drafting %>
+        <span class="text-xs text-gray-400">Published &mdash; edits save as a draft</span>
+        <%= link_to "Review changes", diff_cp_content_type_entry_path(@content_type, @entry),
+            class: "text-sm font-medium text-gray-500 hover:text-gray-900" %>
+        <button type="button" data-action="plum--write#save"
+                class="px-4 py-1.5 rounded-md text-sm font-medium text-gray-700 border border-gray-300 bg-white hover:bg-gray-50 cursor-pointer">
+          Save draft
+        </button>
+        <button type="button" data-action="plum--write#publishDraft"
+                class="px-4 py-1.5 rounded-md text-sm font-medium text-white plum-btn-primary cursor-pointer">
+          Publish changes
+        </button>
+      <% else %>
+        <span class="text-xs text-gray-400"><%= @entry.status.titleize %></span>
+        <button type="button" data-action="plum--write#save"
+                class="px-4 py-1.5 rounded-md text-sm font-medium text-white plum-btn-primary cursor-pointer">
+          Save
+        </button>
+      <% end %>
+    </div>
+  </header>
+
+  <main class="plum-write-page">
+    <%= form_with model: [:cp, @content_type, @entry], id: "write-form", data: { "plum--write-target": "form" } do |f| %>
+      <%= hidden_field_tag "entry[write_mode]", "1" %>
+      <%= f.text_area :title, rows: 1, placeholder: "Untitled", autocomplete: "off",
+          value: @entry.draft_title,
+          class: "plum-write-title",
+          data: { "plum--write-target": "title", action: "input->plum--write#titleChanged" } %>
+
+      <div class="plum-write-body">
+        <%= hidden_field_tag "entry[data][#{field_handle}]", field_value, id: "write_field_hidden" %>
+        <lexxy-editor value="<%= field_value %>"
+                      data-direct-upload-url="<%= main_app.rails_direct_uploads_url %>"
+                      data-blob-url-template="<%= main_app.rails_service_blob_url(":signed_id", ":filename") %>"
+                      data-hidden-field="write_field_hidden"
+                      data-plum--write-target="editor"
+                      class="lexxy-content"
+                      placeholder="Write something&hellip;"></lexxy-editor>
+      </div>
+    <% end %>
+  </main>
+
+  <div class="plum-write-status">
+    <span data-plum--write-target="words"></span>
+  </div>
+</div>

data/config/plum_routes.rb

@@ -9,6 +9,10 @@ Plum::Engine.routes.draw do
       post :apply_fieldset, on: :member
       resources :entries do
         patch :image_field, on: :member
+        get :write, on: :member
+        get :diff, on: :member
+        post :publish_draft, on: :member
+        delete :discard_draft, on: :member
         post :translate, on: :member
         resources :revisions, controller: "entry_revisions", only: [ :index ] do
           post :restore, on: :member
@@ -27,6 +31,7 @@ Plum::Engine.routes.draw do
     resource :site_settings, only: [ :show, :edit, :update ]
     patch "site_settings/image_field", to: "site_settings#image_field", as: :site_settings_image_field
     resources :themes, only: [ :index, :create, :update ]
+    delete "static_cache", to: "static_cache#destroy", as: :static_cache
     resources :taxonomies do
       resources :terms, except: [ :index, :show ]
     end

data/db/engine_migrate/20260811090000_add_draft_data_to_plum_entries.rb

@@ -0,0 +1,5 @@
+class AddDraftDataToPlumEntries < ActiveRecord::Migration[8.0]
+  def change
+    add_column :plum_entries, :draft_data, :json
+  end
+end

data/docs/config-as-code.md

@@ -0,0 +1,103 @@
+# Proposal: Config as Code
+
+Status: phase 1 implemented 2026-08-12 (`Plum::ConfigSync` + `plum:config:export|sync|check`
+rake tasks, content types + fieldsets, one-way). Phases 2-3 (two-way CP
+write-back, dev file watcher, taxonomies/forms) remain as proposed below.
+
+## Problem
+
+The content *model* (content type blueprints, taxonomies, form definitions)
+lives only in the database, created by clicking in the control panel. That
+means no git history, no code review, and no repeatable path from development
+to production — adding a field to a live site means re-clicking it in the
+production CP. This is the classic CMS pain (WordPress/ACF sync, Contentful
+migrations, Drupal config management all exist to solve it).
+
+## Principle
+
+Split the two kinds of data a CMS holds:
+
+- **Content** (entries, terms, nav items, assets, submissions): editor-owned,
+  changes constantly, stays in the database. Untouched by this proposal.
+- **Config** (content types + blueprints, taxonomies, forms, fieldsets):
+  developer-owned, changes rarely, belongs in version-controlled files.
+
+Files are the source of truth; the DB holds a synced copy so rendering and
+the CP keep working exactly as today.
+
+## File layout (host app repo)
+
+```
+plum/
+  content_types/posts.yml
+  content_types/pages.yml
+  taxonomies/topics.yml
+  forms/contact.yml
+```
+
+```yaml
+# plum/content_types/posts.yml
+name: Blog Posts
+handle: posts
+icon: document
+route_prefix: blog
+fields:
+  - handle: body
+    type: rich_text
+    label: Body
+  - handle: reading_time
+    type: number
+    unit: min
+```
+
+## Mechanics
+
+- `Plum::ConfigSync.apply(site:, dir:)` — files → DB. Upsert by handle,
+  transactional, flushes the static cache. Runs via `rails plum:sync` and
+  optionally on boot.
+- `Plum::ConfigSync.export(site:, dir:)` — DB → files. Bootstraps existing
+  sites onto the workflow; also called by the CP after visual blueprint edits
+  so the clicky builder and git never diverge (**two-way sync** — the
+  Statamic trick that makes both editors and developers happy).
+- Dev: `ActiveSupport::FileUpdateChecker` re-applies changed files on reload,
+  same feel as theme editing.
+- CI: `rails plum:sync --check` fails when the DB has drifted from the files
+  (hand-edits in prod that were never exported).
+
+## Safety rails
+
+- Removing a field from YAML never deletes entry data — entry data is a JSON
+  blob, so orphaned keys simply stop rendering (already true today).
+- Renaming a handle is treated as remove+add unless a `renamed_from:` hint is
+  given.
+- Deleting a content type that still has entries requires `--force`.
+
+## Multi-site / embedded mode
+
+Standalone mode: sync targets the single site; two-way write-back (phase 2)
+is appropriate because the developer owns both the repo and the CP.
+
+Embedded/SaaS mode (Table Needs) inverts the flow: the platform owns the
+content model, customer sites share it, and customers must not write YAML
+into the platform repo. So in host mode:
+
+- files are authoritative **one-way** (no CP write-back),
+- `plum:config:sync` needs an `ALL_SITES=1` mode that migrates every site's
+  model on deploy, like db:migrate for blueprints (not yet implemented),
+- the same files seed newly created sites.
+
+## Configuration
+
+```ruby
+Plum.configure do |config|
+  config.config_path = Rails.root.join("plum")   # nil disables the feature
+  config.config_sync = :two_way                   # :files_authoritative, :off
+end
+```
+
+## Phasing & estimate
+
+1. One-way `apply` + `export` + rake tasks, content types + fieldsets only
+   (~2–3 days).
+2. Two-way CP write-back + dev file watcher (~2 days).
+3. Taxonomies, forms, CI check, docs (~1 day).