hecks 3.2.0 → 3.2.1

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

@@ -28,7 +28,9 @@ module Hecks
           # @param rows [Array<Table::Row>] the route table's rows
           # @param vocabulary [Hash{Symbol => Array<String>}] the Site chapter's closed sets
           # @param problems [Array<String>] collects each problem found, one line each
-          def initialize(edge, rows, vocabulary, problems)
+          # @param template_named [Boolean] whether the caller names the template itself
+          def initialize(edge, rows, vocabulary, problems, template_named: false)
+            @template_named = template_named
             @edge = edge
             @rows = rows
             @vocabulary = vocabulary
@@ -48,15 +50,21 @@ module Hecks
 
           def check_setting
             setting = @edge.setting
-            return problem("Edge", "has no row naming the template; declare one member with template:") unless setting
+            return problem("Edge", "has no row; declare one member with template:") unless setting
+
+            check_template(setting.template) if setting.template || !@template_named
 
-            template = setting.template.to_s
-            problem("Edge", "template #{template.inspect} must be a path inside the project") if
-              template.empty? || template.start_with?("/") || template.split("/").include?("..")
             problem("Edge", "has secret_header but no secret_value") if setting.secret_header && !setting.secret_value
             problem("Edge", "has secret_value but no secret_header") if setting.secret_value && !setting.secret_header
           end
 
+          def check_template(template)
+            template = template.to_s
+            problem("Edge", "has no template; declare template: or name the file to the tool") if template.empty?
+            problem("Edge", "template #{template.inspect} must be a path inside the project") if
+              template.start_with?("/") || template.split("/").include?("..")
+          end
+
           def check_policies
             @edge.policies.each do |policy|
               label = "EdgePolicy #{policy.cache_class}#{" on #{policy.origin}" if policy.origin}"
@@ -86,12 +94,30 @@ module Hecks
           end
 
           def check_rules
+            return check_no_alb unless @edge.alb?
+
             problem("EdgeRule", "rows need an Edge row with listener:") if @edge.rules.any? && !@edge.setting&.listener
             @edge.rules.each { |rule| check_rule(rule) }
             repeated(@edge.rules.map(&:rule), "EdgeRule", &:itself)
             repeated(@edge.rules.map(&:priority), "EdgeRule priority", &:to_s)
           end
 
+          # With `alb: false` nothing routes by listener rule, so a rule row, or a route that names
+          # one, describes a load balancer the project says it does not have. Every route that is
+          # served by a server behind the edge still needs the origin that reaches it.
+          def check_no_alb
+            problem("EdgeRule", "rows describe a load balancer, and the Edge row says alb: false") if @edge.rules.any?
+            @rows.select(&:alb_rule).each do |row|
+              problem(row.path, "names alb_rule #{row.alb_rule}, and the Edge row says alb: false")
+            end
+            @rows.each do |row|
+              next if row.cdn || !%w[cms domain].include?(row.origin) || @edge.upstream(row.origin)
+
+              problem(row.path, "is served from #{row.origin}, which no EdgeOrigin maps, and with alb: false " \
+                                "nothing else reaches it")
+            end
+          end
+
           def check_rule(rule)
             label = "EdgeRule #{rule.rule}"
             member_of(label, "origin", rule.origin, :origin)

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

@@ -19,7 +19,7 @@ module Hecks
       # `EdgePolicy`, `EdgeOrigin` and `EdgeRule`. `docs/site-routes.md` lists their fields. A
       # project that declares none of the four has no edge to project.
       class Edge
-        Setting  = Struct.new(:template, :listener, :secret_header, :secret_value, keyword_init: true)
+        Setting  = Struct.new(:template, :listener, :secret_header, :secret_value, :alb, keyword_init: true)
         Policy   = Struct.new(:cache_class, :origin, :cache, :origin_request, :response_headers, keyword_init: true)
         Upstream = Struct.new(:origin, :id, :target_group, keyword_init: true)
         Rule     = Struct.new(:rule, :priority, :origin, keyword_init: true)
