hecks 3.10.0 → 3.11.0

data/lib/hecks/projections/site/cms_editor/destructive.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # Which commands the editor asks a person to confirm before it runs them, and what colour
+        # each lifecycle state's badge has.
+        #
+        # A command is destructive when its first word is one of `WORDS` (`WithdrawOffer`,
+        # `DiscardDraft`), or when it is a lifecycle move into a state named for one of `STATES`.
+        # The test reads the bluebook's own words and structure, never a list of aggregates, so a
+        # domain with a different vocabulary confirms nothing it did not name that way. A move that
+        # can be undone, such as an archive with a restore, is not destructive by that alone.
+        #
+        # A state's tone is structural: the starting state is `neutral`, a state named for a
+        # destructive word is `danger`, and the others alternate `ok` and `info` in the order the
+        # moves reach them. The badge always carries the state's name; tone is never the only cue.
+        module Destructive
+          # The first words of a command that undoes or ends something.
+          WORDS = %w[withdraw retire discard delete cancel remove].freeze
+
+          # The states those commands move into.
+          STATES = %w[withdrawn retired discarded deleted cancelled canceled removed].freeze
+
+          module_function
+
+          # @param name [String] the command's name, such as `"DiscardDraft"`
+          # @param lifecycle [Hash{String => Object}, nil] the lifecycle as `Schema` reads it
+          # @return [Boolean] whether the editor confirms the command first
+          def command?(name, lifecycle)
+            return true if WORDS.include?(words(name).first)
+
+            move = lifecycle && lifecycle["transitions"].find { |transition| transition["verb"] == name }
+            !move.nil? && STATES.include?(move["to"].downcase)
+          end
+
+          # @param lifecycle [Hash{String => Object}, nil] the lifecycle as `Schema` reads it
+          # @return [Hash{String => String}] each state's tone, empty without a lifecycle
+          def tones(lifecycle)
+            return {} unless lifecycle
+
+            states = [lifecycle["default"], *lifecycle["transitions"].flat_map { |move| [*move["from"], move["to"]] }].uniq
+            cycle = %w[ok info].cycle
+            states.to_h { |state| [state, tone(state, lifecycle["default"], cycle)] }
+          end
+
+          # @return [String] the tone of one state; `cycle` hands out `ok` and `info` in turn
+          def tone(state, default, cycle)
+            return "neutral" if state == default
+
+            STATES.include?(state.downcase) ? "danger" : cycle.next
+          end
+
+          # @return [Array<String>] the lower-case words of a CamelCase or snake_case name
+          def words(name) = name.to_s.scan(/[A-Z][a-z0-9]*|[a-z0-9]+/).map(&:downcase)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/drafts.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "clearing"
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # An aggregate that keeps a draft of its content beside the live one: the editor writes the
+        # draft as the person types and publishes it only when asked.
+        #
+        # A command on the aggregate whose every argument is `draft_<x>` (the aggregate holds
+        # both `draft_<x>` and `<x>`, of one type, and some `<x>` is a rich-text body, a block list
+        # or a value object, alone or in a list) saves the draft. A command with a
+        # `sets <x>, to: state(:draft_<x>)` mutation publishes it; one that only empties
+        # `draft_<x>` (see `Clearing`) discards it. A missing publishing or discarding command is
+        # left out.
+        module Drafts
+          # What a draft attribute's name starts with.
+          PREFIX = "draft_"
+
+          module_function
+
+          # @param agg [Bluebook::Aggregate] the aggregate
+          # @param attributes [Array<Hash{String => Object}>] its attributes as `Schema` shapes
+          #   them
+          # @return [Hash{String => String}, nil] `attribute` (the draft), `live`, `save`, and
+          #   `publish` and `discard` when the aggregate has them; nil when it keeps no drafts
+          def of(agg, attributes)
+            found = agg.commands.lazy.filter_map { |command| saving(command, agg, attributes) }.first
+            return nil unless found
+
+            found.merge("publish" => publishing(agg, found), "discard" => discarding(agg, found)).compact
+          end
+
+          # @return [Hash{String => String}, nil] the draft and live attributes `command` saves
+          def saving(command, agg, attributes)
+            return nil unless acts_on?(command, agg) && !command.attributes.empty?
+
+            lives = command.attributes.map { |argument| live_of(argument, agg) }
+            live = lives.all? ? lives.find { |name| draftable?(name, attributes) } : nil
+            live && { "attribute" => "#{PREFIX}#{live}", "live" => live, "save" => command.hecks_name }
+          end
+
+          # @return [Boolean] whether the command acts on an existing instance of the aggregate
+          def acts_on?(command, agg) = !command.creates? && command.references.to_s == agg.hecks_name
+
+          # @return [String, nil] the live attribute `argument` is the draft of, when it is one
+          def live_of(argument, agg)
+            name = argument.name.to_s
+            live = name.delete_prefix(PREFIX)
+            return nil unless name.start_with?(PREFIX) && same_type?(agg, name, live) && agg.attributes.any? do |held|
+              held.name.to_s == name
+            end
+
+            live
+          end
+
+          # @return [Boolean] whether the aggregate holds both attributes, of one type
+          def same_type?(agg, draft, live)
+            types = [draft, live].map { |name| agg.attributes.find { |held| held.name.to_s == name }&.type.to_s }
+            types.none?(&:empty?) && types.uniq.size == 1
+          end
+
+          # @return [Boolean] whether the named attribute is a rich-text body, a block list or a
+          #   value object (a page's fixed slots), alone or in a list
+          def draftable?(name, attributes)
+            attributes.any? do |attr|
+              attr["name"] == name && (attr["widget"] == "body" || attr.key?("blockList") || attr["kind"] == "object")
+            end
+          end
+
+          # @return [String, nil] the command that moves the draft into the live attribute
+          def publishing(agg, found)
+            agg.commands.find { |command| acts_on?(command, agg) && promotes?(command, found) }&.hecks_name
+          end
+
+          # @return [String, nil] the command that empties the draft and changes nothing live
+          def discarding(agg, found)
+            agg.commands.find { |command| acts_on?(command, agg) && empties?(command, agg, found) }&.hecks_name
+          end
+
+          def promotes?(command, found)
+            command.mutations.any? do |mutation|
+              mutation.target.to_s == found["live"] && mutation.source.is_a?(Hecks::StateRef) &&
+                mutation.source.name.to_s == found["attribute"]
+            end
+          end
+
+          def empties?(command, agg, found)
+            return false if command.hecks_name == found["save"] || targets_of(command) != [found["attribute"]]
+
+            clears = Clearing.of(command, agg).map { |argument| argument.name.to_s }
+            command.mutations.all? { |mutation| clears.include?(mutation.source.to_s) }
+          end
+
+          def targets_of(command) = command.mutations.map { |mutation| mutation.target.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/hints.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "key_kinds"
+require_relative "moment"
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # What one attribute's names, pattern and closed set say about how a value of it is
+        # entered: a moment (see `Moment`), a `<kind>:<slug>` key (see `KeyKinds`) or one of a
+        # closed set's members. A value object with a single plain part is entered as that part,
+        # so the part's pattern and the value object's names count; a value object of several
+        # parts has parts of its own, each read the same way.
+        class Hints
+          # @param objects [Hash{String => Bluebook::ValueObject}] the value objects by name
+          def initialize(objects)
+            @objects = objects
+          end
+
+          # @param attribute [Bluebook::Attribute] a declared attribute
+          # @return [Hash{String => Object}] `widget`, `keys` and `options` when the attribute has
+          #   them
+          def of(attribute)
+            leaf, names = leaf(attribute)
+            return {} unless leaf
+
+            { **moment(leaf, names), **keys(leaf), **options(attribute, leaf) }
+          end
+
+          private
+
+          # @return [Array(Bluebook::Attribute, Array<String>), nil] the attribute that holds the
+          #   value and the names it goes by, or nil for a reference or a value object of parts
+          def leaf(attribute)
+            return nil if attribute.type.is_a?(Bluebook::Reference)
+
+            object = @objects[attribute.type.to_s]
+            return [attribute, [attribute.name.to_s]] unless object
+
+            part = plain_part(object)
+            part && [part, [attribute.name.to_s, attribute.type.to_s, part.name.to_s]]
+          end
+
+          # @return [Bluebook::Attribute, nil] the one part of a value object that is a plain value
+          def plain_part(object)
+            part = object.attributes.first
+            part if object.attributes.size == 1 && !part.list? && !@objects.key?(part.type.to_s)
+          end
+
+          def moment(leaf, names)
+            widget = Moment.widget(names) if leaf.type.to_s == "Integer"
+            widget ? { "widget" => widget } : {}
+          end
+
+          # A value object declared a closed set (`one_of`) is entered by choosing one of its
+          # members.
+          def options(attribute, leaf)
+            object = @objects[attribute.type.to_s]
+            return {} unless object&.closed_set?
+
+            members = object.members.filter_map { |member| member[leaf.name] }.uniq
+            members.empty? ? {} : { "options" => members.map(&:to_s) }
+          end
+
+          def keys(leaf)
+            kinds = KeyKinds.of(leaf.pattern)
+            kinds.empty? ? {} : { "keys" => kinds }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/icons.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # The editor's icons, drawn once here and emitted as one vector sprite
+        # (`src/ui/icons.ts`). Pages and the browser code refer to an icon by name with
+        # `<svg><use href="#i-name"/></svg>`, so there is no icon font, no request and no external
+        # file. Each is a 24 by 24 outline drawn with the current text colour.
+        module Icons
+          # Each icon's name and the drawing elements inside its symbol.
+          DRAWINGS = {
+            "menu"          => '<path d="M4 7h16M4 12h16M4 17h16"/>',
+            "close"         => '<path d="M6 6l12 12M18 6L6 18"/>',
+            "sun"           => '<circle cx="12" cy="12" r="4"/>' \
+                               '<path d="M12 3v2M12 19v2M3 12h2M19 12h2M5.6 5.6L7 7M17 17l1.4 1.4M5.6 18.4L7 17M17 7l1.4-1.4"/>',
+            "moon"          => '<path d="M20 14.5A8 8 0 019.5 4 8 8 0 1020 14.5z"/>',
+            "sign-out"      => '<path d="M10 4H5v16h5M15 8l4 4-4 4M19 12H9"/>',
+            "search"        => '<circle cx="11" cy="11" r="6"/><path d="M16 16l4 4"/>',
+            "plus"          => '<path d="M12 5v14M5 12h14"/>',
+            "copy"          => '<rect x="9" y="9" width="11" height="11" rx="2"/><path d="M5 15V6a2 2 0 012-2h8"/>',
+            "check"         => '<path d="M5 12.5l4.5 4.5L19 7.5"/>',
+            "chevron-up"    => '<path d="M6 14l6-6 6 6"/>',
+            "chevron-down"  => '<path d="M6 10l6 6 6-6"/>',
+            "chevron-right" => '<path d="M10 6l6 6-6 6"/>',
+            "arrow-up"      => '<path d="M12 19V5M6 11l6-6 6 6"/>',
+            "arrow-down"    => '<path d="M12 5v14M6 13l6 6 6-6"/>',
+            "sort"          => '<path d="M8 9l4-4 4 4M8 15l4 4 4-4"/>',
+            "trash"         => '<path d="M5 7h14M10 7V4h4v3M7 7l1 13h8l1-13M10 11v6M14 11v6"/>',
+            "pencil"        => '<path d="M5 19l1-4L16 5l3 3L9 18l-4 1zM14 7l3 3"/>',
+            "bold"          => '<path d="M7 5h6a3.5 3.5 0 010 7H7zM7 12h7a3.5 3.5 0 010 7H7z"/>',
+            "italic"        => '<path d="M10 5h8M6 19h8M14 5l-4 14"/>',
+            "underline"     => '<path d="M7 5v7a5 5 0 0010 0V5M5 20h14"/>',
+            "strike"        => '<path d="M4 12h16M16 7a4 3 0 00-4-2c-2.5 0-4 1.2-4 3s1.5 2.5 4 4 4 2 4 4-1.7 3-4.2 3' \
+                               'a5 4 0 01-4.3-2"/>',
+            "code"          => '<path d="M9 7l-5 5 5 5M15 7l5 5-5 5"/>',
+            "link"          => '<path d="M10 14a4 4 0 005.7 0l3-3a4 4 0 00-5.7-5.7l-1 1' \
+                               'M14 10a4 4 0 00-5.7 0l-3 3A4 4 0 0011 18.7l1-1"/>',
+            "unlink"        => '<path d="M10 14a4 4 0 005.7 0l3-3a4 4 0 00-5.7-5.7l-1 1' \
+                               'M14 10a4 4 0 00-5.7 0l-3 3A4 4 0 0011 18.7l1-1M4 4l16 16"/>',
+            "list-bullets"  => '<path d="M9 6h11M9 12h11M9 18h11"/><circle cx="4.5" cy="6" r="1"/>' \
+                               '<circle cx="4.5" cy="12" r="1"/><circle cx="4.5" cy="18" r="1"/>',
+            "list-numbers"  => '<path d="M10 6h10M10 12h10M10 18h10M4 5l1.5-1v4M4 11.5h3l-3 3h3M4 17.5h3v1.5H5M7 19v1.5H4"/>',
+            "indent"        => '<path d="M4 5h16M12 10h8M12 15h8M4 20h16M4 9l3 3-3 3"/>',
+            "outdent"       => '<path d="M4 5h16M12 10h8M12 15h8M4 20h16M7 9l-3 3 3 3"/>',
+            "align-left"    => '<path d="M4 6h16M4 10h10M4 14h16M4 18h10"/>',
+            "align-center"  => '<path d="M4 6h16M7 10h10M4 14h16M7 18h10"/>',
+            "align-right"   => '<path d="M4 6h16M10 10h10M4 14h16M10 18h10"/>',
+            "align-justify" => '<path d="M4 6h16M4 10h16M4 14h16M4 18h16"/>',
+            "image"         => '<rect x="4" y="5" width="16" height="14" rx="2"/><circle cx="9" cy="10" r="1.5"/>' \
+                               '<path d="M5 17l5-5 4 4 2-2 3 3"/>',
+            "divider"       => '<path d="M4 12h16M8 7h8M8 17h8" stroke-dasharray="0"/>',
+            "quote"         => '<path d="M5 17v-4a4 4 0 014-4M13 17v-4a4 4 0 014-4M5 17h4v-4H5M13 17h4v-4h-4"/>',
+            "line-break"    => '<path d="M5 6v6a3 3 0 003 3h10M14 11l4 4-4 4"/>',
+            "undo"          => '<path d="M9 7L4 12l5 5M4 12h10a5 5 0 010 10"/>',
+            "redo"          => '<path d="M15 7l5 5-5 5M20 12H10a5 5 0 000 10"/>',
+            "upload"        => '<path d="M12 16V5M7 10l5-5 5 5M5 19h14"/>',
+            "alert"         => '<path d="M12 4l9 16H3zM12 10v4M12 17v.5"/>',
+            "info"          => '<circle cx="12" cy="12" r="9"/><path d="M12 11v5M12 8v.5"/>',
+            "success"       => '<circle cx="12" cy="12" r="9"/><path d="M8 12.5l3 3 5-6"/>',
+            "clock"         => '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/>',
+            "dot"           => '<circle cx="12" cy="12" r="4"/>',
+            "inbox"         => '<path d="M4 13l2-8h12l2 8M4 13v6h16v-6M4 13h5l1 2h4l1-2h5"/>',
+            "eye"           => '<path d="M2.5 12S6 5.5 12 5.5 21.5 12 21.5 12 18 18.5 12 18.5 2.5 12 2.5 12z"/>' \
+                               '<circle cx="12" cy="12" r="3"/>',
+            "refresh"       => '<path d="M19 6v5h-5M5 18v-5h5M18.2 10A7 7 0 006 7.5M5.8 14A7 7 0 0018 16.5"/>',
+            "external"      => '<path d="M14 4h6v6M20 4l-9 9M18 14v5H5V6h5"/>',
+            "phone"         => '<rect x="7" y="3" width="10" height="18" rx="2"/><path d="M11 18h2"/>',
+            "tablet"        => '<rect x="5" y="3" width="14" height="18" rx="2"/><path d="M11 18h2"/>',
+            "desktop"       => '<rect x="3" y="4" width="18" height="12" rx="2"/><path d="M9 20h6M12 16v4"/>',
+            "calendar"      => '<rect x="4" y="5" width="16" height="15" rx="2"/><path d="M4 10h16M9 3v4M15 3v4"/>',
+            "arrow-left"    => '<path d="M19 12H5M11 6l-6 6 6 6"/>'
+          }.freeze
+
+          module_function
+
+          # @return [String] the symbols as one hidden sprite's body, each with an id `i-<name>`
+          def sprite
+            DRAWINGS.map { |name, drawing| %(<symbol id="i-#{name}" viewBox="0 0 24 24">#{drawing}</symbol>) }.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/key_kinds.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # The `<kind>:<slug>` key convention, read from an attribute's own `pattern:`.
+        #
+        # A key such as `post:hello` says what it names in its first part. The bluebook states the
+        # convention only when the attribute's pattern does: it must start `^kind:` or
+        # `^(kind|kind):`, with lower-case words of letters, digits and underscores. Anything
+        # else is not a convention the editor assumes.
+        module KeyKinds
+          # `^` then one word, or a group of words separated by `|`, then the `:`.
+          LEAD = /\A\^(?:\((?:\?:)?(?<kinds>\w+(?:\|\w+)*)\)|(?<kinds>\w+)):/
+
+          module_function
+
+          # @param pattern [String, nil] the attribute's declared pattern
+          # @return [Array<String>] the kinds the pattern allows before the colon; empty when none
+          def of(pattern)
+            found = LEAD.match(pattern.to_s)
+            return [] unless found
+
+            found[:kinds].split("|").grep(/\A[a-z][a-z0-9_]*\z/).uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/limits.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # What a holder's rules say about how much an attribute may hold: a list's least and most
+        # rows (`chapters.size >= 1`, `parts.size <= 12`) and a text's most characters
+        # (`summary.to_s.size <= 600`). The rules are the domain's own, so the editor shows the
+        # limit it will be held to, and a text that may be long is entered in a writing box.
+        #
+        # The holder is a value object (its invariants), an aggregate (its invariants) or a command
+        # (its `given`s). A rule is read only when it is the whole of the invariant, or the whole
+        # of it after an `x.unset? ||` guard on the same part.
+        module Limits
+          # A list's size compared with a number.
+          LIST = /\A(\w+)\.size (<=|>=) (\d+)\z/
+
+          # A text's length bounded above (`to_s.size`, `size` or `length`), maybe after a guard.
+          TEXT = /\A(?:(\w+)\.unset\? \|\| )?(\w+)\.(?:to_s\.)?(?:size|length) <= (\d+)\z/
+
+          # A text that may be longer than this many characters is entered in a writing box.
+          MULTILINE_FROM = 200
+
+          module_function
+
+          # @param attributes [Array<Hash{String => Object}>] the holder's attributes as `Schema`
+          #   shapes them
+          # @param rules [Array<#canonical>] the holder's invariants or `given`s
+          # @return [Array<Hash{String => Object}>] the attributes, each with `min` and `max` when
+          #   it is a list a rule bounds, and `maxLength` (with `multiline` above `MULTILINE_FROM`)
+          #   when it is a text a rule bounds
+          def apply(attributes, rules)
+            texts = rules.map { |rule| rule.canonical.to_s }
+            lists = sizes(texts)
+            bound = lengths(texts)
+            attributes.map { |attr| attr.merge(listed(attr, lists), texted(attr, bound)) }
+          end
+
+          # @return [Hash{String => Hash{String => Integer}}] each list's `min` and `max`; where a
+          #   holder says several, the tightest wins
+          def sizes(texts)
+            texts.filter_map { |text| LIST.match(text) }.each_with_object({}) do |found, bounds|
+              held = (bounds[found[1]] ||= {})
+              kind = found[2] == "<=" ? "max" : "min"
+              held[kind] = [held[kind], found[3].to_i].compact.public_send(kind == "max" ? :min : :max)
+            end
+          end
+
+          # @return [Hash{String => Integer}] each text's most characters
+          def lengths(texts)
+            texts.filter_map { |text| TEXT.match(text) }
+                 .select { |found| found[1].nil? || found[1] == found[2] }
+                 .to_h { |found| [found[2], found[3].to_i] }
+          end
+
+          def listed(attr, lists)
+            found = attr["list"] ? lists[attr["name"]] : nil
+            found ? found.reject { |kind, size| kind == "min" && size < 1 } : {}
+          end
+
+          def texted(attr, bound)
+            most = attr["type"] == "String" && !attr["list"] ? bound[attr["name"]] : nil
+            return {} unless most
+
+            { "maxLength" => most, **(most > MULTILINE_FROM ? { "multiline" => true } : {}) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/media.rb

@@ -75,7 +75,7 @@ module Hecks
           # @return [Hash{String => Object}] the picture aggregate as the editor's schema names it
           def describe(agg, command, found)
             listing = agg["queries"].find { |query| query["attributes"].empty? }
-            { "aggregate" => agg["name"], "command" => command["name"], "fields" => found,
+            { "aggregate" => agg["name"], **agg.slice("chapter"), "command" => command["name"], "fields" => found,
               "listing" => listing && listing["name"] }
           end
         end

data/lib/hecks/projections/site/cms_editor/moment.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # Which integer attributes are moments in time, read from the names the bluebook gave them.
+        #
+        # An integer is a moment when one of the names it goes by (the attribute's, its value
+        # object's, the value object's part's) ends in `_at` or `At` (a date and a time), ends in
+        # `_on` or `On` (a date), or has `epoch` in it (seconds since 1970, so a date and a time).
+        # The value is always whole seconds since 1970 UTC; the editor shows it in the viewer's own
+        # time zone. A name is the only evidence the bluebook gives, so the rule is this narrow:
+        # an integer named `duration` or `Season` is never a date.
+        module Moment
+          # Names that end in `at` or `on` as a word, so `created_at` and `CreatedAt` match and
+          # `format`, `Season` and `Combat` do not.
+          AT = /(?:_at|[a-z0-9]At)\z/
+          ON = /(?:_on|[a-z0-9]On)\z/
+
+          module_function
+
+          # @param names [Array<String>] the names the integer goes by
+          # @return [String, nil] `"datetime"`, `"date"`, or nil when the integer is not a moment
+          def widget(names)
+            return "datetime" if names.any? { |name| AT.match?(name) || name.match?(/epoch/i) }
+
+            "date" if names.any? { |name| ON.match?(name) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/palette.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "color"
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # The editor's colours, light and dark, derived from one accent colour, as the custom
+        # properties of a daisyUI theme (`--color-base-100`, `--color-primary`, ...) and the few
+        # extras the pages use (`--ed-muted`, `--ed-edge`). Every text and fill pair is moved
+        # until it reaches the accessibility standard's level for it (4.5:1 for text, 3:1 for the
+        # edge of a control), so a brand colour that would fail cannot make the editor unreadable.
+        #
+        # The neutrals (ground, page, ink, muted ink, rule) are fixed when the row names no
+        # accent, and take the accent's hue at low saturation when it does, so an accent retints
+        # the whole theme. Primary buttons are filled with ink (daisyUI's `neutral`); the accent
+        # (`primary`) marks selection, focus, links, the active navigation item and the saved or
+        # published state.
+        class Palette
+          # The accent a row that names none gets: a deep verdigris.
+          DEFAULT_ACCENT = "#1f7a6d"
+
+          # The neutrals a row that names no accent gets, per theme.
+          FIXED = {
+            light: { ground: "#f4f6f8", surface: "#ffffff", ink: "#1a222c", muted: "#5a6675", rule: "#dce1e7" },
+            dark:  { ground: "#11161b", surface: "#181f26", ink: "#e7ebef", muted: "#9aa6b3", rule: "#28313b" }
+          }.freeze
+
+          # Hues of the status colours, in degrees.
+          TONES = { ok: 150.0, warn: 38.0, danger: 4.0 }.freeze
+
+          # The daisyUI variable each status tone fills.
+          STATUS = { ok: "success", warn: "warning", danger: "error" }.freeze
+
+          # @param accent [String, nil] a six-digit hex colour, or nil for the default
+          def initialize(accent = nil)
+            @custom = !accent.to_s.empty?
+            @accent = (accent.to_s.empty? ? DEFAULT_ACCENT : accent).downcase
+          end
+
+          # @return [Hash{Symbol => Hash{String => String}}] each theme's properties, name to value
+          def themes = { light: properties(:light), dark: properties(:dark) }
+
+          private
+
+          def properties(theme)
+            base = neutrals(theme)
+            found = base.merge(accents(theme, base)).merge(tones(theme, base))
+            { **daisy(found), **extras(found) }
+          end
+
+          def lighter(theme) = theme == :light ? :darker : :lighter
+
+          def neutrals(theme)
+            fixed = @custom ? tinted(FIXED.fetch(theme)) : FIXED.fetch(theme)
+            backs = [fixed[:surface], fixed[:ground]]
+            edge = Color.reach(Color.mix(fixed[:rule], fixed[:muted], 0.5), backs, 3.0, lighter(theme))
+            { **fixed, muted: Color.reach(fixed[:muted], backs, 4.5, lighter(theme)), edge: edge }
+          end
+
+          # The fixed neutrals with the accent's hue at the saturation each already has.
+          def tinted(fixed)
+            hue = Color.hsl(@accent).first
+            fixed.transform_values do |hex|
+              _, sat, light = Color.hsl(hex)
+              hex == "#ffffff" ? hex : Color.from_hsl(hue, sat, light)
+            end
+          end
+
+          def accents(theme, base)
+            backs = [base[:surface], base[:ground]]
+            fill = theme == :light ? @accent : Color.reach(@accent, backs, 4.5, :lighter)
+            soft = Color.mix(base[:surface], fill, theme == :light ? 0.1 : 0.18)
+            { primary: Color.reach(fill, [*backs, soft], 4.5, lighter(theme)), accent_soft: soft }
+          end
+
+          def tones(theme, base)
+            TONES.each_with_object({}) do |(name, hue), found|
+              back = theme == :light ? Color.from_hsl(hue, 0.5, 0.94) : Color.from_hsl(hue, 0.28, 0.18)
+              start = Color.from_hsl(hue, 0.55, theme == :light ? 0.3 : 0.72)
+              found[:"#{name}_bg"] = back
+              found[:"#{name}_fg"] = Color.reach(start, [back, base[:surface]], 4.5, lighter(theme))
+            end
+          end
+
+          # The first of white, a near-black and black that reads on `fill`.
+          def on(fill) = ["#ffffff", "#0f151a", "#000000"].find { |hex| Color.contrast(hex, fill) >= 4.5 }
+
+          def daisy(found)
+            colours = surfaces(found).merge(fills(found))
+            named = colours.slice("primary", "secondary", "accent", "info", *STATUS.values)
+            contents = named.to_h { |name, value| ["#{name}-content", on(value)] }
+            colours.merge(contents).transform_keys { |name| "--color-#{name}" }
+          end
+
+          def surfaces(found)
+            { "base-100" => found[:surface], "base-200" => found[:ground], "base-300" => found[:rule],
+              "base-content" => found[:ink], "neutral" => found[:ink], "neutral-content" => found[:surface] }
+          end
+
+          def fills(found)
+            { "primary" => found[:primary], "secondary" => found[:muted], "accent" => found[:primary], "info" => found[:primary],
+              **STATUS.to_h { |tone, name| [name, found[:"#{tone}_fg"]] } }
+          end
+
+          def extras(found)
+            { "--ed-muted" => found[:muted], "--ed-edge" => found[:edge], "--ed-soft" => found[:accent_soft],
+              "--ed-ok-bg" => found[:ok_bg], "--ed-warn-bg" => found[:warn_bg], "--ed-danger-bg" => found[:danger_bg] }
+          end
+        end
+      end
+    end
+  end
+end