hecks 5.0.0 → 7.0.0

data/lib/hecks/projections/site/admin_cms.rb

@@ -30,7 +30,7 @@ module Hecks
 
         # Renders the four files for a project that declares an admin row.
         #
-        # @param bluebook [Bluebook::Chapter] the chapter that declares the route table
+        # @param bluebook [Bluebook::Declaration] the bluebook that declares the route table
         # @param options [Hash{Symbol => Object}] `:admin` (Admin) the checked admin row, or nil
         # @return [Hash{String => String}] each file's relative path to its text; empty with no row
         def call(bluebook:, options: {})

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

@@ -29,6 +29,9 @@ module Hecks
           # An invariant that holds unless the kind is the named one: what the rest of it reads.
           GUARD = /\A(\w+)(?:\.value)? != "([^"]+)" \|\| (.*)\z/m
 
+          # A double-quoted string, capturing the text between the quotes.
+          QUOTED = /"([^"]+)"/
+
           # A limit written as a size comparison.
           LIMIT = /\A(\w+)\.size <= (\d+)\z/
 
@@ -72,7 +75,7 @@ module Hecks
           # @return [Array(String, Array<String>), nil] a text part restricted by a literal list
           def literal(item)
             found = literals(item).find { |match| item.attributes.any? { |part| part.name.to_s == match[2] && !part.list? } }
-            found && [found[2], found[1].scan(/"([^"]+)"/).flatten]
+            found && [found[2], found[1].scan(QUOTED).flatten]
           end
 
           # @return [Array<MatchData>] the invariants that restrict a part to a literal list
@@ -99,7 +102,7 @@ module Hecks
               object.members.all? { |row| kinds.include?(row[:kind].to_s) }
           end
 
-          def words(text) = text.to_s.split(",").map(&:strip).reject(&:empty?)
+          def words(text) = Hecks::Text.comma_list(text)
 
           # @return [Hash{String => Array<String>}] the slots each kind's guarded invariants read
           def mentions(item, name, kinds)

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

@@ -15,6 +15,9 @@ module Hecks
           # A base path: one or more segments, starting with a slash and not ending with one.
           BASE_PATH = %r{\A(/[^/\s]+)+\z}
 
+          # A whole number from 1, of at most ten digits: an upload size cap in bytes.
+          BYTE_COUNT = /\A[1-9]\d{0,9}\z/
+
           # The largest upload size cap a row may name: 100 MiB.
           MAX_UPLOAD = 104_857_600
 
@@ -27,7 +30,7 @@ module Hecks
           def problems(row, roles, table)
             base = row[:base_path]
             [*path_problems(row, base), *("Editor roles name no role" if roles.empty?), *login_problems(row[:login], table),
-             *media_problems(row), *media_chapter_problems(row), *ThemeChecks.problems(row), *ScaleChecks.problems(row),
+             *media_problems(row), *media_bluebook_problems(row), *ThemeChecks.problems(row), *ScaleChecks.problems(row),
              *Preview.problems(row[:preview].strip)]
           end
 
@@ -44,18 +47,18 @@ module Hecks
             found = []
             found << "media_dir must not be empty" if row[:media_dir].strip.empty?
             cap = row[:media_max_bytes]
-            unless cap.match?(/\A[1-9]\d{0,9}\z/) && cap.to_i <= MAX_UPLOAD
+            unless cap.match?(BYTE_COUNT) && cap.to_i <= MAX_UPLOAD
               found << "media_max_bytes #{cap.inspect} must be a whole number of bytes from 1 to #{MAX_UPLOAD}"
             end
             found
           end
 
-          # @return [Array<String>] the problem with a `media` chapter that is one the editor edits
-          def media_chapter_problems(row)
+          # @return [Array<String>] the problem with a `media` bluebook that is one the editor edits
+          def media_bluebook_problems(row)
             named = row[:media].strip
