hecks 5.0.0 → 7.0.0

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

@@ -11,38 +11,41 @@ module Hecks
   module Projections
     module Site
       module CmsEditor
-        # The project's `Editor` row, checked: which domain chapter the editor edits, where the
+        # The project's `Editor` row, checked: which domain bluebook the editor edits, where the
         # editor is served, the session cookie it keeps, and the host and sign-in it reads.
         #
         # `docs/site-routes.md` lists the fields. A project that declares no row has no editor to
         # project.
         class Setting
+          # A lowercase letter followed by an uppercase one: where two camel-case words meet.
+          WORD_BOUNDARY = /([a-z])([A-Z])/
+
           # The `Editor` row: its fields, which are required and what the others default to.
           ROW = RootRows.new(
             "Editor",
-            fields:   { domain: String, chapter: String, base_path: String, sso_path: String, session_cookie: String,
+            fields:   { domain: String, bluebook: String, base_path: String, sso_path: String, session_cookie: String,
                         host_cookie: String, host_env: String, host_default: String, roles: String, login: String,
                         title: String, brand: String, accent: String, logo: String, skip: String, media: String,
-                        media_dir: String, media_max_bytes: String, chapter_roles: String, page_size: [String, Integer],
+                        media_dir: String, media_max_bytes: String, bluebook_roles: String, page_size: [String, Integer],
                         preview: String },
-            required: %i[domain chapter host_env login],
+            required: %i[domain bluebook host_env login],
             defaults: { base_path: "/editor", session_cookie: "hecks_editor", host_cookie: "hecks_session",
                         host_default: "http://127.0.0.1:4322", roles: "Admin,Owner", title: "Editor", brand: "",
                         accent: "", logo: "", skip: "", media: "", media_dir: "media", media_max_bytes: "5242880",
-                        chapter_roles: "", page_size: "25", preview: "" }
+                        bluebook_roles: "", page_size: "25", preview: "" }
           )
 
           # @return [Hash{Symbol => String}] the checked row, defaults filled
           attr_reader :row
 
-          # Reads and checks the row a chapter declares.
+          # Reads and checks the row a bluebook declares.
           #
-          # @param chapter [Bluebook::Chapter] the chapter that declares the route table
+          # @param bluebook [Bluebook::Declaration] the bluebook that declares the route table
           # @param table [Table, nil] the checked route table, to check the login page against
-          # @return [Setting, nil] the checked setting, or nil when the chapter declares no row
+          # @return [Setting, nil] the checked setting, or nil when the bluebook declares no row
           # @raise [Table::Invalid] when the row is refused
-          def self.read(chapter, table: nil)
-            row = ROW.read(chapter).first
+          def self.read(declaration, table: nil)
+            row = ROW.read(declaration).first
             row && new(row, table: table)
           end
 
@@ -60,20 +63,24 @@ module Hecks
           # @return [String] the domain's directory, relative to the project
           def domain = row.fetch(:domain)
 
-          # @return [String] the first chapter the editor edits, which names the generated package
-          def chapter = chapters.first.to_s
+          # @return [String] the first bluebook the editor edits, which names the generated package
+          def bluebook = bluebooks.first.to_s
 
-          # @return [Array<String>] every chapter the editor edits, in the order the row names them:
-          #   `chapter` is one name or several, comma separated
-          def chapters = row.fetch(:chapter).split(",").map(&:strip).reject(&:empty?)
+          # @return [Array<String>] every bluebook the editor edits, in the order the row names
+          #   them:
+          #   `bluebook` is one name or several, comma separated
+          def bluebooks = Hecks::Text.comma_list(row.fetch(:bluebook))
 
-          # @return [Hash{String => Array<String>}] the roles a chapter's aggregates are limited to,
-          #   from `Chapter=Role,Role;Chapter=Role`; a chapter not named is open to every role the
+          # @return [Hash{String => Array<String>}] the roles a bluebook's aggregates are limited
+          #   to,
+          #   from `Bluebook=Role,Role;Bluebook=Role`; a bluebook not named is open to every role
+          #   the
           #   editor admits
-          def chapter_roles
-            row.fetch(:chapter_roles).split(";").map(&:strip).reject(&:empty?).to_h do |entry|
+          def bluebook_roles
+            entries = row.fetch(:bluebook_roles).split(";")
+            entries.map(&:strip).reject(&:empty?).to_h do |entry|
               name, roles = entry.split("=", 2)