@@ -29,15 +29,15 @@ module Hecks
 
         # The fields each kind of row may carry, with the Ruby class each takes.
         FIELDS = {
-          setting:  { template: String, listener: String, secret_header: String, secret_value: String },
+          setting:  { template: String, listener: String, secret_header: String, secret_value: String, alb: :bool },
           policy:   { cache_class: String, origin: String, cache: String, origin_request: String,
                     response_headers: String },
           upstream: { origin: String, id: String, target_group: String },
           rule:     { rule: String, priority: Integer, origin: String }
         }.freeze
 
-        # The fields a row of each kind must carry.
-        REQUIRED = { setting: [:template], policy: %i[cache_class cache], upstream: %i[origin id],
+        # The fields a row of each kind must carry. The template may instead be named to the tool.
+        REQUIRED = { setting: [], policy: %i[cache_class cache], upstream: %i[origin id],
                      rule: %i[rule priority origin] }.freeze
 
         STRUCTS = { setting: Setting, policy: Policy, upstream: Upstream, rule: Rule }.freeze
@@ -62,15 +62,17 @@ module Hecks
         # @param chapter [Bluebook::Chapter] the chapter that declares the route table
         # @param table [Table] the checked route table
         # @param vocabulary [Hash{Symbol => Array<String>}] the Site chapter's closed sets
+        # @param template [String, nil] the template the caller names, which stands in for the
+        #   `Edge` row's own `template:`
         # @return [Edge, nil] the checked edge, or nil when the chapter declares none
         # @raise [Table::Invalid] when a row is refused or the edge contradicts the routes
-        def self.read(chapter, table:, vocabulary:)
+        def self.read(chapter, table:, vocabulary:, template: nil)
           declared = OBJECTS.transform_values { |name| Table.rows_of(chapter, name) }
           return nil if declared.values.all?(&:empty?)
 
           problems = []
           records = declared.to_h { |kind, members| [kind, build(kind, members, problems)] }
-          new(records, table: table, vocabulary: vocabulary, problems: problems)
+          new(records, table: table, vocabulary: vocabulary, problems: problems, template: template)
         end
 
         # @param kind [Symbol] a key of `OBJECTS`
@@ -86,27 +88,35 @@ module Hecks
             end
             (REQUIRED.fetch(kind) - member.keys).each { |field| problems << "#{label} needs #{field}" }
             typed = member.slice(*FIELDS.fetch(kind).keys).select do |field, value|
-              value.is_a?(FIELDS.fetch(kind).fetch(field)) || (problems << "#{label} has #{field} #{value.inspect}; " \
-                                                                           "#{field} is a #{FIELDS.fetch(kind).fetch(field)}")
+              typed?(value, FIELDS.fetch(kind).fetch(field)) ||
+                (problems << "#{label} has #{field} #{value.inspect}; " \
+                             "#{field} is #{type_name(FIELDS.fetch(kind).fetch(field))}")
             end
             STRUCTS.fetch(kind).new(**typed)
           end
         end
         private_class_method :build
 
+        def self.typed?(value, type) = type == :bool ? [true, false].include?(value) : value.is_a?(type)
+        private_class_method :typed?
+
+        def self.type_name(type) = type == :bool ? "true or false" : "a #{type}"
+        private_class_method :type_name
+
         # @param records [Hash{Symbol => Array<Struct>}] the rows of each kind
         # @param table [Table] the checked route table
         # @param vocabulary [Hash{Symbol => Array<String>}] the closed sets
         # @param problems [Array<String>] the problems already found in reading the rows
+        # @param template [String, nil] the template the caller names, if any
         # @raise [Table::Invalid] naming every problem when there is one
-        def initialize(records, table:, vocabulary:, problems:)
+        def initialize(records, table:, vocabulary:, problems:, template: nil)
           @setting = records.fetch(:setting).first
           @policies = records.fetch(:policy)
           @upstreams = records.fetch(:upstream)
           @rules = records.fetch(:rule)
-          Checks.new(self, table.rows, vocabulary, problems).call
+          Checks.new(self, table.rows, vocabulary, problems, template_named: !template.nil?).call
           if problems.empty?
-            @listener_rules = Rules.new(self, table.rows, problems).call
+            @listener_rules = alb? ? Rules.new(self, table.rows, problems).call : []
             built = Behaviours.new(self, table.rows, problems).call
             @default_behaviour = built.fetch(:default)
             @behaviours = built.fetch(:list)
@@ -116,6 +126,10 @@ module Hecks
           raise Table::Invalid, "the edge is refused:\n#{problems.map { |line| "  - #{line}" }.join("\n")}"
         end
 
+        # @return [Boolean] whether the project has a load balancer, and so listener rules; true
+        #   unless the `Edge` row says `alb: false`
+        def alb? = setting.nil? || setting.alb != false
+
         # @param origin [String] an origin of the Origin set
         # @return [Upstream, nil] its CloudFront origin and target group
         def upstream(origin) = upstreams.find { |candidate| candidate.origin == origin }

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

@@ -77,10 +77,12 @@ module Hecks
         end
 
         def route_fields(row)
-          { path: row.path, kind: row.kind, render: row.render, auth: row.auth, methods: row.verbs,
-            cache: row.cache, origin: row.origin, source: row.source, indexable: row.indexable,
-            switch: blank_to_nil(row.switch), off: row.off, preview: row.preview,
-            label: blank_to_nil(row.label), seo: blank_to_nil(row.seo), redirectTo: row.redirect_to }
+          fields = { path: row.path, kind: row.kind, render: row.render, auth: row.auth, methods: row.verbs,
+                     cache: row.cache, origin: row.origin, source: row.source, indexable: row.indexable,
+                     switch: blank_to_nil(row.switch), off: row.off, preview: row.preview,
+                     label: blank_to_nil(row.label), seo: blank_to_nil(row.seo), redirectTo: row.redirect_to }
+          fields[:seoTitle] = row.seo_title if row.seo_title
+          fields
         end
 
         def switches(rows)
@@ -112,13 +114,16 @@ module Hecks
           TS
         end
 
+        # The navigation arrays hold every entry that has a slot, a switched-off page's too: an
+        # entry of an off page carries its `switch` and `on: false`, and the site drops it while
+        # `pageIsOn(switch)` is false. An entry of a page that is on carries neither.
         def navigation(table)
-          rows = live(table.rows)
+          items = table.rows + table.links
           [nav_const("NAV_DESKTOP", "The desktop navigation: a page with no group is its own entry; a group holds its pages.",
-                     desktop(rows)),
-           nav_const("NAV_MOBILE", "The mobile navigation, in its own order.", mobile(rows)),
-           nav_const("NAV_FOOTER", "The footer columns, left to right, each with its links.", footer(rows)),
-           nav_const("NAV_ADMIN", "The admin navigation: each admin page under its key.", admin(rows))].join("\n\n")
+                     desktop(items)),
+           nav_const("NAV_MOBILE", "The mobile navigation, in its own order.", mobile(items)),
+           nav_const("NAV_FOOTER", "The footer columns, left to right, each with its links.", footer(items)),
+           nav_const("NAV_ADMIN", "The admin navigation: each admin page under its key.", admin(items))].join("\n\n")
         end
 
         def nav_const(name, comment, entries)