-            return [] unless row[:chapter].split(",").map(&:strip).include?(named)
+            return [] unless row[:bluebook].split(",").map(&:strip).include?(named)
 
-            ["media #{named.inspect} is this editor's own chapter; name another chapter"]
+            ["media #{named.inspect} is this editor's own bluebook; name another bluebook"]
           end
 
           # The login page is a public row: a visitor with no session must reach it.

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

@@ -12,6 +12,9 @@ module Hecks
           # A six-digit hex colour with its leading hash.
           HEX = /\A#[0-9a-fA-F]{6}\z/
 
+          # Two characters: one channel's hex digits.
+          HEX_PAIR = /../
+
           # The step by which `reach` moves a colour's lightness while it searches.
           STEP = 0.01
 
@@ -19,7 +22,7 @@ module Hecks
 
           # @param value [String] a colour such as `"#1f7a6d"`
           # @return [Array<Float>] its red, green and blue, each from 0.0 to 1.0
-          def rgb(value) = value.delete_prefix("#").scan(/../).map { |pair| pair.hex / 255.0 }
+          def rgb(value) = value.delete_prefix("#").scan(HEX_PAIR).map { |pair| pair.hex / 255.0 }
 
           # @param channels [Array<Float>] red, green and blue, each from 0.0 to 1.0
           # @return [String] the colour as lower-case hex

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

@@ -4,35 +4,37 @@ module Hecks
   module Projections
     module Site
       module CmsEditor
-        # Several chapters as one editor: each aggregate keeps the name its chapter gave it and is
-        # stamped with the chapter that declares it, so two aggregates of one name in different
-        # chapters are two aggregates. The stamps exist only when the editor spans more than one
-        # chapter (`chapter`), or when a chapter's roles are limited (`roles`), so an editor of one
-        # open chapter reads exactly as a chapter alone does.
+        # Several bluebooks as one editor: each aggregate keeps the name its bluebook gave it and is
+        # stamped with the bluebook that declares it, so two aggregates of one name in different
+        # bluebooks are two aggregates. The stamps exist only when the editor spans more than one
+        # bluebook (`bluebook`), or when a bluebook's roles are limited (`roles`), so an editor of
+        # one
+        # open bluebook reads exactly as a bluebook alone does.
         module Composition
           module_function
 
-          # @param chapters [Array<Bluebook::Chapter>] the chapters, in the order the row names them
-          # @param skip [Array<String>] `Name` (in every chapter) or `Chapter::Name` to leave out
-          # @param roles [Hash{String => Array<String>}] the roles each chapter is limited to
+          # @param bluebooks [Array<Bluebook::Declaration>] the bluebooks, in the order the row
+          #   names them
+          # @param skip [Array<String>] `Name` (in every bluebook) or `Bluebook::Name` to leave out
+          # @param roles [Hash{String => Array<String>}] the roles each bluebook is limited to
           # @yieldparam aggregate [Bluebook::Aggregate] one aggregate to shape
           # @yieldreturn [Hash{String => Object}] the aggregate as the editor reads it
-          # @return [Array<Hash{String => Object}>] the shaped aggregates, chapter by chapter
-          def aggregates(chapters, skip:, roles:)
-            many = chapters.size > 1
-            chapters.flat_map do |chapter|
-              kept(chapter, skip).map { |agg| stamp(yield(agg), many ? chapter.name : nil, roles[chapter.name]) }
+          # @return [Array<Hash{String => Object}>] the shaped aggregates, bluebook by bluebook
+          def aggregates(declarations, skip:, roles:)
+            many = declarations.size > 1
+            declarations.flat_map do |declaration|
+              kept(declaration, skip).map { |agg| stamp(yield(agg), many ? declaration.name : nil, roles[declaration.name]) }
             end
           end
 
