//go:build fiestaseed

// The Fiesta prose exporter for internal/designsystem. hack/seed/run-prose.sh
// copies this file into a scratch rastrillo worktree at the seed commit
// and runs TestFiestaProse there, so it reads the gallery's English
// where it is written: the family tables, the idiom blurbs, the shell
// views, the format and screen docs, and the two idiom rules. It
// reads, under FIESTA_SEED_OUT, the committed examples/examples.json
// and hack/seed/sources.json, and writes two files there:
//
//   - examples/prose.json, every explanation the gallery shows, keyed
//     by family, example and state, with a screen's warning callout as
//     a title and body of its own beside the state's note;
//   - hack/seed/prose-review.json, the strings that could not carry
//     verbatim, each with the rastrillo text, the reason, and the
//     approved replacement once there is one.
//
// A string joins the review queue when it mentions something Fiesta
// does not have (a Go template, a partial, a server, a cookie,
// rastrillo itself) or when, read against Fiesta's HTML, it is not
// true. The mechanical part is proseReason, over proseWords,
// proseFields and proseScripts; the rest is a judgement, written down
// in proseUntrue with its reason. A queued
// string's slot in prose.json is empty until approvedProse carries
// its replacement, so a reseed reproduces the approved text and never
// the rastrillo one.
package designsystem

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"sort"
	"strings"
	"testing"
)

// The manifest's shape and sources.json's, mirrored from Fiesta. The
// tags are the contract; this side cannot import the other.
type proseManifest struct {
	Examples []proseEntry `json:"examples"`
}

type proseEntry struct {
	Name   string       `json:"name"`
	Family string       `json:"family"`
	Kind   string       `json:"kind"`
	States []proseState `json:"states"`
}

type proseState struct {
	ID string `json:"id"`
}

type proseSource struct {
	Kind   string `json:"kind"`
	Source string `json:"source"`
	State  int    `json:"state"`
}

// prose.json's shape, mirrored from Fiesta's gallery package.
type proseFile struct {
	Families map[string]proseFamily  `json:"families"`
	Examples map[string]proseExample `json:"examples"`
	Pages    prosePages              `json:"pages"`
}

type proseFamily struct {
	Title string `json:"title"`
	Blurb string `json:"blurb"`
}

type proseExample struct {
	Blurb    string                  `json:"blurb"`
	States   map[string]string       `json:"states,omitempty"`
	Warnings map[string]proseWarning `json:"warnings,omitempty"`
}

// proseWarning is the callout after one state's note: a screen's
// WarningTitle and WarningBody, each a slot of its own.
type proseWarning struct {
	Title string `json:"title"`
	Body  string `json:"body"`
}

type prosePages struct {
	Idioms []proseRule `json:"idioms"`
}

type proseRule struct {
	Idiom string `json:"idiom"`
	Title string `json:"title"`
	Body  string `json:"body"`
}

// proseReview is one line of hack/seed/prose-review.json: the slot,
// what rastrillo says there, why that cannot carry, and what Fiesta
// says instead once copy review has approved it.
type proseReview struct {
	ID     string `json:"id"`
	Seed   string `json:"seed"`
	Reason string `json:"reason"`
	Text   string `json:"text"`
}

// proseWords are the words that put a string in the review queue:
// each names something Fiesta's HTML does not have.
var proseWords = []struct {
	what string
	re   *regexp.Regexp
}{
	{"Go", regexp.MustCompile(`\bGo\b`)},
	{"a template", regexp.MustCompile(`(?i)\btemplates?\b`)},
	{"{{", regexp.MustCompile(`\{\{`)},
	{"ui.", regexp.MustCompile(`\bui\.`)},
	{"rastrillo", regexp.MustCompile(`(?i)rastrillo`)},
	{"a partial", regexp.MustCompile(`(?i)\bpartials?\b`)},
	{"/_theme", regexp.MustCompile(`/_theme`)},
	{"a cookie", regexp.MustCompile(`(?i)\bcookies?\b`)},
	{"a server", regexp.MustCompile(`(?i)\bservers?\b`)},
	{".go", regexp.MustCompile(`\.go\b`)},
}