-              [name.to_s.strip, roles.to_s.split(",").map(&:strip).reject(&:empty?)]
+              [name.to_s.strip, Hecks::Text.comma_list(roles)]
             end
           end
 
@@ -83,9 +90,9 @@ module Hecks
           # @return [Integer] how many instances a list shows to a page
           def page_size = row.fetch(:page_size).to_i
 
-          # @return [String, nil] the other chapter whose picture aggregate the editor's pictures
-          #   use, or nil when the pictures (if any) are in the editor's own chapter
-          def media_chapter = row.fetch(:media).strip.then { |name| name.empty? ? nil : name }
+          # @return [String, nil] the other bluebook whose picture aggregate the editor's pictures
+          #   use, or nil when the pictures (if any) are in the editor's own bluebook
+          def media_bluebook = row.fetch(:media).strip.then { |name| name.empty? ? nil : name }
 
           # @return [String, nil] the product name the header shows, or nil for the domain's name
           def brand = row.fetch(:brand).strip.then { |name| name.empty? ? nil : name }
@@ -93,14 +100,14 @@ module Hecks
           # @return [String, nil] the accent colour as hex, or nil for the default theme
           def accent = row.fetch(:accent).strip.then { |hex| hex.empty? ? nil : hex }
 
-          # @return [Array<String>] the aggregates left out: `Name`, or `Chapter::Name`
-          def skip = row.fetch(:skip).split(",").map(&:strip).reject(&:empty?)
+          # @return [Array<String>] the aggregates left out: `Name`, or `Bluebook::Name`
+          def skip = Hecks::Text.comma_list(row.fetch(:skip))
 
           # @return [Array<String>] the roles that count as an editor
-          def roles = row.fetch(:roles).split(",").map(&:strip).reject(&:empty?)
+          def roles = Hecks::Text.comma_list(row.fetch(:roles))
 
           # @return [String] the generated package's name
-          def package = "#{chapter.gsub(/([a-z])([A-Z])/, '\1-\2').tr("_", "-").downcase}-editor"
+          def package = "#{bluebook.gsub(WORD_BOUNDARY, '\1-\2').tr("_", "-").downcase}-editor"
 
           # @return [Hash{String => String}] each placeholder to the text that replaces it
           def tokens

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

@@ -16,6 +16,9 @@ module Hecks
           # list everything, then the one that lists what is in use.
           LISTINGS = %w[all list listing active].freeze
 
+          # A lower-case letter or digit followed by a capital: where two camel-case words meet.
+          WORD_BOUNDARY = /([a-z0-9])([A-Z])/
+
           # @param aggregates [Array<Hash{String => Object}>] the aggregates as `Schema` shapes them
           # @param media [Hash{String => Object}, nil] the picture aggregate, as `Media` says
           def initialize(aggregates, media = nil)
@@ -47,20 +50,20 @@ module Hecks
             agg = @media["definition"] || @aggregates.find { |candidate| candidate["name"] == @media["aggregate"] }
             return nil unless agg
 
-            described = describe(agg, agg["chapter"] || @media["domain"], @media["listing"])
+            described = describe(agg, agg["bluebook"] || @media["domain"], @media["listing"])
             described.merge("label" => @media.dig("fields", "alt", "name"), "strict" => false)
           end
 
           private
 
           def pick(found, from)
-            own = found.select { |agg| agg["chapter"] == from["chapter"] }
+            own = found.select { |agg| agg["bluebook"] == from["bluebook"] }
             chosen = own.first || (found.first if found.size == 1)
-            chosen && describe(chosen, chosen["chapter"], listing(chosen)).merge("strict" => true)
+            chosen && describe(chosen, chosen["bluebook"], listing(chosen)).merge("strict" => true)
           end
 