@@ -126,32 +131,41 @@ module Hecks
           "// #{comment}\nexport const #{name} = #{body.empty? ? '[]' : "[\n#{body.join("\n")}\n]"} as const;"
         end
 
-        def desktop(rows)
-          items = rows.reject { |row| row.nav_order.nil? }.sort_by { |row| [row.nav_order, row.path] }
+        # One link: a row's or a link's path and label, the fragment a link names, and for a page
+        # that is off the switch that turns it on.
+        def entry(item, **before)
+          link = { **before, path: item.path, label: item.label }
+          link[:fragment] = item.fragment if item.respond_to?(:fragment) && item.fragment
+          link.merge!(switch: item.switch, on: false) if item.off
+          link
+        end
+
+        def order_key(item, order) = [order, item.path, item.respond_to?(:fragment) ? item.fragment.to_s : ""]
+
+        def desktop(items)
           entries = []
-          items.each do |row|
-            item = { path: row.path, label: row.label }
-            group = row.nav_group
-            slot = group && entries.find { |entry| entry[:group] == group }
-            slot ? slot[:items] << item : entries << { group: group, items: [item] }
+          items.reject { |item| item.nav_order.nil? }.sort_by { |item| order_key(item, item.nav_order) }.each do |item|
+            group = item.nav_group
+            slot = group && entries.find { |candidate| candidate[:group] == group }
+            slot ? slot[:items] << entry(item) : entries << { group: group, items: [entry(item)] }
           end
           entries
         end
 
-        def mobile(rows)
-          rows.reject { |row| row.mobile_order.nil? }.sort_by { |row| [row.mobile_order, row.path] }
-              .map { |row| { path: row.path, label: row.label } }
+        def mobile(items)
+          items.reject { |item| item.mobile_order.nil? }.sort_by { |item| order_key(item, item.mobile_order) }
+               .map { |item| item.mobile_heading ? entry(item, heading: item.mobile_heading) : entry(item) }
         end
 
-        def footer(rows)
-          columns = rows.select(&:footer_column).sort_by { |row| [row.footer_order, row.path] }.group_by(&:footer_column)
+        def footer(items)
+          columns = items.select(&:footer_column).sort_by { |item| order_key(item, item.footer_order) }.group_by(&:footer_column)
           columns.sort_by { |name, group| [group.first.footer_order, name] }
-                 .map { |name, group| { column: name, items: group.map { |row| { path: row.path, label: row.label } } } }
+                 .map { |name, group| { column: name, items: group.map { |item| entry(item) } } }
         end
 
-        def admin(rows)
-          rows.select(&:admin_key).sort_by { |row| [row.admin_order, row.admin_key] }
-              .map { |row| { key: row.admin_key, path: row.path, label: row.label } }
+        def admin(items)
+          items.select(&:admin_key).sort_by { |item| [item.admin_order, item.admin_key] }
+               .map { |item| entry(item, key: item.admin_key) }
         end
 
         def search(rows)
@@ -216,13 +230,22 @@ module Hecks
               const source = stripHtml(pattern)
                 .split("/")
                 .map((part) =>
-                  part === "*" ? ".*" : part.startsWith(":") ? "[^/]+" : part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+                  part.startsWith(":")
+                    ? "[^/]+"
+                    : part
+                        .split("*")
+                        .map((piece) => piece.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+                        .join(".*"),
                 )
                 .join("/");
               return new RegExp("^" + source + "$");
             }
 
-            /** Whether a pathname is one a route pattern (`/blog/:slug.html`, `/pay/*`) describes, with or without `.html`. */
+            /**
+             * Whether a pathname is one a route pattern describes, with or without `.html`. A `:name` is one
+             * segment; a `*` is any run of characters, `/` included, wherever it stands, as in a CDN's path
+             * pattern: `/pay/*` matches `/pay/7` and `/admin*` matches `/admin`, `/admin-inbox` and `/admin/x`.
+             */
             export function matchesPath(pattern: string, pathname: string): boolean {
               return toRegExp(pattern).test(stripHtml(pathname));
             }

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

@@ -11,9 +11,10 @@ module Hecks
       # on it: the distribution's cache behaviours and the load balancer's listener rules.
       #
       # The blocks are returned by name, `"behaviors"` and `"listener_rules"`, as text from the
-      # left margin. `Regions` puts each between the markers of the same name in the project's
-      # template, at the markers' indentation. The text is a pure function of the table and the
-      # edge rows.
+      # left margin; a project whose `Edge` row says `alb: false` has no load balancer and gets
+      # `"behaviors"` alone. `Regions` puts each between the markers of the same name in the
+      # project's template, at the markers' indentation. The text is a pure function of the table
+      # and the edge rows.
       module SiteCdn
         extend Projector::Target
 
@@ -25,7 +26,7 @@ module Hecks
         # @param options [Hash{Symbol => Object}] `:registry` (Runtime::Registry) the project booted
         #   into; or `:table` (Table) and `:edge` (Edge), already read
         # @return [Hash{String => String}] each region's name to its text; empty when the chapter
-        #   declares no edge
+        #   declares no edge, and without `"listener_rules"` when the edge has no load balancer
         # @raise [Table::Invalid] when the table or the edge is refused
         def call(bluebook:, options: {})
           registry = options[:registry]
@@ -33,6 +34,8 @@ module Hecks
           edge = options[:edge] || Edge.read(bluebook, table: table, vocabulary: Table.vocabulary(registry))
           return {} unless edge
 
+          return { "behaviors" => behaviors(edge) } unless edge.alb?
+
           { "behaviors" => behaviors(edge), "listener_rules" => listener_rules(edge) }
         end
 

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

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
+require_relative "../edge/pattern"
+
 module Hecks
   module Projections
     module Site
       class Table
         # What no single row can show, and what a row contradicts in itself once its defaults are
-        # filled: a path declared twice, a switch the rows disagree on, an off route that sits in a
-        # navigation, an indexable route that is not public.
+        # filled: a path declared twice, a switch the rows disagree on, a navigation entry that
+        # cannot be linked to, an indexable route that is not public, a public route beneath a
+        # prefix that is not.
         class Checks
           SWITCH_ID = /\A[a-z][a-z0-9_]*\z/
+          FRAGMENT = /\A[A-Za-z0-9][\w:.-]*\z/
           PUBLIC_MENUS = %w[desktop mobile footer].freeze
 
           # The navigation slots a row sits in.
           #
-          # @param row [Row] a row
+          # @param row [Row, Link] a row or link
           # @return [Array<String>] some of `desktop`, `mobile`, `footer`, `admin`
           def self.navigation(row)
             { "desktop" => row.nav_order, "mobile" => row.mobile_order, "footer" => row.footer_column,
@@ -22,8 +26,10 @@ module Hecks
 
           # @param rows [Array<Row>] the table's rows, defaults filled in
           # @param problems [Array<String>] collects each problem found, one line each
-          def initialize(rows, problems)
+          # @param links [Array<Link>] the table's extra navigation entries
+          def initialize(rows, problems, links: [])
             @rows = rows
+            @links = links
             @problems = problems
           end
 
@@ -32,7 +38,8 @@ module Hecks
             check_duplicate_paths
             check_switches
             @rows.each { |row| check_row(row) }
-            check_unique(@rows.filter_map(&:admin_key), "admin key")
+            @links.each { |link| check_link(link) }
+            check_unique((@rows + @links).filter_map(&:admin_key), "admin key")
             check_unique(@rows.map(&:source).grep(/\Aglobal:/), "source")
           end
 
@@ -63,6 +70,7 @@ module Hecks
             check_redirect(row, path)
             check_navigation(row, path)
             check_indexing(row, path)
+            check_beneath_prefix(row, path)
             return unless row.preview == "draft" && row.source == "none"
 
             problem(path, "previews as a draft but has source none; a draft preview needs a global: or collection: source")
@@ -90,13 +98,51 @@ module Hecks
             slots = self.class.navigation(row)
             return if slots.empty?
 
-            problem(path, "is off and sits in the #{slots.join(' and ')} navigation") if row.off
-            problem(path, "sits in the navigation but is a #{row.kind}; only a page does") unless row.kind == "page"
+            unless row.verbs.include?("GET")
+              problem(path, "sits in the navigation but answers #{row.verbs.join(',')}; a link is a GET")
+            end
             problem(path, "sits in the navigation and has a parameter") if path.match?(/[:*]/)
             problem(path, "sits in the navigation and has no label") if row.label.to_s.empty?
+            check_heading(row, path)
             check_menu_audience(row, path, slots)
           end
 
+          def check_heading(item, path)
+            return unless item.mobile_heading
+            return problem(path, "has a mobile_heading but no mobile_order") if item.mobile_order.nil?
+
+            problem(path, "has an empty mobile_heading") if item.mobile_heading.strip.empty?
+          end
+
+          def check_link(link)
+            path = "NavLink #{link.path}"
+            slots = self.class.navigation(link)
+            problem(path, "sits in no navigation; give it nav_order, mobile_order, footer_column or admin_key") if slots.empty?
+            problem(path, "has a parameter; a link is to one page") if link.path.to_s.match?(/[:*]/)
+            problem(path, "has no label") if link.label.to_s.empty?
+            if link.fragment && !link.fragment.match?(FRAGMENT)
+              problem(path, "has fragment #{link.fragment.inspect}; a fragment is an element id, written without #")
+            end
+            check_heading(link, path)
+            check_menu_audience(link, path, slots)
+          end
+
+          # A public route under a prefix that is not public (the sign-in page beside the admin
+          # pages) inherits nothing from the prefix, so the row has to say what it is: its cache
+          # class is declared, not derived from its auth.
+          def check_beneath_prefix(row, path)
+            return if row.auth != "public" || row.explicit_cache || row.path.nil?
+
+            pattern = Edge::Pattern.edge(row.path)
+            prefix = @rows.find do |other|
+              other.auth != "public" && other.path && Edge::Pattern.strictly_covers?(Edge::Pattern.edge(other.path), pattern)
+            end
+            return unless prefix
+
+            problem(path, "is public but sits beneath #{prefix.path}, which is #{prefix.auth}; " \
+                          "name its cache class (cache: \"no_store\" for a sign-in page) to say that is meant")
+          end
+
           def check_menu_audience(row, path, slots)
             public_slots = slots & PUBLIC_MENUS
             if row.auth != "public" && public_slots.any?

data/lib/hecks/projections/site/table/link_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      class Table
+        # One extra navigation entry that points at a route the table declares, optionally at a
+        # fragment of its page. `off` and `switch` are copied from the route it points at.
+        Link = Struct.new(:path, :fragment, :label, :nav_group, :nav_order, :mobile_order, :mobile_heading,
+                          :footer_column, :footer_order, :admin_key, :admin_order, :off, :switch, :auth,
+                          keyword_init: true)
+
+        # Turns a declared `NavLink` member into a `Link`: checks its fields and their types, and
+        # copies the facts it shares with the route it points at.
+        class LinkBuilder
+          # The fields a link may carry, with the Ruby class each takes.
+          FIELDS = { path: String, fragment: String, label: String, nav_group: String, nav_order: Integer,
+                     mobile_order: Integer, mobile_heading: String, footer_column: String,
+                     footer_order: Integer, admin_key: String, admin_order: Integer }.freeze
+
+          # @param rows [Array<Row>] the table's rows, which a link points at
+          # @param problems [Array<String>] collects each problem found, one line each
+          def initialize(rows, problems)
+            @rows = rows
+            @problems = problems
+          end
+
+          # @param member [Hash{Symbol => Object}] the declared fields of one link
+          # @param index [Integer] the link's position, for a message about a link with no path
+          # @return [Link] the link; its problems are in `problems`
+          def call(member, index)
+            label = "NavLink #{member[:path] || "row #{index + 1}"}"
+            fields = checked_fields(member, label)
+            target = @rows.find { |row| row.path == fields[:path] && row.verbs.include?("GET") }
+            problem(label, "points at no route that answers GET; declare the route first") unless target
+            link = Link.new(**fields, off: target ? target.off : false, switch: target ? target.switch : "",
+                                      auth: target ? target.auth : "public")
+            link.footer_order ||= 0 if link.footer_column
+            link.admin_order ||= 0 if link.admin_key
+            link
+          end
+
+          private
+
+          def checked_fields(member, label)
+            member.each_key do |key|
+              problem(label, "has no field #{key}; fields are #{FIELDS.keys.join(', ')}") unless FIELDS.key?(key)
+            end
+            known = member.slice(*FIELDS.keys)
+            known.each do |key, value|
+              next if value.is_a?(FIELDS.fetch(key))
+
+              problem(label, "has #{key} #{value.inspect}; #{key} is a #{FIELDS.fetch(key)}")
+            end
+            problem(label, "needs a path") unless known[:path]
+            known
+          end
+
+          def problem(label, text) = @problems << "#{label} #{text}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/table/row_builder.rb

@@ -8,7 +8,8 @@ module Hecks
         Row = Struct.new(:path, :kind, :render, :auth, :verbs, :cache, :origin, :source,
                          :indexable, :switch, :off, :preview, :label, :seo, :redirect_to, :aliases,
                          :nav_group, :nav_order, :mobile_order, :footer_column, :footer_order,
-                         :admin_key, :admin_order, :compress, :alb_rule, :cdn, keyword_init: true)
+                         :admin_key, :admin_order, :compress, :alb_rule, :cdn,
+                         :seo_title, :edge_verbs, :mobile_heading, :explicit_cache, keyword_init: true)
 
         # Turns a declared member into a `Row`: checks its fields and their types, fills the
         # defaults, and checks each closed-set value against the Site chapter's vocabulary.
@@ -19,7 +20,8 @@ module Hecks
                      off: :bool, preview: String, label: String, seo: String, redirect_to: String,
                      aliases: String, nav_group: String, nav_order: Integer, mobile_order: Integer,
                      footer_column: String, footer_order: Integer, admin_key: String,
-                     admin_order: Integer, compress: :bool, alb_rule: String, cdn: :bool }.freeze
+                     admin_order: Integer, compress: :bool, alb_rule: String, cdn: :bool,
+                     seo_title: String, edge_methods: String, mobile_heading: String }.freeze
 
           # The value objects of the Site chapter's `Route` aggregate whose members are the closed
           # sets, by the row field each constrains.