// proseFields are the capitalised field names a note uses as a
// template argument. Only the names no English sentence here starts
// with: Label, Name, Title, Select, Page and Path are judged by eye
// instead, in proseUntrue.
var proseFields = []string{
	"Lead", "Exact", "Primary", "Hidden", "ClearHref", "Placeholder", "Fit", "Desc",
	"SelectName", "CancelLabel", "Alert", "Tone", "Options", "Plain", "RevokePath",
	"RevokeAgentPath", "RevokeAllPath", "Created", "Currency", "Render", "PageData",
}

// proseScripts are the script files a string may name: the ones
// Fiesta ships under that name. Any other .js in a string is a
// script Fiesta does not have.
var proseScripts = map[string]bool{
	"anchor.js": true, "busy.js": true, "calendar.js": true, "copy.js": true, "datetime.js": true,
	"fiesta.js": true, "light.js": true, "select.js": true, "shell.js": true,
}

var proseScript = regexp.MustCompile(`\b[a-z][a-z0-9-]*\.js\b`)

// proseUntrue is the judgement: strings that pass the word list and
// are still not true of Fiesta's HTML, by slot, with the reason.
var proseUntrue = map[string]string{
	"examples.pagination.states.first-page-default-accessible-name":             "Label is the template's argument, and the catalog is rastrillo's",
	"examples.field-text.blurb":                                                 "Name is the template's argument; in the HTML the ids are written out",
	"examples.field-daterange.blurb":                                            "the derived ids are the template's; in the HTML they are written out",
	"examples.notice.blurb":                                                     "describes the template's argument, which the HTML does not have",
	"examples.form-error.blurb":                                                 "describes the template's argument, which the HTML does not have",
	"examples.field-select.blurb":                                               "the ten-option rule is the template's; in the HTML the data-rst-select attribute is what arms select.js",
	"examples.job-status.blurb":                                                 "Fiesta ships no script that polls, and nothing here emits the attribute",
	"examples.job-status.states.running":                                        "Fiesta ships no script that polls, so this state asks the network for nothing",
	"examples.layout-column.blurb":                                              "Fiesta scaffolds nothing",
	"examples.format-money.blurb":                                               "money is a template function",
	"examples.field-date.states.enhanced-input-type-tomorrow-or-in-3-weeks":     "the page has no catalog; the words are on the attribute, and i18n/<lang>.json has the other languages",
	"examples.field-datetime.states.enhanced-input-type-tomorrow-or-in-3-weeks": "the page has no catalog; the words are on the attribute, and i18n/<lang>.json has the other languages",
	"examples.error-page.states.anything-else-the-generic-pair":                 "the framework catalog is rastrillo's; Fiesta's example is six documents",
}

// proseAlways are the slots that are queued whatever rastrillo says
// there, with the reason. The standalone scheme menu is the one state
// Fiesta wrote itself: its page remembers the choice, and rastrillo's
// note describes a server. The sign-in example has no sentence about
// the set of screens, because screenDocs() explains each one and not
// the whole. Two of its screens' notes describe what the app behind
// the screen does, which Fiesta's static example cannot: one has a
// hard-coded address and forms that post, the other a link to # and
// nothing that moves on.
var proseAlways = map[string]string{
	"examples.scheme-menu.states.standalone":          "rastrillo's note describes a server; this state's page remembers the choice itself",
	"examples.signin.blurb":                           "no rastrillo source: screenDocs() explains each screen and not the set, so this one sentence is new",
	"examples.signin.states.coming-back-with-keymail": "claims behaviour the static example lacks: remembering and checking the address",
	"examples.signin.states.on-the-way-to-keymail":    "claims behaviour the static example lacks: moving on by itself",
}