-          # @return [Array<Bluebook::Aggregate>] the chapter's aggregates that are not skipped
-          def kept(chapter, skip)
-            chapter.aggregates.reject { |agg| skip.intersect?([agg.hecks_name, "#{chapter.name}::#{agg.hecks_name}"]) }
+          # @return [Array<Bluebook::Aggregate>] the bluebook's aggregates that are not skipped
+          def kept(declaration, skip)
+            declaration.aggregates.reject { |agg| skip.intersect?([agg.hecks_name, "#{declaration.name}::#{agg.hecks_name}"]) }
           end
 
-          # @return [Hash{String => Object}] `shaped` with its chapter and roles after its name
+          # @return [Hash{String => Object}] `shaped` with its bluebook and roles after its name
           def stamp(shaped, named, roles)
-            extra = { "chapter" => named, "roles" => roles }.compact
+            extra = { "bluebook" => named, "roles" => roles }.compact
             { "name" => shaped["name"], **extra, **shaped.except("name") }
           end
         end

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

@@ -23,6 +23,9 @@ module Hecks
           # The states those commands move into.
           STATES = %w[withdrawn retired discarded deleted cancelled canceled removed].freeze
 
+          # One word of a CamelCase or snake_case name: a capital and its tail, or a lower-case run.
+          WORD = /[A-Z][a-z0-9]*|[a-z0-9]+/
+
           module_function
 
           # @param name [String] the command's name, such as `"DiscardDraft"`
@@ -53,7 +56,7 @@ module Hecks
           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)
+          def words(name) = name.to_s.scan(WORD).map(&:downcase)
         end
       end
     end

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

@@ -27,7 +27,8 @@ module Hecks
           # @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
+            commands = agg.commands.lazy
+            found = commands.filter_map { |command| saving(command, agg, attributes) }.first
             return nil unless found
 
             found.merge("publish" => publishing(agg, found), "discard" => discarding(agg, found)).compact
@@ -58,10 +59,13 @@ module Hecks
 
           # @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 = [draft, live].map { |name| type_of(agg, name).to_s }
             types.none?(&:empty?) && types.uniq.size == 1
           end
 
+          # @return [Object, nil] the type of the aggregate's attribute `name`, or nil without one
+          def type_of(agg, name) = agg.attributes.find { |held| held.name.to_s == name }&.type
+
           # @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)

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

@@ -14,6 +14,9 @@ module Hecks
           # `^` then one word, or a group of words separated by `|`, then the `:`.
           LEAD = /\A\^(?:\((?:\?:)?(?<kinds>\w+(?:\|\w+)*)\)|(?<kinds>\w+)):/
 
+          # A kind: a lower-case word of letters, digits and underscores, starting with a letter.
+          KIND = /\A[a-z][a-z0-9_]*\z/
+
           module_function
 
           # @param pattern [String, nil] the attribute's declared pattern
@@ -22,7 +25,7 @@ module Hecks
             found = LEAD.match(pattern.to_s)
             return [] unless found
 
-            found[:kinds].split("|").grep(/\A[a-z][a-z0-9_]*\z/).uniq
+            found[:kinds].split("|").grep(KIND).uniq
           end
         end
       end

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

@@ -5,7 +5,7 @@ module Hecks
     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
+        # rows (`bluebooks.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.
         #

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"], **agg.slice("chapter"), "command" => command["name"], "fields" => found,
+            { "aggregate" => agg["name"], **agg.slice("bluebook"), "command" => command["name"], "fields" => found,
               "listing" => listing && listing["name"] }
           end
         end

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

@@ -17,13 +17,15 @@ module Hecks
           # `format`, `Season` and `Combat` do not.
           AT = /(?:_at|[a-z0-9]At)\z/
           ON = /(?:_on|[a-z0-9]On)\z/
+          # A name that says it counts from the epoch, in any case.
+          EPOCH = /epoch/i
 
           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) }
+            return "datetime" if names.any? { |name| AT.match?(name) || name.match?(EPOCH) }
 
             "date" if names.any? { |name| ON.match?(name) }
           end

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