-          def describe(agg, chapter, listing)
-            { "target" => agg["name"], "chapter" => chapter, "key" => agg["identity"], "label" => label(agg),
+          def describe(agg, declaration, listing)
+            { "target" => agg["name"], "bluebook" => declaration, "key" => agg["identity"], "label" => label(agg),
               "listing" => listing }.compact
           end
 
@@ -78,7 +81,7 @@ module Hecks
             LISTINGS.filter_map { |word| named.find { |name| name.downcase == word } }.first
           end
 
-          def snake(name) = name.gsub(/([a-z0-9])([A-Z])/, "\\1_\\2").downcase
+          def snake(name) = name.gsub(WORD_BOUNDARY, "\\1_\\2").downcase
         end
       end
     end

data/lib/hecks/projections/site/cms_editor/templates/src/app.ts.tmpl

@@ -98,7 +98,7 @@ function sameSite(request: Request): boolean {
 
 /** What a route needs to answer: show a page for this person, or send them on with a notice. */
 interface Scene {
-  /** The person's role, which decides the chapters they may edit. */
+  /** The person's role, which decides the bluebooks they may edit. */
   role: string | null;
   show(body: string, status?: number, notice?: Flash): Promise<Response>;
   sent(location: string, message: string): Response;
@@ -191,7 +191,7 @@ function route(client: HostClient, request: Request, url: URL, segments: string[
   if (segments[0] === "assets" && segments.length === 2 && request.method === "GET") return serveAsset(segments[1], request);
   if (segments[0] === "scheduled" && segments.length === 1 && request.method === "GET" && SCHEMA.scheduling) return scheduledView(client, scene);
   const { agg, rest: [verb, ...rest] } = locate(segments);
-  if (!agg) return scene.show(notFound(`No aggregate ${segments.slice(0, SCHEMA.chapters ? 2 : 1).join("/")}.`), 404);
+  if (!agg) return scene.show(notFound(`No aggregate ${segments.slice(0, SCHEMA.bluebooks ? 2 : 1).join("/")}.`), 404);
   if (!mayEdit(agg, scene.role)) return scene.show(notFound(`${plural(agg.name)} are not open to your role.`, "Not open to your role"), 403);
   if (verb === undefined) return list(client, agg, url, scene);
   if (verb === "id" && rest.length === 1 && request.method === "GET") return detail(client, agg, rest[0], null, scene);
@@ -319,7 +319,7 @@ async function unchecked(client: HostClient, agg: Aggregate, command: Command, a
 /** The scheduled-action record the editor makes itself: a creating command gets an identity nobody typed. */
 function withMadeIdentity(agg: Aggregate, command: Command, args: State): State {
   const spec = SCHEMA.scheduling;
-  if (!spec?.generated || !command.creates || command.name !== spec.schedule || agg.name !== spec.aggregate || agg.chapter !== spec.chapter) return args;
+  if (!spec?.generated || !command.creates || command.name !== spec.schedule || agg.name !== spec.aggregate || agg.bluebook !== spec.bluebook) return args;
   const identity = agg.attributes.find((attr) => attr.name === agg.identity);
   return identity ? { ...args, [identity.name]: plainValue(agg, identity, randomUUID()) } : args;
 }

data/lib/hecks/projections/site/cms_editor/templates/src/commands.ts.tmpl

@@ -60,12 +60,12 @@ function canonical(value: unknown): unknown {
 
 const sameState = (a: State | undefined, b: State | undefined): boolean => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
 
-/** Whether the host's refusal names this aggregate's verb: by its chapter too when the editor spans several. */
+/** Whether the host's refusal names this aggregate's verb: by its bluebook too when the editor spans several. */
 function refusedLast(answer: Answer, agg: Aggregate, command: Command): boolean {
   const last = (answer.refusals ?? []).at(-1);
   if (last === undefined) return false;
   const verb = String(last.verb ?? "");
-  return verb.replace(/^.*::/, "") === `${agg.name}.${command.name}` && (!agg.chapter || !verb.includes("::") || verb.startsWith(`${agg.chapter}::`));
+  return verb.replace(/^.*::/, "") === `${agg.name}.${command.name}` && (!agg.bluebook || !verb.includes("::") || verb.startsWith(`${agg.bluebook}::`));
 }
 
 /** Whether `after` shows the command took effect, given the instance as it was `before`. */

data/lib/hecks/projections/site/cms_editor/templates/src/host.ts.tmpl

@@ -14,7 +14,7 @@ export interface HostOptions {
   /** The host's address, when not read from the environment variable the Editor row names. */
   url?: string;
   fetch?: typeof fetch;
-  /** The domain to address, when it is not the chapter the editor edits (pictures kept in another chapter). */
+  /** The domain to address, when it is not the bluebook the editor edits (pictures kept in another bluebook). */
   domain?: string;
 }
 

data/lib/hecks/projections/site/cms_editor/templates/src/media/handler.ts.tmpl

@@ -79,11 +79,11 @@ function picture(storage: MediaStorage, media: Media, state: State) {
 }
 
 function aggregateOf(media: Media): Aggregate {
-  const own = (candidate: Aggregate): boolean => candidate.name === media.aggregate && (candidate.chapter ?? SCHEMA.domain) === (media.domain ?? SCHEMA.domain);
+  const own = (candidate: Aggregate): boolean => candidate.name === media.aggregate && (candidate.bluebook ?? SCHEMA.domain) === (media.domain ?? SCHEMA.domain);
   return media.definition ?? (SCHEMA.aggregates.find(own) as Aggregate);
 }
 
-/** Whether a person in `role` may use the pictures: not when the chapter that holds them limits its roles to others. */
+/** Whether a person in `role` may use the pictures: not when the bluebook that holds them limits its roles to others. */
 export function mediaOpen(role: string | null): boolean {
   const media = SCHEMA.media as Media;
   return mayEdit(aggregateOf(media), role);
@@ -161,8 +161,8 @@ async function serve(storage: MediaStorage, key: string): Promise<Response> {
 
 /**
  * The handler of everything under `<base>/media`, given the path segments after `media`. When the
- * pictures are kept in another chapter (`media.domain`), they are read and registered through a
- * client for that chapter, not the editor's own.
+ * pictures are kept in another bluebook (`media.domain`), they are read and registered through a
+ * client for that bluebook, not the editor's own.
  */
 export function mediaHandler(storage: MediaStorage = diskStorage(), options: HostOptions = {}) {
   const media = SCHEMA.media as Media;

data/lib/hecks/projections/site/cms_editor/templates/src/names.ts.tmpl

@@ -2,35 +2,35 @@ __BANNER__
 
 // How an aggregate is named in the three places it has a name: its address in the editor, the name
 // the host knows it by, and the key the navigation and the counts hold it under. An editor of one
-// chapter names an aggregate by its own name in all three. An editor of several chapters names it by
-// its chapter as well, so two aggregates of one name in different chapters stay two.
+// bluebook names an aggregate by its own name in all three. An editor of several bluebooks names it by
+// its bluebook as well, so two aggregates of one name in different bluebooks stay two.
 import { SCHEMA } from "./schema.ts";
 import type { Aggregate } from "./schema.ts";
 
 /** The path segments that address an aggregate under the editor's base path. */
-export const at = (agg: Aggregate): string[] => (agg.chapter ? [agg.chapter, agg.name] : [agg.name]);
+export const at = (agg: Aggregate): string[] => (agg.bluebook ? [agg.bluebook, agg.name] : [agg.name]);
 
-/** The name the host knows an aggregate by: `Chapter::Aggregate` when the editor spans chapters. */
-export const qualified = (agg: Aggregate): string => (agg.chapter ? `${agg.chapter}::${agg.name}` : agg.name);
+/** The name the host knows an aggregate by: `Bluebook::Aggregate` when the editor spans bluebooks. */
+export const qualified = (agg: Aggregate): string => (agg.bluebook ? `${agg.bluebook}::${agg.name}` : agg.name);
 
 /** What the navigation and the counts hold an aggregate under. */
-export const keyOf = (agg: Aggregate): string => (agg.chapter ? `${agg.chapter}.${agg.name}` : agg.name);
+export const keyOf = (agg: Aggregate): string => (agg.bluebook ? `${agg.bluebook}.${agg.name}` : agg.name);
 
-/** The host's name for an aggregate of `chapter` (this editor's first chapter when none is named). */
-export const hostName = (name: string, chapter?: string): string => `${chapter ?? SCHEMA.domain}::${name}`;
+/** The host's name for an aggregate of `bluebook` (this editor's first bluebook when none is named). */
+export const hostName = (name: string, bluebook?: string): string => `${bluebook ?? SCHEMA.domain}::${name}`;
 
 /**
- * The aggregate a path names, and the segments after it. With several chapters the path is
- * `<Chapter>/<Aggregate>/...`, and with one it is `<Aggregate>/...`.
+ * The aggregate a path names, and the segments after it. With several bluebooks the path is
+ * `<Bluebook>/<Aggregate>/...`, and with one it is `<Aggregate>/...`.
  */
 export function locate(segments: string[]): { agg: Aggregate | undefined; rest: string[] } {
-  if (SCHEMA.chapters) {
-    const [chapter, name, ...rest] = segments;
-    return { agg: SCHEMA.aggregates.find((candidate) => candidate.chapter === chapter && candidate.name === name), rest };
+  if (SCHEMA.bluebooks) {
+    const [bluebook, name, ...rest] = segments;
+    return { agg: SCHEMA.aggregates.find((candidate) => candidate.bluebook === bluebook && candidate.name === name), rest };
   }
   const [name, ...rest] = segments;
   return { agg: SCHEMA.aggregates.find((candidate) => candidate.name === name), rest };
 }
 
-/** Whether a person in `role` may edit `agg`: every role may, unless its chapter limits them. */
+/** Whether a person in `role` may edit `agg`: every role may, unless its bluebook limits them. */
 export const mayEdit = (agg: Aggregate, role: string | null): boolean => !agg.roles || (role !== null && agg.roles.includes(role));

data/lib/hecks/projections/site/cms_editor/templates/src/schema.ts.tmpl

@@ -15,8 +15,8 @@ export type Kind = "text" | "integer" | "number" | "boolean" | "object" | "refer
  */
 export interface Picker {
   target?: string;
-  /** The target's chapter, when the editor spans several or the target is in another. */
-  chapter?: string;
+  /** The target's bluebook, when the editor spans several or the target is in another. */
+  bluebook?: string;
   /** The target's identity attribute. */
   key?: string;
   /** The attribute that names an instance to a person (its title, name or label, else its identity). */
@@ -120,7 +120,7 @@ export interface Query {
  */
 export interface Related {
   aggregate: string;
-  chapter?: string;
+  bluebook?: string;
   /** The related aggregate's identity attribute, which the key fills. */
   field: string;
   shape: "document" | "gallery" | "metadata";
@@ -140,9 +140,9 @@ export interface Drafts {
 
 export interface Aggregate {
   name: string;
-  /** The chapter that declares the aggregate; set when the editor spans several. */
-  chapter?: string;
-  /** The roles that may edit it, when its chapter limits them; any admitted role otherwise. */
+  /** The bluebook that declares the aggregate; set when the editor spans several. */
+  bluebook?: string;
+  /** The roles that may edit it, when its bluebook limits them; any admitted role otherwise. */
   roles?: string[];
   description: string | null;
   identity: string;
@@ -163,14 +163,14 @@ export interface MediaField {
   wrap: string | null;
 }
 
-/** The aggregate that registers pictures, when the chapter has one: found by shape, never by name. */
+/** The aggregate that registers pictures, when the bluebook has one: found by shape, never by name. */
 export interface Media {
   aggregate: string;
   command: string;
   fields: { key: MediaField; alt: MediaField; mime: MediaField; width?: MediaField; height?: MediaField };
   /** The query that lists the pictures, or null when every instance is read. */
   listing: string | null;
-  /** The chapter that holds the picture aggregate, when it is not this editor's own chapter. */
+  /** The bluebook that holds the picture aggregate, when it is not this editor's own bluebook. */
   domain?: string;
   /** That aggregate, which is then not among the editor's own; see `domain`. */
   definition?: Aggregate;
@@ -183,7 +183,7 @@ export interface Media {
  */
 export interface Scheduling {
   aggregate: string;
-  chapter?: string;
+  bluebook?: string;
   subject: string;
   action: string;
   actions: string[];
@@ -202,10 +202,10 @@ export interface Scheduling {
 }
 
 export interface Schema {
-  /** The first chapter, which names the domain the host is asked for. */
+  /** The first bluebook, which names the domain the host is asked for. */
   domain: string;
-  /** Every chapter, in the order the navigation groups them; set when the editor spans several. */
-  chapters?: string[];
+  /** Every bluebook, in the order the navigation groups them; set when the editor spans several. */
+  bluebooks?: string[];
   aggregates: Aggregate[];
   media?: Media;
   scheduling?: Scheduling;

data/lib/hecks/projections/site/cms_editor/templates/src/ui/pages.ts.tmpl

@@ -3,8 +3,8 @@ __BANNER__
 // The pages: an overview of what the domain holds, a list per aggregate (table.ts), one instance
 // (detail.ts), and a form per command generated from the command's attributes. Every page is built
 // into the frame in shell.ts. Lifecycle state is a badge, and a lifecycle move is offered only from
-// the states it applies in. An editor of several chapters groups the overview and the navigation by
-// chapter and puts the chapter in each address.
+// the states it applies in. An editor of several bluebooks groups the overview and the navigation by
+// bluebook and puts the bluebook in each address.
 import { EDITOR } from "../config.ts";
 import { at, keyOf } from "../names.ts";
 import type { Aggregate, Attr, Command, Query } from "../schema.ts";
@@ -37,11 +37,11 @@ const OVERVIEW: Crumb = ["Overview", href()];
 const head = (title: string, note: string, extra = ""): string =>
   `<div class="mb-6 flex flex-wrap items-start justify-between gap-3"><div><h1 class="text-3xl">${esc(title)}</h1><p class="mt-1 max-w-prose text-muted">${esc(note)}</p></div>${extra}</div>`;
 
-/** The trail to an aggregate's list: the overview, then the chapter when there are several. */
-const trail = (agg: Aggregate): Crumb[] => [OVERVIEW, ...(agg.chapter ? [[label(agg.chapter)] as Crumb] : []), [plural(agg.name), href(...at(agg))]];
+/** The trail to an aggregate's list: the overview, then the bluebook when there are several. */
+const trail = (agg: Aggregate): Crumb[] => [OVERVIEW, ...(agg.bluebook ? [[label(agg.bluebook)] as Crumb] : []), [plural(agg.name), href(...at(agg))]];
 
-/** The words a page of an aggregate carries in its title: the plural, and the chapter when it could be mistaken for another. */
-const titleOf = (agg: Aggregate): string => (agg.chapter ? `${plural(agg.name)} (${label(agg.chapter)})` : plural(agg.name));
+/** The words a page of an aggregate carries in its title: the plural, and the bluebook when it could be mistaken for another. */
+const titleOf = (agg: Aggregate): string => (agg.bluebook ? `${plural(agg.name)} (${label(agg.bluebook)})` : plural(agg.name));
 
 function overviewItems(aggregates: Aggregate[]): string {
   const items = aggregates.map((agg) => {
@@ -53,18 +53,18 @@ function overviewItems(aggregates: Aggregate[]): string {
 
 /** The overview: every aggregate the domain declares, with what it is and how much of it there is. */
 export function home(): string {
-  const sections = groups().map(([chapter, aggregates]) => {
-    if (chapter === null) return overviewItems(aggregates);
-    return groupOf(chapter, `<h2 class="mb-2 mt-8 text-lg">${esc(label(chapter))}</h2>\n${overviewItems(aggregates)}`);
+  const sections = groups().map(([bluebook, aggregates]) => {
+    if (bluebook === null) return overviewItems(aggregates);
+    return groupOf(bluebook, `<h2 class="mb-2 mt-8 text-lg">${esc(label(bluebook))}</h2>\n${overviewItems(aggregates)}`);
   });
-  const body = `${head(SCHEMA.chapters ? EDITOR.brand : SCHEMA.domain, "Choose what to edit.")}
+  const body = `${head(SCHEMA.bluebooks ? EDITOR.brand : SCHEMA.domain, "Choose what to edit.")}
 ${sections.join("\n")}`;
   return page("Overview", body, { crumbs: [["Overview"]] });
 }
 
 /**
  * The page for a path that names nothing, or, with a `title`, for another reason the person is
- * sent back (the domain not answering, a chapter closed to their role): the heading and the tab
+ * sent back (the domain not answering, a bluebook closed to their role): the heading and the tab
  * say that reason, not "Not found".
  */
 export function notFound(what: string, title = "Not found"): string {
@@ -75,7 +75,7 @@ export function notFound(what: string, title = "Not found"): string {
 
 /** An aggregate's list: one page of its rows, with the filters in `view`. */
 export function listPage(agg: Aggregate, rows: Row[], query: Query | null, error: string | null, asked: boolean, view: View, choices: Choices = {}): string {
-  return page(titleOf(agg), list(agg, rows, query, error, asked, view, choices), { active: keyOf(agg), crumbs: [OVERVIEW, ...(agg.chapter ? [[label(agg.chapter)] as Crumb] : []), [plural(agg.name)]] });
+  return page(titleOf(agg), list(agg, rows, query, error, asked, view, choices), { active: keyOf(agg), crumbs: [OVERVIEW, ...(agg.bluebook ? [[label(agg.bluebook)] as Crumb] : []), [plural(agg.name)]] });
 }
 
 /** One instance, with the records and actions that go with it and its preview. */

data/lib/hecks/projections/site/cms_editor/templates/src/ui/pickers.ts.tmpl

@@ -29,7 +29,7 @@ export const SELECT_MAX = 30;
 export const OFFER_MAX = 500;
 
 /** The host's name for the aggregate a target offers: the key its choices are held under. */
-export const targetKey = (target: Target): string => hostName(target.target ?? "", target.chapter);
+export const targetKey = (target: Target): string => hostName(target.target ?? "", target.bluebook);
 
 const idOf = (key: string): string => `choices-${key.replace(/[^A-Za-z0-9]+/g, "-")}`;
 

data/lib/hecks/projections/site/cms_editor/templates/src/ui/schedule.ts.tmpl

@@ -30,7 +30,7 @@ function scheduler(): { agg: Aggregate; spec: Scheduling } | null {
 /** Whether a scheduled action's subject can be a record of `agg`: its key's kinds name that aggregate. */
 function subjectIs(sched: Aggregate, spec: Scheduling, agg: Aggregate): boolean {
   const subject = sched.attributes.find((attr) => attr.name === spec.subject);
-  return (subject?.picker?.kinds ?? []).some((kind) => kind.target === agg.name && kind.chapter === agg.chapter);
+  return (subject?.picker?.kinds ?? []).some((kind) => kind.target === agg.name && kind.bluebook === agg.bluebook);
 }
 
 /** Whether records of `agg` have a Schedule panel and the person may use it. */
@@ -138,7 +138,7 @@ function subjectLink(key: string, sched: Aggregate, spec: Scheduling, world: Wor
   const kind = key.slice(0, Math.max(key.indexOf(":"), 0));
   const subject = sched.attributes.find((attr) => attr.name === spec.subject);
   const target = (subject?.picker?.kinds ?? []).find((candidate) => candidate.kind === kind && candidate.target);
-  const aggregate = target && SCHEMA.aggregates.find((candidate) => candidate.name === target.target && candidate.chapter === target.chapter);
+  const aggregate = target && SCHEMA.aggregates.find((candidate) => candidate.name === target.target && candidate.bluebook === target.bluebook);
   const id = aggregate && [key.slice(kind.length + 1), key].find((candidate) => world.lookup(aggregate, candidate));
   return aggregate && id ? `<a class="link" href="${esc(href(...at(aggregate), "id", id))}">${esc(key)}</a>` : esc(key);
 }

data/lib/hecks/projections/site/cms_editor/templates/src/ui/shell.ts.tmpl

@@ -49,13 +49,13 @@ export const countMark = MARK.count;
 /** `html` as the part of a page only the people who may edit `agg` see: `decorate` cuts it out for the rest. */
 export const onlyFor = (agg: Aggregate, html: string): string => `<!--editor:only:${keyOf(agg)}-->${html}<!--editor:/only:${keyOf(agg)}-->`;
 
-/** `html` as the part of a page that belongs to a chapter, cut out when the person may edit none of it. */
-export const groupOf = (chapter: string, html: string): string => `<!--editor:group:${chapter}-->${html}<!--editor:/group:${chapter}-->`;
+/** `html` as the part of a page that belongs to a bluebook, cut out when the person may edit none of it. */
+export const groupOf = (bluebook: string, html: string): string => `<!--editor:group:${bluebook}-->${html}<!--editor:/group:${bluebook}-->`;
 
-/** The chapters in the order they are shown, each with the aggregates it holds; one nameless group for an editor of one chapter. */
-export function groups(): [chapter: string | null, aggregates: Aggregate[]][] {
-  if (!SCHEMA.chapters) return [[null, SCHEMA.aggregates]];
-  return SCHEMA.chapters.map((chapter): [string, Aggregate[]] => [chapter, SCHEMA.aggregates.filter((agg) => agg.chapter === chapter)]);
+/** The bluebooks in the order they are shown, each with the aggregates it holds; one nameless group for an editor of one bluebook. */
+export function groups(): [bluebook: string | null, aggregates: Aggregate[]][] {
+  if (!SCHEMA.bluebooks) return [[null, SCHEMA.aggregates]];
+  return SCHEMA.bluebooks.map((bluebook): [string, Aggregate[]] => [bluebook, SCHEMA.aggregates.filter((agg) => agg.bluebook === bluebook)]);
 }
 
 function brandMark(extra: string): string {
@@ -80,10 +80,10 @@ function scheduledLink(active: string | undefined): string {
 }
 
 function navigation(active: string | undefined): string {
-  const sections = groups().map(([chapter, aggregates]) => {
-    const heading = `<li class="menu-title mt-4 px-3 text-muted">${chapter === null ? "Content" : esc(label(chapter))}</li>`;
+  const sections = groups().map(([bluebook, aggregates]) => {
+    const heading = `<li class="menu-title mt-4 px-3 text-muted">${bluebook === null ? "Content" : esc(label(bluebook))}</li>`;
     const section = `${heading}\n${navItems(aggregates, active)}`;
-    return chapter === null ? section : groupOf(chapter, section);
+    return bluebook === null ? section : groupOf(bluebook, section);
   });
   return `<nav id="rail" aria-label="Sections" class="flex-1 overflow-y-auto">
 <ul class="menu w-full gap-0.5 p-3">
@@ -191,8 +191,8 @@ function cutBetween(html: string, open: string, close: string): string {
 function visibleTo(html: string, role: string | null): string {
   const hidden = SCHEMA.aggregates.filter((agg) => !mayEdit(agg, role));
   const gone = hidden.map((agg): [string, string] => [`<!--editor:only:${keyOf(agg)}-->`, `<!--editor:/only:${keyOf(agg)}-->`]);
-  const empty = (SCHEMA.chapters ?? []).filter((chapter) => SCHEMA.aggregates.every((agg) => agg.chapter !== chapter || hidden.includes(agg)));
-  const groups = empty.map((chapter): [string, string] => [`<!--editor:group:${chapter}-->`, `<!--editor:/group:${chapter}-->`]);
+  const empty = (SCHEMA.bluebooks ?? []).filter((bluebook) => SCHEMA.aggregates.every((agg) => agg.bluebook !== bluebook || hidden.includes(agg)));
+  const groups = empty.map((bluebook): [string, string] => [`<!--editor:group:${bluebook}-->`, `<!--editor:/group:${bluebook}-->`]);
   const cut = [...gone, ...groups].reduce((text, [open, close]) => cutBetween(text, open, close), html);
   return cut.replace(/<!--editor:\/?(?:only|group):[^>]*-->/g, "");
 }

data/lib/hecks/projections/site/cms_editor/templates/src/ui/world.ts.tmpl

@@ -21,15 +21,15 @@ export interface World {
 
 /** The aggregate a `related` entry names. */
 export const relatedAggregate = (rel: Related): Aggregate | undefined =>
-  SCHEMA.aggregates.find((candidate) => candidate.name === rel.aggregate && candidate.chapter === rel.chapter);
+  SCHEMA.aggregates.find((candidate) => candidate.name === rel.aggregate && candidate.bluebook === rel.bluebook);
 
 /** The aggregate that registers pictures, when the editor has it among its own. */
 export function pictureAggregate(): Aggregate | undefined {
   const media = SCHEMA.media;
   if (!media) return undefined;
-  return SCHEMA.aggregates.find((agg) => agg.name === media.aggregate && (media.domain ? agg.chapter === media.domain : !agg.chapter || agg.chapter === SCHEMA.domain));
+  return SCHEMA.aggregates.find((agg) => agg.name === media.aggregate && (media.domain ? agg.bluebook === media.domain : !agg.bluebook || agg.bluebook === SCHEMA.domain));
 }
 
 /** The aggregate whose records are the scheduled actions, when the editor has one. */
 export const schedulingAggregate = (): Aggregate | undefined =>
-  SCHEMA.scheduling && SCHEMA.aggregates.find((candidate) => candidate.name === SCHEMA.scheduling?.aggregate && candidate.chapter === SCHEMA.scheduling?.chapter);
+  SCHEMA.scheduling && SCHEMA.aggregates.find((candidate) => candidate.name === SCHEMA.scheduling?.aggregate && candidate.bluebook === SCHEMA.scheduling?.bluebook);

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

@@ -16,6 +16,12 @@ module Hecks
           # The longest brand the header has room for.
           BRAND_LENGTH = 60
 
+          # A control character, such as a newline.
+          CONTROL = /[[:cntrl:]]/
+
+          # A backslash or a control character: what a safe relative path never holds.
+          BACKSLASH_OR_CONTROL = /[\\[:cntrl:]]/
+
           module_function
 
           # @param row [Hash{Symbol => String}] the row, defaults filled
@@ -40,7 +46,7 @@ module Hecks
 
           # @return [Array<String>] the problem with a brand that is long or has more than one line
           def brand_problems(brand)
-            return [] if brand.length <= BRAND_LENGTH && !brand.match?(/[[:cntrl:]]/)
+            return [] if brand.length <= BRAND_LENGTH && !brand.match?(CONTROL)
 
             ["brand must be one line of at most #{BRAND_LENGTH} characters"]
           end
@@ -48,7 +54,7 @@ module Hecks
           # @return [Boolean] whether `path` is relative, has no hidden part, and is a picture
           def safe_path?(path)
             LOGO_TYPES.include?(File.extname(path).delete_prefix(".").downcase) && !path.start_with?("/") &&
-              path.split("/", -1).none? { |part| part.empty? || part.start_with?(".") } && !path.match?(/[\\[:cntrl:]]/)
+              path.split("/", -1).none? { |part| part.empty? || part.start_with?(".") } && !path.match?(BACKSLASH_OR_CONTROL)
           end
         end
       end