// approvedProse is the review's answer, by slot. Nothing joins this
// map without copy review; a reseed writes these and never the
// rastrillo text they replace.
var approvedProse = map[string]string{
	"examples.actor.states.an-agent-acting-for-a-person":                        "The agent's name, then the person it acted for. When the app itself did something, show nothing.",
	"examples.api-tokens.blurb":                                                 "The API token page: the one-time reveal, the create form, the list and the revoke buttons.",
	"examples.api-tokens.states.four-tokens-two-of-them-live":                   "The revoke forms post to /tokens/revoke, /tokens/revoke-agent and /tokens/revoke-all, under the page's own path. Point them wherever your app handles them.",
	"examples.api-tokens.states.just-created-the-secret-shown-once":             "Show this in the response to the create form itself, and do not redirect it: the secret is in that response and nowhere else.",
	"examples.callout.states.negative-announced-as-an-alert":                    "role=\"alert\" makes a screen reader announce it as soon as it appears. Keep it for messages that cannot wait.",
	"examples.choice-field.blurb":                                               "Option cards: the preferred radio or checkbox group. The title stays short; the description explains.",
	"examples.confirm-form.states.ordinary-default-cancel-wording":              "The cancel link says Cancel, which is the usual wording. Change it when the form's own words are clearer.",
	"examples.error-page.states.anything-else-the-generic-pair":                 "Any status that has no wording of its own gets this generic pair: a title that says something is wrong and a body that says to try again.",
	"examples.field-date.blurb":                                                 "A native date input, plus the natural-language combobox datetime.js adds when the input carries data-rst-date. Type \"tomorrow\" into it.",
	"examples.field-date.states.enhanced-input-type-tomorrow-or-in-3-weeks":     "The words it parses are on data-rst-date-words, here in the page's language. i18n/<lang>.json has them in twelve languages, so the field can parse whichever language the page is in.",
	"examples.field-daterange.blurb":                                            "A start and an end as one labelled fieldset. Give every input its own name and id.",
	"examples.field-daterange.states.date-and-time-seeded":                      "Commit the start with the end still empty and datetime.js fills the end in an hour later. Nothing in the markup does that; the script does.",
	"examples.field-datetime.states.enhanced-input-type-tomorrow-or-in-3-weeks": "The words it parses are on data-rst-date-words, here in the page's language. i18n/<lang>.json has them in twelve languages, so the field can parse whichever language the page is in.",
	"examples.field-money.blurb":                                                "A money amount in one currency. The currency code shows beside the label and is sent with the form, so a currency that changed while someone was typing is caught on save.",
	"examples.field-select.blurb":                                               "The field envelope around a native select. Add data-rst-select and select.js turns it into a filterable combobox; the native select is still what the form submits. Worth it from about ten options.",
	"examples.field-select.states.hand-written-with-optgroups":                  "Grouped choices are optgroups you write yourself. select.js keeps the groups rather than dropping them; a select can also refuse the enhancement outright with data-rst-select=\"false\".",
	"examples.field-select.states.twelve-options-the-filterable-combobox":       "Add data-rst-select from about ten options. Below that, leave it off: search over a handful of items is furniture, not help.",
	"examples.field-text.blurb":                                                 "One labelled text input. The required marker's star is aria-hidden; the input's required attribute is the programmatic signal.",
	"examples.field-text.states.the-headline-field":                             "Give the main field of a form, a title or a name, rst-input=\"primary\" for a more prominent input.",
	"examples.field-url.blurb":                                                  "A web address field that accepts example.com with or without https://. Whatever reads the form has to add the scheme and check the address.",
	"examples.form-error.blurb":                                                 "A form's summary error line, role=\"alert\". Leave it out when there is no error.",
	"examples.form-foot.states.idle-the-button-before-anything-happens":         "A button that CHANGES something gets a loading state; a button that only reveals something, e.g. a disclosure, a dropdown, a tab, does not. busy.js applies that rule to every submit button in every form, with nothing to opt into.",
	"examples.form-foot.states.working-what-busy-js-writes-on-the-way-out":      "Only the button that was clicked: every other submit button in the form keeps its name and its value, and the form itself is guarded against a second submit. data-busy=\"false\" opts out, on the form or on one button; data-busy-label replaces the text. With scripts off none of this happens and the form submits exactly as it always did, so a second submit is still your app's job to catch.",
	"examples.form-layout.blurb":                                                "The attributes that give a form its rhythm and its save bar. They wrap a run of fields you compose yourself.",
	"examples.format-dates.blurb":                                               "Put a date in a <time> tag, with a version of the date a computer can read. Write the date itself however your readers expect to see it. Fiesta will not format it for you.",
	"examples.format-money.blurb":                                               "Store each amount as a whole number of the currency's smallest unit, such as cents, with its currency code beside it. Write it the way the reader's language does. The currency always comes from your data, never from the reader.",
	"examples.job-status.blurb":                                                 "A background job's progress: a spinner, a line of text and a bar. The data-poll attributes say where a page could fetch a fresh copy and how often. Fiesta ships no script that does that, so wire it up yourself, and leave the attributes off once the job is done.",
	"examples.job-status.states.running":                                        "The data-poll attributes are where a script would fetch a fresh copy from, and how often. Nothing in Fiesta does, so on this page it stays running.",
	"examples.layout-column.blurb":                                              "The plain centred page an app starts on: a skip link, a title, and the content column.",
	"examples.list-bar-search.states.empty-accessible-name-from-the-catalog":    "No placeholder. The input's accessible name is its aria-label, which an app writes in the page's language.",
	"examples.list-bar-search.states.with-a-query":                              "The ✕ is a link to the same screen with the query dropped. The status filter rides in a hidden input and survives it.",
	"examples.list-bar-search.states.with-a-query-on-page-4":                    "The page number rides in a hidden input, so a new search would carry page=4 into a result set that no longer has four pages. The ✕ link drops it: point it at the list's first page.",
	"examples.locale-menu.blurb":                                                "The language switcher: a details menu of one-field POST forms, so the choice is sent to your app and the reader stays on the same path.",
	"examples.locale-menu.states.twelve-languages-current-highlighted":          "Each language is a one-field form, so choosing one is a POST your app answers. A static site can use a menu of plain links instead.",
	"examples.media-grid.states.screenshots-a-logo-and-a-banner":                "Give a logo or a banner rst-media-frame=\"contain\". A screenshot keeps the default and shows its top. A tile with no description says \"No description\".",
	"examples.media-grid.states.select-mode-one-tile-selected":                  "Wrap the grid and a bulk-bar in one form. Each tile's checkbox posts its value under the name \"id\"; rename it if your app expects another. Inside the form, menu items must be links.",
	"examples.meter.states.over-budget":                                         "Over budget, the bar is full and the number says by how much: write value=\"100\" and leave the real figure to the text.",
	"examples.notice.blurb":                                                     "A one-line confirmation after a redirect: one sentence in a paragraph with role=\"status\". Leave it out when there is nothing to say.",
	"examples.pagination.states.first-page-default-accessible-name":             "The nav's aria-label is the plain word Pagination. Say which list it pages when a page has more than one.",
	"examples.scheme-menu.blurb":                                                "The colour-scheme switch: a details menu of one-field POST forms for Light, Dark and System. Posted, the choice goes to your app; standalone, fiesta.js remembers it in the browser.",
	"examples.scheme-menu.states.standalone":                                    "No app behind it: the forms have no action, and with data-rst-scheme-store=\"local\" on the <html> element fiesta.js remembers the choice in the browser. The gallery's own header uses this one.",
	"examples.scheme-menu.states.three-choices-dark-current":                    "Each scheme is a one-field form, so choosing one is a POST your app answers, and the page comes back with the chosen scheme marked current.",
	"examples.seg-tabs.blurb":                                                   "A segmented control of plain links. The current tab is aria-current on a link.",
	"examples.shell-topbar.blurb":                                               "The topbar shell's own chrome, as markup. The whole page it belongs to is layout-topbar, under Shells.",
	"examples.signin.blurb":                                                     "The sign-in screen in every state it passes through: asking for an address, coming back, after the link is sent, when something went wrong, and the other ways in.",
	"examples.signin.states.asking-for-an-address":                              "One field and one button. Nothing to remember and nothing to steal.",
	"examples.signin.states.coming-back-with-keymail":                           "For someone coming back: the address they used last time is on the button, so one tap sends it. Remembering that address, and checking it again, is your app's job.",
	"examples.signin.states.on-the-way-to-keymail":                              "A holding page while someone is sent on to sign in. Your app moves the page on by itself; the link is there in case it does not.",
	"examples.signin.warnings.email-and-password.body":                          "People reuse them, they leak, and you inherit the job of storing them safely. Use a link in your email plus a passkey, or passkeys on their own. The markup is here because some products still need it.",
	"examples.stat.states.a-shortened-number":                                   "Showing 4.1k instead of 4120? Put the full number in a <data> tag's value. Screen readers only read what is on screen, so keep anything a person needs in the number itself.",
	"examples.stat.states.the-big-number":                                       "Give one stat in the row rst-stat=\"lead\" to make it big. It is the same component, just larger.",
	"examples.status-pill.states.neutral":                                       "Neutral is the default tone, so rst-tone=\"neutral\" could be left off.",
	"families.choices-and-actions.blurb":                                        "The controls that pick from options, and the rows that end a form. Each one sits in a padded rst-box, because that is the card a form goes in.",
	"families.form.blurb":                                                       "The fields a person types into, in the states a real form puts them in. Each one sits in a padded rst-box, because that is the card a form goes in.",
	"families.screens.blurb":                                                    "Whole screens built from the components. Start your own from one of them.",
	"families.shells.blurb":                                                     "The page frames an app is built in: a column, a top bar, a sidebar, a console and a stage. Each opens full width.",
}

