@heroiclands/package-build 23.9.0 → 23.11.0

package/docs/design.md

@@ -21,6 +21,24 @@ An Address identifies a subject by package, system, type, and shortcode. It is i
 
 The content index uses JSON Lines. A record can retain the note's full frontmatter, anchors, and outgoing links, and streams without loading one giant JSON array. It is derived, disposable, and stable for a fixed source tree and toolchain version. SQL queries and editor navigation read that index rather than guessing from filenames.
 
+## Reference presentation and access
+
+An indexed subject has one ordinary wikilink syntax regardless of its audience.
+The renderer derives spoiler presentation from the actual destination, so an
+author does not duplicate a privacy declaration on every mention. The `.show`
+override reveals a particular reference without changing the destination's
+audience. A separate inline `.secret` span marks authored text as a spoiler.
+
+Concealment and access remain separate decisions. Public site and book builds
+omit GM-only notes; a reference to an omitted destination carries no unusable
+link. Foundry's private packs and page permissions govern destination access.
+Web inline spoilers use a separate show/hide control beside their content, so
+a revealed link is independently usable. Foundry and book inline spoilers are
+visible labelled text; an inline Foundry span has no native secret-section
+permission behavior. A spoiler in published HTML remains readable in the source. See the
+[authoring contract](authoring/links-and-markup.md#references-to-secret-subjects)
+for syntax and surface presentation.
+
 ## Build boundaries
 
 The content pass reads `assets/content/` and addressable assets. It emits the content index, page source, and Foundry documents. Site rendering and book typesetting consume those outputs; their layout decisions do not become fields of a Foundry DataModel. Packaging stages only the files a Foundry manifest declares. The build checks emitted fields against the target system schema because Foundry can otherwise discard an unknown field without an error.

package/docs/guides/book.md

@@ -522,6 +522,13 @@ Anchors on headings are scoped to their entries, so two entries can use the
 same heading anchor. The build reports an unresolved destination while
 keeping the source available for inspection.
 
+A reference to a GM-only note or secret heading prints with secret styling
+and a **Secret:** label. GM-only notes remain omitted, and references to them
+print as text without a link. `.show` removes the automatic spoiler presentation
+of that reference, without adding the destination to the book. An authored
+`[text]{.secret}` uses the same static inline styling. Printed text remains
+visible; see [secret references](../authoring/links-and-markup.md#references-to-secret-subjects).
+
 The [generated sections](../reference/format-details.md#generated-sections)
 an entry carries — **Within**, **Governed by**, **In song and story**, the
 event views and the rest — name notes the build chose rather than the author,

package/docs/guides/site.md

@@ -118,6 +118,13 @@ Wikilinks resolve through the address index. Each emitted page receives
 derived `related` entries for the links its author wrote and the backlinks
 other authors wrote to it.
 
+A wikilink to a GM-only note or secret heading conceals its whole reference in
+an inline show/hide spoiler. `.show` reveals the reference without changing the
+destination's audience. GM-only pages remain omitted, so references to them
+have no link; published secret sections retain theirs. Spoiler text remains in
+the generated HTML and is readable in page source. See
+[secret references](../authoring/links-and-markup.md#references-to-secret-subjects).
+
 What lies within a place, who governs it, what an affiliation governs, the
 works naming a note and the map from a place reach the page as
 [generated sections](../reference/format-details.md#generated-sections): H1

package/docs/reference/format-details.md

@@ -339,8 +339,11 @@ infoboxes:
 ### Frontmatter has three regions
 
 A HeroicLands note has opening YAML frontmatter with nonempty `shortcode` and
-`type` values. Other Markdown files are ordinary Markdown. A note's frontmatter
-has three regions:
+`type` values. The opening and closing `---` delimiters accept LF or CRLF line
+endings. Parsing keeps the original source text and diagnostic positions;
+malformed YAML is an error with either line ending. The charset check recommends
+LF and reports carriage returns as warnings. Other Markdown files are ordinary
+Markdown. A note's frontmatter has three regions:
 
 | Region               | Describes                                               | Unknown keys |
 | -------------------- | ------------------------------------------------------- | ------------ |
@@ -512,7 +515,10 @@ is declared, so a near miss is a finding that names what you probably meant.
 
 `gm` marks a note for GM access. It is excluded from public site pages, SQL
 tables on the public site, and the book. Foundry compiles it only to private
-compendiums. A regular note cannot link to it; a GM note can.
+compendiums. Any note may reference it with an ordinary wikilink; the
+reference is automatically a spoiler. The `.show` override reveals that
+reference without changing the destination's audience or access permissions;
+see [references to secret subjects](#references-to-secret-subjects).
 
 **`draft` marks unfinished content.** It does two things and nothing
 else: a link _into_ a draft note renders marked, and the note itself states that
@@ -1805,6 +1811,120 @@ name at every citation with no link edited. `[[x|]]` is labelled; `[[x]]` is not
 It is the label that is required, not a target: the anchor-only form above
 carries its pipe like every other link.
 
+#### References to secret subjects
+
+Use `[[doc-divineactn|The Truth of Divine Action]]` for an indexed subject,
+including one with a GM-only audience. The renderer derives spoiler presentation
+from the resolved destination and conceals the whole reference, including its
+label. A public destination has no automatic concealment. An anchor inside secret
+content is a secret destination, including a same-note anchor reference. A
+link to the whole public note does not inherit a section's secrecy.
+
+The website renders an inline show/hide spoiler; an omitted GM-only target
+retains its reference as text without a dead link. A published secret section
+retains its link. Foundry renders a visible inline spoiler with a **Secret:**
+label, with access to its destination controlled by private packs and page
+permissions. Books print secret styling and a **Secret:** label, retaining text
+without a link when the GM-only destination is omitted. `.show` bypasses the
+automatic spoiler presentation on each surface; an unavailable destination
+still has no link.
+
+An immediately following `.show` attribute explicitly reveals the reference:
+
+```markdown
+[[doc-divineactn|The Truth of Divine Action]]{.show}
+[[doc-magictruth|The Truth of Magic]]{.show}
+```
+
+This override changes the reference's presentation only. It does not publish a
+GM-only note, alter Foundry permissions or reveal the destination's content.
+It is redundant for public destinations. `[text]{.secret}` separately marks
+text itself as a spoiler; it declares no destination audience. See
+[inline spans](#inline-spans) for inline spoiler syntax and surface behavior.
+
+#### Marking names in prose
+
+`package-build lint` reports name-marking warnings in authored body prose.
+The warnings leave a valid package passing. Headings, frontmatter, tables,
+infoboxes, code, comments and embeds are outside this check.
+
+A name is explicit: a `[Name]{.name}` bracket span or an authored link label.
+Use typed `.name` spans for unwritten subjects and ordinary wikilinks for
+indexed subjects, including private ones. Introduce another subject with its
+full canonical name at its first prose use; use plain text for the note's own
+subject and for later mentions and aliases.
+Plain prose is not searched for names. Wikilinks, ordinary Markdown links and
+reference links all supply names; a resolved empty wikilink label uses the
+note's full name. Images, code, footnote markers and bare autolinks without
+authored labels supply none.
+
+1. A `.name` span whose whole text matches an indexed `name.full` or
+   `name.aliases` should be a link. Use `[[place-arden|Arden Vale]]` or
+   `[[place-arden|]]` to introduce that note.
+2. Mark or link each name at most once per note. An indexed full name and its
+   declared aliases share one identity, including across different heading
+   anchors. Other labels use their whole text as their identity: different
+   labels linking to one page are separate names, and a label is not
+   automatically an alias of its destination.
+3. Introduce the full name before a short form or declared alias.
+   Possessives and regular plurals count as uses; other indexed forms can be
+   declared aliases.
+
+Bold is emphasis. A whole bold span exactly matching an indexed full name or
+alias receives one advisory to mark or link the name. It supplies no name
+occurrence or introduction, and bold containing a marked or linked name
+receives no such advisory. Unknown bold phrases supply no names.
+
+Inline Markdown remains active inside name spans, and name spans remain
+valid inside emphasis:
+
+```markdown
+**This is a phrase with [Joe Blow]{.name} in it**
+```
+
+The name is `Joe Blow`; the surrounding phrase is emphasis. Sites and books display
+`.name` text in bold.
+
+Each affected occurrence produces one warning at its authored
+`file:line:column`, naming the full name or explicit label. A warning
+can describe several marking problems at that occurrence.
+
+An optional `data-type` on a `.name` span states what the named thing is:
+
+```markdown
+[Ravenmoor]{.name data-type="place/settlement"}
+[Aldric Venn]{.name data-type="being/npc"}
+```
+
+Use a declared [note type](note-types.md), optionally followed by `/` and one
+of that type's subtypes. An enumerated declaration requires a listed subtype;
+an open declaration accepts a well-formed subtype, and an absent subtype
+declaration admits none. An unknown or malformed supplied value is an error
+at the `data-type` attribute's file, line and UTF-16 column. The same attribute
+on a span without the exact `name` class is an ordinary attribute. An untyped
+`.name` is valid; its type is not inferred from a matching note.
+
+The index captures actual `.name` spans throughout the authored body, including
+headings, tables, verse and spans within links. The prose-only marking checks
+above keep their narrower scope. Frontmatter, literal code, escaped syntax,
+unmarked link labels, bold, plain prose and generated content add no names.
+The rendered visible text preserves its spelling and inline content.
+
+Each own-note metadata record carries `names` in authored order. Every entry
+has exactly `name`, `type`, `subType`, `line` and `column`; absent
+classifications are explicit `null`, and no occurrences gives an empty array.
+This is derived metadata, not frontmatter. Documentation mirrors and assets
+do not duplicate a note's occurrences. The [`names` relation](#content-tables)
+flattens these entries with their containing NOTE Address.
+
+Lint groups names without an indexed full-name or alias match by supplied
+classification and lists all their source uses. It also groups conflicting
+annotations of the same visible name. Untyped uses do not conflict. A bare
+type and its subtype agree; different supplied types or different supplied
+subtypes conflict. One package advisory contains both groups and is located
+at the earliest reported use. Advisory findings preserve a successful lint
+exit status. Supplied-value errors prevent publication and compilation.
+
 ### Assets are types
 
 `icon`, `image` and `audio` are types in the type vocabulary, and an address
@@ -2911,7 +3031,7 @@ for the keys.
 | `frames`         | `data.sounds.frames`            | `frame`, `shape`, `class` (a list), `makes`, `examples` (a list of `{ root, form }`)                                                                                                                                                                                                                                                                                       |
 | `read_past`      | `data.sounds.readPast`          | `written`, `readAs`, `what`                                                                                                                                                                                                                                                                                                                                                |
 | `sound_changes`  | `data.soundChanges`             | One row per step: `position` (the set's), `name`, `from_language`, `to_language`, `takes`, `step_position` (the step's in its set), `step`, `change`, `where`                                                                                                                                                                                                              |
-| `elements`       | `data.elements`                 | `form`, `variants` (a list), `element_position` (the element's `position`), `kind`, `sense`, `examples` (a list), `word`, `genitive`                                                                                                                                                                                                                                       |
+| `elements`       | `data.elements`                 | `form`, `variants` (a list), `element_position` (the element's `position`), `kind`, `sense`, `examples` (a list), `word`, `joining`                                                                                                                                                                                                                                        |
 | `roots`          | `data.roots`                    | `root`, `sense`, `field`                                                                                                                                                                                                                                                                                                                                                   |
 | `cognates`       | `data.cognates`                 | One row per form of a set: `position` (the set's), `gloss`, `proto`, `form_language` (the form's language note), `form`                                                                                                                                                                                                                                                    |
 | `calling_names`  | `data.callingNames`             | One row per closing: `form`, `doubled` (`true` or `false`), `usual`, and the language's `min_syllables`                                                                                                                                                                                                                                                                    |
@@ -2922,7 +3042,7 @@ for the keys.
 | `name_shapes`    | `data.naming.shapes`            | `of`, `syllables_min`, `syllables_max`, `per_vowel_min`, `per_vowel_max`                                                                                                                                                                                                                                                                                                   |
 | `name_edges`     | `data.naming.edges`             | `edge`, `sounds` (a list), `vowel` (`false` where unstated), `of` (`name` where unstated)                                                                                                                                                                                                                                                                                  |
 | `name_draws`     | `data.naming.draws`             | `kind`, `elements` (a list)                                                                                                                                                                                                                                                                                                                                                |
-| `held_from`      | `data.naming.heldFrom`          | `source`, `takes`, `clip`, `genitive` and `elements` (lists)                                                                                                                                                                                                                                                                                                               |
+| `held_from`      | `data.naming.heldFrom`          | `source`, `takes`, `clip`, `joining` and `elements` (lists)                                                                                                                                                                                                                                                                                                                |
 | `near_names`     | `data.naming.nearName.examples` | `near`, `given`, and the language's `min_syllables`                                                                                                                                                                                                                                                                                                                        |
 
 A register name is carried by a note in the language's `data.scope` — any
@@ -2937,6 +3057,30 @@ office title, and by an anchor that has it as its name, which the row cites as
 `max(form) FILTER (WHERE form_language = 'thalorna-note-skill-helonclng') AS "Helonic"`,
 grouped by `position` and `gloss`.
 
+**`names`** is one row per actual `.name` span in an authored note body. Each
+row has these columns, including on an empty relation:
+
+| Column    | SQL type  | Meaning                                                                                      |
+| --------- | --------- | -------------------------------------------------------------------------------------------- |
+| `owner`   | `VARCHAR` | Containing authored page's canonical NOTE Address, or `NULL` when the record has no Address. |
+| `name`    | `VARCHAR` | Rendered visible text, preserving its spelling.                                              |
+| `type`    | `VARCHAR` | Supplied note type, or `NULL`.                                                               |
+| `subType` | `VARCHAR` | Supplied subtype, or `NULL`.                                                                 |
+| `line`    | `BIGINT`  | Original 1-based source line at the span's opening `[`.                                      |
+| `column`  | `BIGINT`  | Original 1-based UTF-16 source column at that `[`.                                           |
+
+```sql
+SELECT owner, name, type, subType, line, "column"
+FROM names
+WHERE type = 'place'
+ORDER BY owner, line, "column"
+```
+
+A native Item's source uses its NOTE page as `owner`. Declared dependency
+metadata supplies `names` in that package's SQL schema. Public queries exclude
+GM-only owners; all/native contexts retain them. Only authored occurrences
+contribute rows, so generated queries and sections add no further names.
+
 **`language_lineage`** is one row per language note and each language it
 inherits words from through [`data.family`](#a-languages-words): `language`,
 `ancestor` and `depth`, with the language itself at depth `0`, its parent at
@@ -3374,6 +3518,28 @@ An attribute-bearing opener allows a nested div to be distinguished from the bar
 The watch wears [a _blue_ sash]{#watch-sash .uniform lang=en}.
 ```
 
+The exact `.name` class marks a name, with optional `data-type="type/subType"`;
+see [marking names in prose](#marking-names-in-prose) for the vocabulary and index.
+The exact `.secret` class marks the enclosed text as an inline spoiler:
+
+```markdown
+[The hidden **passage**]{.secret}
+[Aldric Venn]{.name .secret data-type="being/npc"}
+```
+
+The website provides an inline show/hide button and preserves interactive links
+inside the revealed content. Foundry prints a visible inline `secret` span
+with a **Secret:** label; the span does not withhold its text from players.
+The book prints the text with secret styling and a **Secret:** label.
+Inline emphasis and combined `.name` classification survive rendering. Published HTML retains the text, so opening
+the spoiler or inspecting the source reveals it.
+
+This span has no effect on a destination's audience. Ordinary wikilinks derive
+spoilers from their resolved destinations; `.show` bypasses that automatic
+concealment without cancelling an enclosing authored `.secret`. An inline span
+does not change the scope of `.secret` headings or `:::secret` blocks, and it
+does not start or withhold a JournalEntryPage.
+
 Inline Markdown remains active inside the span. Bracket spans have lower priority than URL links, image links, reference links, footnotes and wikilinks. A bracketed form immediately preceded by `!`, followed by `(` or another `[`, or beginning with `[[` is not a span, even when the link is unresolved. Ordinary links retain their existing syntax. Escape a bracket when it should be literal, or put examples inside a code span or fence. A span identifier addresses that point in the note; it does not start a journal page.
 
 ##### Alerts
@@ -5492,7 +5658,7 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `soundChanges[].steps[].step`              | `string`, required                                                                                                             | The step's label, as `A1` or `"1"`; no label stands twice in a set                                                                                                                   |
 | `soundChanges[].steps[].change`            | `string`, required                                                                                                             | The change in arrow notation, as `` `ph` > `f`; `kh` > `h` ``, or the operation it names in words                                                                                    |
 | `soundChanges[].steps[].where`             | `string`                                                                                                                       | Where it holds, as `word end`; everywhere where absent                                                                                                                               |
-| `elements`                                 | `{ form, variants?, position?, kind?, sense, examples?, word?, genitive? }[]`                                                  | `language` only: the elements its names are built from                                                                                                                               |
+| `elements`                                 | `{ form, variants?, position?, kind?, sense, examples?, word?, joining? }[]`                                                   | `language` only: the elements its names are built from                                                                                                                               |
 | `elements[].form`                          | `string`, required                                                                                                             | The element, as `arn-`                                                                                                                                                               |
 | `elements[].variants`                      | `string[]`                                                                                                                     | The element's other forms, as `aldr-` beside `ald-`                                                                                                                                  |
 | `elements[].position`                      | `opening`, `closing`, `either` or `link`                                                                                       | Where in a name it stands                                                                                                                                                            |
@@ -5500,7 +5666,7 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `elements[].sense`                         | `string`, required                                                                                                             | What it means                                                                                                                                                                        |
 | `elements[].examples`                      | `string[]`                                                                                                                     | The names it is read from                                                                                                                                                            |
 | `elements[].word`                          | `string`                                                                                                                       | The word it is the stem of, a form of `words` of the language or an ancestor                                                                                                         |
-| `elements[].genitive`                      | `string`                                                                                                                       | The element in the genitive, as `-borgar`, where a name governing another word takes it                                                                                              |
+| `elements[].joining`                       | `string`                                                                                                                       | The element's joining form, as `-borgar`, when it qualifies another word                                                                                                             |
 | `roots`                                    | `{ root, sense, field? }[]`                                                                                                    | `language` only: the consonantal roots its words are set from                                                                                                                        |
 | `roots[].root`                             | `string`, required                                                                                                             | The root, as `d-l-k`                                                                                                                                                                 |
 | `roots[].sense`                            | `string`, required                                                                                                             | What it means                                                                                                                                                                        |
@@ -5540,11 +5706,11 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `naming.draws`                             | `{ kind, elements }[]`                                                                                                         | The element kinds each kind of name is built from                                                                                                                                    |
 | `naming.draws[].kind`                      | `byname`, `given` or `place`, required                                                                                         | The kind of name; once per kind                                                                                                                                                      |
 | `naming.draws[].elements`                  | list of `byname`, `given` or `place`, required                                                                                 | The element kinds, as `elements[].kind` states them                                                                                                                                  |
-| `naming.heldFrom`                          | `{ source, takes, clip?, genitive?, elements? }[]`                                                                             | What a place name takes first, by what the place is held from                                                                                                                        |
+| `naming.heldFrom`                          | `{ source, takes, clip?, joining?, elements? }[]`                                                                              | What a place name takes first, by what the place is held from                                                                                                                        |
 | `naming.heldFrom[].source`                 | `string`, required                                                                                                             | What the place is held from, as `a founder`                                                                                                                                          |
 | `naming.heldFrom[].takes`                  | `stem`, `godName`, `givenName` or `element`, required                                                                          | What stands first: a name-stem in any grade, a god's name, a founder's given name, or one of `elements`                                                                              |
 | `naming.heldFrom[].clip`                   | `first`                                                                                                                        | How the name is clipped: to its first element; whole where absent. A name row only                                                                                                   |
-| `naming.heldFrom[].genitive`               | `string[]`                                                                                                                     | The genitive endings, one of which stands at the seam after the name. A name row only                                                                                                |
+| `naming.heldFrom[].joining`                | `string[]`                                                                                                                     | The joining endings, one of which stands at the seam after the name. A name row only                                                                                                 |
 | `naming.heldFrom[].elements`               | `string[]`                                                                                                                     | The elements that may stand first; required on, and only on, a row that takes an `element`                                                                                           |
 | `naming.nearName`                          | `{ minSyllables, examples? }`                                                                                                  | The near name a long given name carries                                                                                                                                              |
 | `naming.nearName.minSyllables`             | `integer`, required                                                                                                            | The fewest syllables a given name has that carries a near name                                                                                                                       |
@@ -5856,7 +6022,7 @@ data:
       - { kind: byname, elements: [byname, place] }
     heldFrom:
       - { source: a god, takes: godName, clip: first }
-      - { source: a founder, takes: givenName, genitive: ["-s", "-a"] }
+      - { source: a founder, takes: givenName, joining: ["-s", "-a"] }
       - { source: the ting and its law, takes: element, elements: ["ting-", "lög-"] }
     nearName:
       minSyllables: 4
@@ -5972,9 +6138,8 @@ form and its other forms, where in a name it stands (`opening`, `closing`,
 `either` or `link`), its sense and the names it is read from. In a language
 that keeps one set of elements for each kind of name, `kind` says which
 (`byname`, `given` or `place`). `word` names the word of `words` the element is
-the stem of, the language's or an ancestor's, and `genitive` gives the element
-in the genitive where a name governing another word takes it. An element that
-is also a word stays a word.
+the stem of, the language's or an ancestor's, and `joining` gives its form
+when it qualifies another word. An element that is also a word stays a word.
 
 **`roots` lists consonantal roots**, each with its sense and the field it
 belongs to. **`cognates`** lists, on the eldest language of a set, the form one
@@ -6007,7 +6172,7 @@ there too and `of` where the edge holds for one class of name only; an edge
 stands once for each class. `draws` gives the element kinds each kind of name
 is built from. `heldFrom` gives what a place name takes first by what the
 place is held from: a name-stem, a god's name, a founder's given name — that
-name `clip`ped to its `first` element, or followed by one of its `genitive`
+name `clip`ped to its `first` element, or followed by one of its `joining`
 endings — or one of the `elements` listed. `nearName` states the fewest
 syllables a given name has that carries a near name, with worked examples.
 
@@ -6056,7 +6221,7 @@ Each finding is located at the key at fault:
 | A naming edge stated twice for one class of name, at the second                                                                                                                                                                                                                                                                                                          | error    |
 | A kind of name whose draws are stated twice, at the second                                                                                                                                                                                                                                                                                                               | error    |
 | A held-from row that takes an `element` and names no `elements`, at the row                                                                                                                                                                                                                                                                                              | error    |
-| `elements` on a held-from row that takes no element, or `clip` or `genitive` on one that takes no name, at the key                                                                                                                                                                                                                                                       | error    |
+| `elements` on a held-from row that takes no element, or `clip` or `joining` on one that takes no name, at the key                                                                                                                                                                                                                                                        | error    |
 | A `scope` Address that does not resolve, or a type that is no note type                                                                                                                                                                                                                                                                                                  | error    |
 | A tongue `language` or a cognate form's language that is no language note                                                                                                                                                                                                                                                                                                | error    |
 | A register row with neither a `tongue` nor a `kind`, at the row                                                                                                                                                                                                                                                                                                          | error    |
@@ -6391,6 +6556,12 @@ word.
    them, then its culture's `data.language`;
 3. on a culture, its own `data.language`.
 
+On lore and affiliation notes, `data.language` and
+`data.glossary[].language` name language notes. Use `skill-provnzlng` for a
+language in this package, or `<pkg>-note-skill-provnzlng` for its complete
+NOTE Address. Any other system segment, including `sohl`, is an error at the
+authored value. A SOHL skill Address names a compiled Item.
+
 An affiliation's culture is the one it states or inherits, as
 [Culture in the index](#culture-in-the-index) describes, and a culture's
 `data.language` includes one it inherits from its

package/docs/reference/note-types.md

@@ -474,7 +474,7 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.scope`            | a map — `{ folders?, cultures?, lore?, parents?, addresses?, paths?, types?, skip? }`                                                        | The notes the register covers. A language skill note only.                                                                                                                                                                                                                                                                                                                                            |
 | `data.sounds`           | a map — `{ letters?, edges?, clusters?, stress?, finals?, syllables?, joining?, joins?, marks?, skeleton?, frames?, readPast?, mutations? }` | The letters the language writes and the rules its words keep. A language skill note only.                                                                                                                                                                                                                                                                                                             |
 | `data.soundChanges`     | list of `{ name, from?, to?, takes?, steps }`                                                                                                | Named sets of ordered changes, each making one tongue's words from another's. A language skill note only.                                                                                                                                                                                                                                                                                             |
-| `data.elements`         | list of `{ form, variants?, position?, kind?, sense, examples?, word?, genitive? }`                                                          | The elements the language's names are built from. A language skill note only.                                                                                                                                                                                                                                                                                                                         |
+| `data.elements`         | list of `{ form, variants?, position?, kind?, sense, examples?, word?, joining? }`                                                           | The elements the language's names are built from. A language skill note only.                                                                                                                                                                                                                                                                                                                         |
 | `data.roots`            | list of `{ root, sense, field? }`                                                                                                            | The consonantal roots the language's words are set from. A language skill note only.                                                                                                                                                                                                                                                                                                                  |
 | `data.cognates`         | list of `{ forms, proto?, gloss }`                                                                                                           | Sets of forms one older word takes in several languages, stated on the eldest. A language skill note only.                                                                                                                                                                                                                                                                                            |
 | `data.callingNames`     | a map — `{ closings, minSyllables }`                                                                                                         | The short name a long given name is called by. A language skill note only.                                                                                                                                                                                                                                                                                                                            |
@@ -635,7 +635,7 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.elements[].sense`                   | a string                                                                                                  | yes      | What the element means.                                                                                                                                                                                                                                                                                                                  |
 | `data.elements[].examples`                | a list of names                                                                                           | no       | The names the element is read from.                                                                                                                                                                                                                                                                                                      |
 | `data.elements[].word`                    | a form of the language's words                                                                            | no       | The word the element is the stem of, a form of `data.words` of the language or an ancestor.                                                                                                                                                                                                                                              |
-| `data.elements[].genitive`                | the element as written, such as `-borgar`                                                                 | no       | The element in the genitive, where a name governing another word takes it.                                                                                                                                                                                                                                                               |
+| `data.elements[].joining`                 | the element as written, such as `-borgar`                                                                 | no       | The element's joining form, as written when it qualifies another word.                                                                                                                                                                                                                                                                   |
 | `data.roots[].root`                       | a consonantal skeleton, such as `d-l-k`                                                                   | yes      | The root.                                                                                                                                                                                                                                                                                                                                |
 | `data.roots[].sense`                      | a string                                                                                                  | yes      | What the root means.                                                                                                                                                                                                                                                                                                                     |
 | `data.roots[].field`                      | a string, such as `stone`                                                                                 | no       | The field the root belongs to.                                                                                                                                                                                                                                                                                                           |
@@ -668,11 +668,11 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.naming.draws`                       | list of `{ kind, elements }`                                                                              | no       | The element kinds each kind of name is built from.                                                                                                                                                                                                                                                                                       |
 | `data.naming.draws[].kind`                | one of byname, given, place                                                                               | yes      | The kind of name; once per kind.                                                                                                                                                                                                                                                                                                         |
 | `data.naming.draws[].elements`            | a list of element kinds                                                                                   | yes      | The kinds of element, as `data.elements` states them, the name is built from.                                                                                                                                                                                                                                                            |
-| `data.naming.heldFrom`                    | list of `{ source, takes, clip?, genitive?, elements? }`                                                  | no       | What a place name takes first, by what the place is held from.                                                                                                                                                                                                                                                                           |
+| `data.naming.heldFrom`                    | list of `{ source, takes, clip?, joining?, elements? }`                                                   | no       | What a place name takes first, by what the place is held from.                                                                                                                                                                                                                                                                           |
 | `data.naming.heldFrom[].source`           | a string, such as `a founder`                                                                             | yes      | What the place is held from.                                                                                                                                                                                                                                                                                                             |
 | `data.naming.heldFrom[].takes`            | one of stem, godName, givenName, element                                                                  | yes      | What stands first: a name-stem in any grade, a god's name, a founder's given name, or one of `elements`.                                                                                                                                                                                                                                 |
 | `data.naming.heldFrom[].clip`             | one of first                                                                                              | no       | How the name is clipped: `first`, to its first element; whole where absent.                                                                                                                                                                                                                                                              |
-| `data.naming.heldFrom[].genitive`         | a list of endings                                                                                         | no       | The genitive endings, one of which stands at the seam after the name.                                                                                                                                                                                                                                                                    |
+| `data.naming.heldFrom[].joining`          | a list of endings                                                                                         | no       | The joining endings, one of which stands at the seam after the name.                                                                                                                                                                                                                                                                     |
 | `data.naming.heldFrom[].elements`         | a list of elements                                                                                        | no       | The elements that may stand first, for a row that takes an `element`.                                                                                                                                                                                                                                                                    |
 | `data.naming.nearName`                    | a map — `{ minSyllables, examples? }`                                                                     | no       | The near name a long given name carries.                                                                                                                                                                                                                                                                                                 |
 | `data.naming.nearName.minSyllables`       | a whole number                                                                                            | yes      | The fewest syllables a given name has that carries a near name.                                                                                                                                                                                                                                                                          |

package/engine/anchors.mjs

@@ -41,7 +41,7 @@ import { scanPoetry } from "./content-poetry.mjs";
 import { scanSpans } from "./content-spans.mjs";
 import { slugify } from "./content-slug.mjs";
 import { scanFigures } from "./content-figures.mjs";
-import { scanHeadingAttributes } from "./heading-attributes.mjs";
+import { withheldSections, scanHeadingAttributes } from "./heading-attributes.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 
 /**
@@ -65,12 +65,14 @@ export const ANCHOR_KINDS = Object.freeze(["prose", "event"]);
  *   picture's address to the role its asset declares, so a figure anchor's
  *   `name` reads `Map 1` rather than `Figure 1` where it is due — see
  *   {@link module:engine/content-figures.scanFigures}.
+ * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Exact-text scanner projections.
  * @returns {Array<{slug: string, name: string, level: number, line: number,
- *   kind: string}>} In document order.
+ *   kind: string, secret?: boolean}>} In document order.
  */
-export function collectAnchors(body, bodyLine = 1, resolveRole) {
+export function collectAnchors(body, bodyLine = 1, resolveRole, syntax) {
     const anchors = [];
-    for (const heading of scanHeadingAttributes(body, bodyLine).headings) {
+    const headings = scanHeadingAttributes(body, bodyLine).headings;
+    for (const heading of headings) {
         if (!heading.id) continue;
         anchors.push({
             slug: heading.id,
@@ -90,9 +92,12 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
             kind: "prose",
         });
     }
+    const secretBlocks = [];
     const blockAnchors = (source, firstLine) => {
         const sourceLines = source.split("\n");
-        for (const block of scanBlocks(source).blocks) {
+        for (const block of (syntax ? syntax(source).blocks : scanBlocks(source)).blocks) {
+            if (block.name === "secret")
+                secretBlocks.push({ start: firstLine + block.start, end: firstLine + block.end });
             if (block.id)
                 anchors.push({
                     slug: slugify(block.id),
@@ -108,7 +113,7 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
         }
     };
     blockAnchors(String(body ?? ""), bodyLine);
-    for (const alert of scanAlerts(body).blocks) {
+    for (const alert of (syntax ? syntax(body).alerts : scanAlerts(body)).blocks) {
         if (alert.id)
             anchors.push({
                 slug: slugify(alert.id),
@@ -128,7 +133,8 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
                 kind: "prose",
             });
     }
-    for (const span of scanSpans(body).spans) {
+    const spans = (syntax ? syntax(body).spans : scanSpans(body)).spans;
+    for (const span of spans) {
         if (span.id)
             anchors.push({
                 slug: slugify(span.id),
@@ -138,17 +144,45 @@ export function collectAnchors(body, bodyLine = 1, resolveRole) {
                 kind: "prose",
             });
     }
+    const sections =
+        headings.some((heading) => heading.classes.includes("secret")) ?
+            withheldSections(body).sections
+        :   [];
+    const secretSpans = spans.filter((span) =>
+        span.attrs.some(([key, value]) => key === "class" && value.split(/\s+/).includes("secret")),
+    );
+    const secretSpanAnchors = new Set(
+        spans
+            .filter(
+                (target) =>
+                    target.id &&
+                    secretSpans.some(
+                        (parent) => parent.start <= target.start && parent.end >= target.end,
+                    ),
+            )
+            .map((span) => span.id),
+    );
+    for (const anchor of anchors) {
+        const line = anchor.line - bodyLine;
+        if (
+            sections.some((section) => line >= section.start && line < section.end) ||
+            secretBlocks.some((block) => anchor.line >= block.start && anchor.line <= block.end) ||
+            secretSpanAnchors.has(anchor.slug)
+        )
+            anchor.secret = true;
+    }
     return anchors.sort((a, b) => a.line - b.line);
 }
 
 /** Collisions involving a div, verse or inline-span anchor.
  * Heading and caption collisions are diagnosed by their existing scanners.
  * @param {string} body - Authored Markdown.
+ * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Exact-text scanner projections.
  * @returns {Array<{line: number, column: number, message: string}>} Located collisions.
  */
-export function markupAnchorFindings(body) {
+export function markupAnchorFindings(body, syntax) {
     const groups = new Map();
-    for (const anchor of collectAnchors(body)) {
+    for (const anchor of collectAnchors(body, 1, undefined, syntax)) {
         const slug = slugify(anchor.slug);
         if (!groups.has(slug)) groups.set(slug, []);
         groups.get(slug).push(anchor);

package/engine/base-compiler.mjs

@@ -686,11 +686,13 @@ export class BasePackCompiler {
         // it made — `errors` or `findings`, never just the first — so nothing
         // here re-scans; it only stops taking `[0]`.
         const findings = [];
+        const syntax = this.corpus?.syntax;
+        const scanned = syntax?.(body);
         for (const secretError of [
-            ...scanBlocks(body).errors,
-            ...scanAlerts(body).errors,
-            ...scanSpans(body).errors,
-            ...markupAnchorFindings(body),
+            ...(scanned?.blocks ?? scanBlocks(body)).errors,
+            ...(scanned?.alerts ?? scanAlerts(body)).errors,
+            ...(scanned?.spans ?? scanSpans(body)).errors,
+            ...markupAnchorFindings(body, syntax),
         ]) {
             findings.push({
                 message: secretError.message,