@@ -13,7 +13,7 @@ module Hecks
         # editor aggregate; a value object of one text part named `<Stem>Ref`, where `<Stem>` is
         # the type of an editor aggregate's identity or its name; and `<Image|Picture|Photo|Media>
         # Ref` with a picture aggregate, which suggests pictures and accepts any other text. A
-        # target is found once: the same chapter's, else the only one of its name; else none.
+        # target is found once: the same bluebook's, else the only one of its name; else none.
         module Pickers
           # The stems that name a picture, for the editor's picture aggregate.
           PICTURE_STEMS = %w[Image Picture Photo Media].freeze

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

@@ -23,6 +23,12 @@ module Hecks
           # An absolute address: the origin, then whatever follows it.
           ABSOLUTE = %r{\A(?<origin>https?://[^/?#\s]+)(?<rest>.*)\z}m
 
+          # A placeholder: braces around anything but a brace, capturing the word inside.
+          PLACEHOLDER = /\{([^{}]*)\}/
+
+          # An opening or a closing brace.
+          BRACE = /[{}]/
+
           module_function
 
           # @param template [String] the row's `preview`, which may be empty
@@ -31,7 +37,7 @@ module Hecks
             return [] if template.empty?
 
             found = []
-            found << "must not hold whitespace" if template.match?(/\s/)
+            found << "must not hold whitespace" if template.match?(Hecks::Text::WHITESPACE)
             found.concat(shape_problems(template))
             found.concat(placeholder_problems(template))
             found.map { |problem| "preview #{template.inspect} #{problem}" }
@@ -67,7 +73,7 @@ module Hecks
             found = []
             found << "must not name credentials in the address" if origin.include?("@")
             found << "must not hold a placeholder in the scheme, host or port" if origin.include?("{")
-            found << "names no host" if !origin.include?("{") && URI.parse(origin).host.to_s.empty?
+            found << "names no host" if !origin.include?("{") && Hecks::Text.blank?(URI.parse(origin).host)
             found
           rescue URI::InvalidURIError
             ["is not a valid address"]
@@ -75,13 +81,13 @@ module Hecks
 
           # @return [Array<String>] a problem for each unknown placeholder and each stray brace
           def placeholder_problems(template)
-            unknown = template.scan(/\{([^{}]*)\}/).flatten.uniq - PLACEHOLDERS
+            unknown = template.scan(PLACEHOLDER).flatten.uniq - PLACEHOLDERS
             found = unknown.map do |name|
               "names the placeholder {#{name}}; the placeholders are #{PLACEHOLDERS.map do |word|
                 "{#{word}}"
               end.join(", ")}"
             end
-            found << "has a brace that is not part of a placeholder" if template.gsub(/\{[^{}]*\}/, "").match?(/[{}]/)
+            found << "has a brace that is not part of a placeholder" if template.gsub(PLACEHOLDER, "").match?(BRACE)
             found
           end
         end

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

@@ -38,13 +38,14 @@ module Hecks
             return nil unless key && keyed_by?(key, agg)
 
             shape, field = shape_of(other, media)
-            { "aggregate" => other["name"], "chapter" => other["chapter"], "field" => key["name"], "shape" => shape,
+            { "aggregate" => other["name"], "bluebook" => other["bluebook"], "field" => key["name"], "shape" => shape,
               "create" => creating(other, key), "edit" => editing(other, field) }.compact
           end
 
           # @return [Boolean] whether `key` is declared a key of `<agg's snake name>:<slug>`
           def keyed_by?(key, agg)
-            (key.dig("picker", "kinds") || []).any? { |kind| kind["target"] == agg["name"] && kind["chapter"] == agg["chapter"] }
+            kinds = key.dig("picker", "kinds") || []
+            kinds.any? { |kind| kind["target"] == agg["name"] && kind["bluebook"] == agg["bluebook"] }
           end
 
           # @return [Array(String, String)] the shape, and the attribute that gives it

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

@@ -4,58 +4,65 @@ module Hecks
   module Projections
     module Site
       module CmsEditor
-        # What the `Editor` row's settings for many chapters and long lists must satisfy: chapters
-        # named once each, roles given for a chapter the editor edits, and a page size a list can
-        # hold. A chapter's name is part of an address, so it cannot be spelled as one of the
+        # What the `Editor` row's settings for many bluebooks and long lists must satisfy: bluebooks
+        # named once each, roles given for a bluebook the editor edits, and a page size a list can
+        # hold. A bluebook's name is part of an address, so it cannot be spelled as one of the
         # editor's own paths.
         module ScaleChecks
           # The most instances a list may show to a page.
           MAX_PAGE = 1000
 
-          # The first segments of the editor's own addresses, which no chapter may be named.
+          # A whole number from 1, of at most four digits: a page size.
+          PAGE_COUNT = /\A[1-9]\d{0,3}\z/
+
+          # The first segments of the editor's own addresses, which no bluebook may be named.
           RESERVED = %w[assets media logout api scheduled].freeze
 
           module_function
 
           # @param row [Hash{Symbol => String}] the row, defaults filled
-          # @return [Array<String>] every problem with `chapter`, `chapter_roles` and `page_size`
+          # @return [Array<String>] every problem with `bluebook`, `declaration_roles` and
+          #   `page_size`
           def problems(row)
-            chapters = row[:chapter].split(",").map(&:strip)
-            [*chapter_problems(chapters), *role_problems(row[:chapter_roles], chapters), *page_size_problems(row[:page_size])]
+            declarations = row[:bluebook].split(",").map(&:strip)
+            [*bluebook_problems(declarations), *role_problems(row[:bluebook_roles], declarations),
+             *page_size_problems(row[:page_size])]
           end
 
-          # @return [Array<String>] the problems with an empty, repeated or reserved chapter name
-          def chapter_problems(chapters)
+          # @return [Array<String>] the problems with an empty, repeated or reserved bluebook name
+          def bluebook_problems(declarations)
             found = []
-            found << "chapter names no chapter" if chapters.reject(&:empty?).empty?
-            repeated = chapters.find { |name| chapters.count(name) > 1 }
-            found << "chapter names #{repeated.inspect} twice" if repeated
-            [*found, *reserved_problems(chapters)]
+            found << "bluebook names nothing" if declarations.reject(&:empty?).empty?
+            repeated = declarations.find { |name| declarations.count(name) > 1 }
+            found << "bluebook names #{repeated.inspect} twice" if repeated
+            [*found, *reserved_problems(declarations)]
           end
 
-          # @return [Array<String>] a problem for each chapter spelled as an address of the editor's
-          def reserved_problems(chapters)
-            return [] if chapters.size < 2
+          # @return [Array<String>] a problem for each bluebook spelled as an address of the
+          #   editor's
+          def reserved_problems(declarations)
+            return [] if declarations.size < 2
 
-            (chapters & RESERVED).map do |name|
-              "chapter #{name.inspect} is the first part of an address the editor serves; name it another way"
+            (declarations & RESERVED).map do |name|
+              "bluebook #{name.inspect} is the first part of an address the editor serves; name it another way"
             end
           end
 
-          # @return [Array<String>] the problems with `Chapter=Role,Role;Chapter=Role` entries
-          def role_problems(text, chapters)
-            text.split(";").map(&:strip).reject(&:empty?).flat_map do |entry|
+          # @return [Array<String>] the problems with `Bluebook=Role,Role;Bluebook=Role` entries
+          def role_problems(text, declarations)
+            entries = text.split(";")
+            entries.map(&:strip).reject(&:empty?).flat_map do |entry|
               name, roles = entry.split("=", 2)
-              next ["chapter_roles #{entry.inspect} must read Chapter=Role,Role"] if roles.to_s.strip.empty?
-              next [] if chapters.include?(name.strip)
+              next ["bluebook_roles #{entry.inspect} must read Bluebook=Role,Role"] if roles.to_s.strip.empty?
+              next [] if declarations.include?(name.strip)
 
-              ["chapter_roles names #{name.strip.inspect}, which is not a chapter of this editor"]
+              ["bluebook_roles names #{name.strip.inspect}, which is not a bluebook of this editor"]
             end
           end
 
           # @return [Array<String>] the problem with a page size that is not a whole 1 to 1000
           def page_size_problems(size)
-            return [] if size.match?(/\A[1-9]\d{0,3}\z/) && size.to_i <= MAX_PAGE
+            return [] if size.match?(PAGE_COUNT) && size.to_i <= MAX_PAGE
 
             ["page_size #{size.inspect} must be a whole number from 1 to #{MAX_PAGE}"]
           end

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

@@ -38,7 +38,7 @@ module Hecks
             schedule = parts && endings(agg["lifecycle"]).size > 1 && creating(agg, parts)
             return nil unless schedule
 
-            { "aggregate" => agg["name"], "chapter" => agg["chapter"], **parts, "pending" => agg.dig("lifecycle", "default"),
+            { "aggregate" => agg["name"], "bluebook" => agg["bluebook"], **parts, "pending" => agg.dig("lifecycle", "default"),
               "schedule" => schedule["name"], **optional(agg, parts, schedule) }.compact
           end
 

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

@@ -16,69 +16,71 @@ module Hecks
   module Projections
     module Site
       module CmsEditor
-        # What the editor reads of a domain chapter, as plain data: each aggregate with its
+        # What the editor reads of a domain bluebook, as plain data: each aggregate with its
         # identity, attributes, value objects, lifecycle, commands and queries. The editor's
         # `schema.ts` is this hash as a typed constant, and nothing else about the domain reaches
-        # the generated files, so the output is a pure function of the chapter.
+        # the generated files, so the output is a pure function of the bluebook.
         #
         # An aggregate that registers pictures (see `Media`) is also named under `media`, so the
-        # editor can offer an upload; a chapter with none has no such key.
+        # editor can offer an upload; a bluebook with none has no such key.
         #
         # A query that `returns` a value object is answered outside the domain and is left out: the
         # host refuses it, so a list cannot be built from it.
         class Schema
-          # @param chapters [Bluebook::Chapter, Array<Bluebook::Chapter>] the chapter, or the
-          #   chapters in the order the row names them; the first names the domain addressed
-          # @param skip [Array<String>] aggregates to leave out: `Name`, or `Chapter::Name`
-          # @param pictures [Bluebook::Chapter, nil] another chapter whose picture aggregate the
-          #   editor's pictures use, in place of any in `chapters`
-          # @param roles [Hash{String => Array<String>}] the roles each chapter is limited to
-          # @return [Hash{String => Object}] the domain's name and its aggregates; `chapters` too
+          # @param bluebooks [Bluebook::Declaration, Array<Bluebook::Declaration>] the bluebook, or
+          #   the
+          #   bluebooks in the order the row names them; the first names the domain addressed
+          # @param skip [Array<String>] aggregates to leave out: `Name`, or `Bluebook::Name`
+          # @param pictures [Bluebook::Declaration, nil] another bluebook whose picture aggregate
+          #   the
+          #   editor's pictures use, in place of any in `bluebooks`
+          # @param roles [Hash{String => Array<String>}] the roles each bluebook is limited to
+          # @return [Hash{String => Object}] the domain's name and its aggregates; `bluebooks` too
           #   when there are several
           # @raise [ArgumentError] when no aggregate is left, or `pictures` has no picture aggregate
-          def self.read(chapters, skip: [], pictures: nil, roles: {})
-            list = chapters.is_a?(Array) ? chapters : [chapters]
+          def self.read(declarations, skip: [], pictures: nil, roles: {})
+            list = declarations.is_a?(Array) ? declarations : [declarations]
             shaped = Composition.aggregates(list, skip: skip, roles: roles) { |agg| new(agg).to_h }
-            raise ArgumentError, "the #{list.map(&:name).join(", ")} chapter has no aggregate to edit" if shaped.empty?
+            raise ArgumentError, "the #{list.map(&:name).join(", ")} bluebook has no aggregate to edit" if shaped.empty?
 
             media = pictures ? elsewhere(pictures) : within(shaped, list.first.name)
             assemble(list, Relations.apply(Pickers.apply(shaped, media), media), media)
           end
 
-          # @return [Hash{String => Object}] the schema: the domain, the chapters when several, the
+          # @return [Hash{String => Object}] the schema: the domain, the bluebooks when several, the
           #   aggregates, and the picture and scheduling aggregates when there are such
           def self.assemble(list, aggregates, media)
-            chapters = list.size > 1 ? { "chapters" => list.map(&:name) } : {}
+            declarations = list.size > 1 ? { "bluebooks" => list.map(&:name) } : {}
             scheduling = Scheduling.read(aggregates)
-            { "domain" => list.first.name, **chapters, "aggregates" => aggregates, **(media ? { "media" => media } : {}),
+            { "domain" => list.first.name, **declarations, "aggregates" => aggregates, **(media ? { "media" => media } : {}),
               **(scheduling ? { "scheduling" => scheduling } : {}) }
           end
 
-          # The picture aggregate among the editor's own, with the chapter that holds it when that
-          # is not the first, since the host is addressed by chapter.
+          # The picture aggregate among the editor's own, with the bluebook that holds it when that
+          # is not the first, since the host is addressed by bluebook.
           #
           # @return [Hash{String => Object}, nil] the picture aggregate, as `Media` describes it
           def self.within(shaped, first)
             found = Media.read(shaped)
-            chapter = found&.delete("chapter")
-            chapter && chapter != first ? found.merge("domain" => chapter) : found
+            declaration = found&.delete("bluebook")
+            declaration && declaration != first ? found.merge("domain" => declaration) : found
           end
 
-          # The picture aggregate of another chapter: the same record as one in the editor's own
-          # chapter, with the chapter's name and the aggregate itself, since the editor's own
+          # The picture aggregate of another bluebook: the same record as one in the editor's own
+          # bluebook, with the bluebook's name and the aggregate itself, since the editor's own
           # aggregates do not hold it.
           #
           # @return [Hash{String => Object}] the picture aggregate, as `Media` describes it
-          # @raise [ArgumentError] when the chapter has no aggregate that registers pictures
-          def self.elsewhere(chapter)
-            shaped = chapter.aggregates.map { |agg| new(agg).to_h }
+          # @raise [ArgumentError] when the bluebook has no aggregate that registers pictures
+          def self.elsewhere(declaration)
+            shaped = declaration.aggregates.map { |agg| new(agg).to_h }
             found = Media.read(shaped)
-            raise ArgumentError, "the #{chapter.name} chapter has no aggregate that registers pictures" unless found
+            raise ArgumentError, "the #{declaration.name} bluebook has no aggregate that registers pictures" unless found
 
-            found.merge("domain" => chapter.name, "definition" => shaped.find { |agg| agg["name"] == found["aggregate"] })
+            found.merge("domain" => declaration.name, "definition" => shaped.find { |agg| agg["name"] == found["aggregate"] })
           end
 
-          # @param aggregate [Bluebook::Aggregate] one aggregate of the chapter
+          # @param aggregate [Bluebook::Aggregate] one aggregate of the bluebook
           def initialize(aggregate)
             @agg = aggregate
             @attributes = Attributes.new(aggregate.value_objects)
@@ -96,7 +98,7 @@ module Hecks
 
           private
 
-          def lifecycle_field = @agg.lifecycle&.field
+          def lifecycle_field = @agg.lifecycle_field
 
           # The aggregate's own attributes, bounded by the aggregate's invariants (see `Limits`).
           def aggregate_attributes