type proser struct {
	t       *testing.T
	out     string
	m       proseManifest
	sources map[string]proseSource
	file    proseFile
	queue   []proseReview
	carried []proseReview
}

func TestFiestaProse(t *testing.T) {
	out := os.Getenv("FIESTA_SEED_OUT")
	if out == "" {
		t.Skip("FIESTA_SEED_OUT is unset; this test is the Fiesta prose exporter, run by hack/seed/run-prose.sh")
	}
	p := &proser{t: t, out: out, sources: map[string]proseSource{}}
	p.read("examples/examples.json", &p.m)
	p.read("hack/seed/sources.json", &p.sources)
	p.file = proseFile{Families: map[string]proseFamily{}, Examples: map[string]proseExample{}}
	p.families()
	p.examples()
	p.rules()
	p.check()
	p.write("examples/prose.json", p.file)
	sort.Slice(p.queue, func(i, j int) bool { return p.queue[i].ID < p.queue[j].ID })
	p.write("hack/seed/prose-review.json", p.queue)
	// The inventory, for the run's log: every carried string with its
	// slot, then every queued one with its reason.
	sort.Slice(p.carried, func(i, j int) bool { return p.carried[i].ID < p.carried[j].ID })
	fmt.Printf("fiesta prose: %d strings carried, %d queued for review\n", len(p.carried), len(p.queue))
	for _, c := range p.carried {
		fmt.Printf("carried: %s: %s\n", c.ID, c.Seed)
	}
	for _, q := range p.queue {
		fmt.Printf("review: %s: %s\n", q.ID, q.Reason)
	}
}