@@ -50,7 +52,9 @@ module Hecks
             label = path || label
             check_source(label, source)
             verbs = fields.delete(:methods)
-            row = Row.new(**fields, verbs: verbs, path: path, source: source,
+            edge_verbs = fields.delete(:edge_methods)
+            row = Row.new(**fields, verbs: verbs, edge_verbs: edge_verbs, path: path, source: source,
+                                    explicit_cache: !fields[:cache].nil?,
                                     kind: fields[:kind] || default_kind(source), auth: fields[:auth] || "public",
                                     origin: fields[:origin] || default_origin(source))
             fill_defaults(row)
@@ -94,6 +98,7 @@ module Hecks
             row.cdn = true if row.cdn.nil?
             row.render ||= row.kind == "page" ? "prerender" : "ssr"
             row.verbs = list(row.verbs || (row.source.start_with?("command:") ? "POST" : "GET"))
+            row.edge_verbs = row.edge_verbs.nil? ? row.verbs : list(row.edge_verbs)
             row.aliases = list(row.aliases)
             row.cache ||= default_cache(row)
             row.indexable = indexable_by_default?(row) if row.indexable.nil?
@@ -123,11 +128,21 @@ module Hecks
 
               problem(label, "has #{field} #{row[field].inspect}; #{field} is one of #{@vocabulary.fetch(field).join(', ')}")
             end
-            row.verbs.each do |verb|
-              next if @vocabulary.fetch(:http_method).include?(verb)
+            check_verbs(row, label)
+          end
+
+          def check_verbs(row, label)
+            { "method" => row.verbs, "edge method" => row.edge_verbs }.each do |what, verbs|
+              verbs.each do |verb|
+                next if @vocabulary.fetch(:http_method).include?(verb)
 
-              problem(label, "has method #{verb.inspect}; methods are #{@vocabulary.fetch(:http_method).join(', ')}")
+                problem(label, "has #{what} #{verb.inspect}; methods are #{@vocabulary.fetch(:http_method).join(', ')}")
+              end
             end
+            return if (row.verbs - row.edge_verbs).empty?
+
+            problem(label, "has edge_methods #{row.edge_verbs.join(',')}, which leave out its methods " \
+                           "#{(row.verbs - row.edge_verbs).join(',')}; the edge must allow every verb the route answers")
           end
 
           def check_source(label, source)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "table/row_builder"
+require_relative "table/link_builder"
 require_relative "table/checks"
 
 module Hecks
@@ -21,9 +22,15 @@ module Hecks
         # The name of the value object a client declares its rows in.
         ROW_OBJECT = "Route"
 
+        # The name of the value object a client declares its extra navigation entries in.
+        LINK_OBJECT = "NavLink"
+
         # @return [Array<Row>] the rows, in the order the client declared them
         attr_reader :rows
 
+        # @return [Array<Link>] the extra navigation entries, in the order the client declared them
+        attr_reader :links
+
         # Finds the one chapter of a project that declares the route table.
         #
         # @param registry [Runtime::Registry] the registry the project booted into
@@ -47,7 +54,8 @@ module Hecks
         # @return [Table] the checked table
         # @raise [Invalid] when the Site chapter is not attached or a row is refused
         def self.read(chapter, registry:)
-          new(rows_of(chapter), vocabulary: vocabulary(registry), registry: registry)
+          new(rows_of(chapter), vocabulary: vocabulary(registry), registry: registry,
+                                links: rows_of(chapter, LINK_OBJECT))
         end
 
         # @param registry [Runtime::Registry] a registry holding the Site chapter
@@ -76,20 +84,23 @@ module Hecks
         # @param vocabulary [Hash{Symbol => Array<String>}] the closed sets
         # @param registry [Runtime::Registry, nil] where a `command:` or `query:` source is looked
         #   up; nil skips that check
+        # @param links [Array<Hash{Symbol => Object}>] the declared `NavLink` rows
         # @raise [Invalid] when a row is refused
-        def initialize(members, vocabulary:, registry: nil)
+        def initialize(members, vocabulary:, registry: nil, links: [])
           problems = []
           builder = RowBuilder.new(vocabulary: vocabulary, registry: registry, problems: problems)
           @rows = members.each_with_index.map { |member, index| builder.call(member, index) }
-          Checks.new(@rows, problems).call
+          link_builder = LinkBuilder.new(@rows, problems)
+          @links = links.each_with_index.map { |member, index| link_builder.call(member, index) }
+          Checks.new(@rows, problems, links: @links).call
           return if problems.empty?
 
           raise Invalid, "the route table is refused:\n#{problems.map { |line| "  - #{line}" }.join("\n")}"
         end
 
-        # The navigation slots a row sits in.
+        # The navigation slots a row or link sits in.
         #
-        # @param row [Row] a row
+        # @param row [Row, Link] a row or link
         # @return [Array<String>] some of `desktop`, `mobile`, `footer`, `admin`
         def navigation(row) = Checks.navigation(row)
       end