func (p *proser) read(rel string, v any) {
	p.t.Helper()
	b, err := os.ReadFile(filepath.Join(p.out, filepath.FromSlash(rel)))
	if err != nil {
		p.t.Fatal(err)
	}
	if err := json.Unmarshal(b, v); err != nil {
		p.t.Fatalf("%s: %v", rel, err)
	}
}

func (p *proser) write(rel string, v any) {
	p.t.Helper()
	b, err := json.MarshalIndent(v, "", "  ")
	if err != nil {
		p.t.Fatal(err)
	}
	path := filepath.Join(p.out, filepath.FromSlash(rel))
	if err := os.WriteFile(path, append(b, '\n'), 0o644); err != nil {
		p.t.Fatal(err)
	}
}

// proseReason is the mechanical part of the review: why text cannot
// carry, or "" when the word list, the template arguments and the
// script names all pass. internal/gallery/prose_rule_test.go holds
// the same text and applies it to prose.json, and a test there fails
// when the two drift.
func proseReason(text string) string {
	for _, w := range proseWords {
		if w.re.MatchString(text) {
			return "mentions " + w.what
		}
	}
	for _, f := range proseFields {
		if regexp.MustCompile(`\b` + f + `\b`).MatchString(text) {
			return "uses the template argument " + f
		}
	}
	for _, s := range proseScript.FindAllString(text, -1) {
		if !proseScripts[s] {
			return "names " + s + ", which Fiesta does not ship"
		}
	}
	return ""
}

// reason says why text cannot carry, or "" when it can: the
// mechanical rule, then the judgement.
func (p *proser) reason(id, text string) string {
	if why := proseReason(text); why != "" {
		return why
	}
	return proseUntrue[id]
}

// slot decides one string: carried verbatim, or queued with its
// reason and the approved text if there is one. It returns what
// prose.json holds at that slot.
func (p *proser) slot(id, seed string) string {
	p.t.Helper()
	if seed == "" && proseAlways[id] == "" {
		return ""
	}
	why := proseAlways[id]
	if why == "" {
		why = p.reason(id, seed)
	}
	if why == "" {
		p.carried = append(p.carried, proseReview{ID: id, Seed: seed})
		return seed
	}
	text := approvedProse[id]
	p.queue = append(p.queue, proseReview{ID: id, Seed: seed, Reason: why, Text: text})
	return text
}

// families carries the six sample families' Title and Blurb, and for
// Fiesta's other four families the page kind that holds them in
// rastrillo's gallery. Getting started, tokens and icons are pages
// Fiesta's README, landing page and gallery do themselves.
func (p *proser) families() {
	seen := map[string]bool{}
	for _, e := range p.m.Examples {
		seen[e.Family] = true
	}
	kinds := map[string]pageKind{}
	for _, pk := range pageKinds() {
		kinds[pk.Kind] = pk
	}
	for key := range seen {
		pk, ok := kinds[key]
		if !ok {
			p.t.Fatalf("family %s is no page kind at the seed", key)
		}
		p.file.Families[key] = proseFamily{
			Title: p.slot("families."+key+".title", pk.Title),
			Blurb: p.slot("families."+key+".blurb", pk.Blurb),
		}
	}
}

// examples walks the manifest in its own order and fills each
// example's blurb and each state's note from the source sources.json
// names for it. A rastrillo state several Fiesta states came from
// gives its note to the first of them.
func (p *proser) examples() {
	partials := map[string]partialDoc{}
	for _, fam := range families() {
		for _, doc := range fam.Partials {
			partials[doc.Name] = doc
		}
	}
	shells := map[string]string{}
	for _, sv := range shellViews("", "day", "en") {
		shells[sv.Name] = sv.Blurb
	}
	formats := formatDocs()
	screens := screenDocs()
	noted := map[string]bool{}
	for _, e := range p.m.Examples {
		ex := proseExample{States: map[string]string{}}
		blurbID := "examples." + e.Name + ".blurb"
		for i, st := range e.States {
			key := e.Name + "/" + st.ID
			src, ok := p.sources[key]
			if !ok {
				p.t.Fatalf("sources.json has no %s", key)
			}
			noteID := "examples." + e.Name + ".states." + st.ID
			warnID := "examples." + e.Name + ".warnings." + st.ID
			var blurb, note, warnTitle, warnBody string
			switch src.Kind {
			case "partial":
				doc, ok := partials[src.Source]
				if !ok || src.State >= len(doc.States) {
					p.t.Fatalf("%s: no partial %s state %d", key, src.Source, src.State)
				}
				blurb, note = doc.Blurb, doc.States[src.State].Note
			case "idiom":
				blurb = idiomBlurbs[src.Source]
				if e.Kind != "idiom" {
					// The idiom rides on a component (dropdown): the
					// component's blurb is the example's, and the
					// idiom's is the note on its state.
					blurb, note = "", idiomBlurbs[src.Source]
				}
			case "shell":
				blurb = shells[src.Source]
			case "format":
				if src.State >= len(formats) || formats[src.State].Key != src.Source {
					p.t.Fatalf("%s: format %d is not %s", key, src.State, src.Source)
				}
				blurb = formats[src.State].Body
			case "screen":
				if src.State >= len(screens) || screens[src.State].Key != src.Source {
					p.t.Fatalf("%s: screen %d is not %s", key, src.State, src.Source)
				}
				// The screen's blurb is the state's note; its warning,
				// where it has one, is the callout after the note, with
				// the title and body each a slot of its own.
				doc := screens[src.State]
				note = doc.Blurb
				warnTitle, warnBody = doc.WarningTitle, doc.WarningBody
			default:
				p.t.Fatalf("%s: unknown source kind %q", key, src.Kind)
			}
			// The example's blurb is its first state's source's: every
			// state of an example shares one source, except the idiom
			// a component carries, which is never first.
			if i == 0 {
				ex.Blurb = p.slot(blurbID, blurb)
			}
			origin := fmt.Sprintf("%s/%s/%d", src.Kind, src.Source, src.State)
			if noted[origin] && proseAlways[noteID] == "" {
				note, warnTitle, warnBody = "", "", ""
			}
			if note != "" {
				noted[origin] = true
			}
			if v := p.slot(noteID, note); v != "" {
				ex.States[st.ID] = v
			} else if _, queued := proseAlways[noteID]; queued {
				ex.States[st.ID] = ""
			}
			if warnBody != "" {
				if ex.Warnings == nil {
					ex.Warnings = map[string]proseWarning{}
				}
				ex.Warnings[st.ID] = proseWarning{
					Title: p.slot(warnID+".title", warnTitle),
					Body:  p.slot(warnID+".body", warnBody),
				}
			}
		}
		if len(ex.States) == 0 {
			ex.States = nil
		}
		p.file.Examples[e.Name] = ex
	}
}

// rules carries the two idiom rules, in idiom order.
func (p *proser) rules() {
	names := make([]string, 0, len(idiomRules))
	for name := range idiomRules {
		names = append(names, name)
	}
	sort.Strings(names)
	for _, name := range names {
		rule := idiomRules[name]
		p.file.Pages.Idioms = append(p.file.Pages.Idioms, proseRule{
			Idiom: name,
			Title: p.slot("pages.idioms."+name+".title", rule.Title),
			Body:  p.slot("pages.idioms."+name+".body", rule.Body),
		})
	}
}

// check refuses an approved or judged slot that names nothing in the
// manifest, so a typo in one of the tables above fails the run
// rather than writing a string no page shows.
func (p *proser) check() {
	known := map[string]bool{}
	for key := range p.file.Families {
		known["families."+key+".title"] = true
		known["families."+key+".blurb"] = true
	}
	for _, e := range p.m.Examples {
		known["examples."+e.Name+".blurb"] = true
		for _, st := range e.States {
			known["examples."+e.Name+".states."+st.ID] = true
			known["examples."+e.Name+".warnings."+st.ID+".title"] = true
			known["examples."+e.Name+".warnings."+st.ID+".body"] = true
		}
	}
	for name := range idiomRules {
		known["pages.idioms."+name+".title"] = true
		known["pages.idioms."+name+".body"] = true
	}
	for _, table := range []map[string]string{approvedProse, proseUntrue, proseAlways} {
		for id := range table {
			if !known[id] {
				p.t.Errorf("%s names no slot in the manifest", id)
			}
		}
	}
	queued := map[string]bool{}
	for _, q := range p.queue {
		queued[q.ID] = true
	}
	for id := range approvedProse {
		if !queued[id] {
			p.t.Errorf("%s is approved but was never queued; the rastrillo text there carries as it is", id)
		}
	}
	if strings.TrimSpace(p.file.Families["primitives"].Title) == "" {
		p.t.Error("the primitives family has no title")
	}
}