@heroiclands/package-build 23.8.0 → 23.10.0

package/docs/commands.md

@@ -1004,9 +1004,11 @@ scattered entries instead of one.
 
 `group` rewrites the first `## <version>` section of `CHANGELOG.md` in
 place. Within each `### <Bump> Changes` body, every block sharing one bold
-label is merged into a single block for that label — its bullets kept in
-the order they were originally written, an exact-duplicate bullet kept
-once — and the merged blocks are reordered: the unlabelled lead paragraph a
+label is merged into a single block for that label. Prose and bullets are
+retained, with exact duplicate items kept once. Opening paragraphs from
+merged labels combine in source order before their items. Wrapped
+paragraphs, nested item content and literal code stay intact. The merged
+blocks are reordered: the unlabelled lead paragraph a
 changeset writes with no category first, then every label
 [`changelog.labels`](configuration.md#changelog) declares, in the order
 given, then any label absent from that list last, in the order it first
@@ -1501,6 +1503,73 @@ package-build: This repository declares no end-to-end suite to `run`. Name one u
 
 ## Content operations
 
+### `package-build content run <targets..>`
+
+**NAME**
+
+Run selected content checks and outputs from one captured source tree.
+
+**SYNOPSIS**
+
+```text
+package-build content run <targets..> [--no-references] [--pack <name>] [--out <dir>]
+```
+
+**DESCRIPTION**
+
+Choose one or more of `index`, `lint`, `links` and `compile`. The command runs
+each selected target once, in that order, regardless of the argument order.
+They perform the same operations as `content-index`, `lint`, `links` and
+`package compile`. The standalone commands remain available.
+
+The selected operations share captured files, parsed frontmatter, content
+records and exact-source markup scans. Public and complete SQL preparations
+remain separate, as do prose-link checking and native document resolution.
+Each invocation starts a fresh in-memory session; independent commands do
+their own work. Finish dependency fetching, source generation and asset
+preparation before running this command, and start a new invocation after
+changing any input.
+
+All selected preparations finish before the first output is written. If
+source or writer preparation fails, `index` and `compile` leave existing
+index, intermediate JSON and staged packs untouched. Read-only targets still
+report the findings they can produce. An ordinary lint error does not block
+an otherwise successful index or compile target. The command writes no
+persistent source cache.
+
+Selecting `compile` applies the package command's existing package-kind rule
+before any writer. A documentation package can select `index` alone; selecting
+`index compile` reports the compile refusal and leaves its index untouched.
+
+**OPTIONS**
+
+| Option            | Type    | Default                  | Description                                 |
+| ----------------- | ------- | ------------------------ | ------------------------------------------- |
+| `--references`    | boolean | true                     | Check frontmatter references during `lint`. |
+| `--pack` `<name>` | string  | all configured packs     | Restrict `compile` to this pack.            |
+| `--out` `<dir>`   | string  | configured content index | Set the `index` output directory.           |
+
+**EXIT STATUS**
+
+0 when every selected target succeeds, including advisory warnings. 1 when
+arguments or preparation fail, or any selected target reports an error.
+
+**EXAMPLES**
+
+```bash
+package-build content run lint links
+package-build content run index compile
+package-build content run index lint links compile
+```
+
+**SEE ALSO**
+
+`package-build content-index`, `package-build lint`, `package-build links`,
+`package-build package compile`, [Configuration](configuration.md),
+[Programmatic sessions](api.md#enginecontentsession).
+
+---
+
 ### `package-build package <action> [pack] [entry]`
 
 **NAME**
@@ -2012,6 +2081,21 @@ dependencies; exact Item UUID validation remains part of compilation. Reads
 the content tree named by `root`, defaulting to
 `paths.content`; writes nothing.
 
+Name marking is advisory: lint checks explicit `.name` spans and authored link
+labels against the [name-marking
+conventions](authoring/links-and-markup.md#marking-names-in-prose). Plain prose
+is not searched for names. It builds one matcher from the current local and
+dependency names, then
+reports each affected occurrence at its exact source location. These warnings
+also appear when `lint` is selected in `content run`; they do not fail the run.
+
+Lint also emits one grouped package advisory for marked names without an
+indexed full-name or alias match, and for conflicting supplied classifications.
+It lists every source use and is located at the earliest reported span.
+Untyped uses and compatible type/subtype refinements do not conflict.
+An invalid supplied `.name` `data-type` is a located preparation error and
+prevents selected writers. See the same name-marking guide for typed examples.
+
 Content lint computes source positions when it emits findings and shares each
 note's YAML position document across consecutive lookups.
 
@@ -2182,6 +2266,9 @@ wikilink at all. Also reports a vendored foreign-package content index that
 has drifted out of reach, naming `package-build deps fetch` as the fix. Resolves
 address-valued SoHL system fields declared by the installed schema against this
 package and its declared dependencies.
+An anchored reference to a dependency's readable note must name a prose anchor
+in its fetched content index. A missing section is an error even when the page
+address resolves. Event ids are not prose sections and cannot be wikilink targets.
 Reads the content tree named by `root`, defaulting to `paths.content`, and
 the cached content indexes of any declared dependency; writes nothing.
 
@@ -2342,16 +2429,27 @@ package-build content-index [root] [--out <dir>]
 
 **DESCRIPTION**
 
-Emits this package's note index as JSON Lines — one record per note,
-carrying its full frontmatter plus its place in the tree. Every build
-already walks the tree and parses every note's frontmatter and then throws
-the result away; this publishes that walk so anything outside a build can
-query the content without paying for a second walk. Its own command rather
-than only a build step, because the point is that anyone can regenerate it
-at will — the artifact costs a frontmatter parse, not a build, which is
-also what lets it stay uncommitted. Reads the content tree named by `root`,
-defaulting to `paths.content`; writes `<contentPackage>-metadata.jsonl`
-into `--out`, defaulting to the configured `paths.contentIndex`.
+Emits this package's note index as JSON Lines, carrying full frontmatter,
+tree positions, prose and event anchors, and document targets. Reads the
+content tree named by `root`, defaulting to `paths.content`; writes
+`<contentPackage>-metadata.jsonl`, `<contentPackage>-dictionary.jsonl` and
+`<contentPackage>-terms.jsonl` into `--out`, defaulting to the configured
+`paths.contentIndex`.
+
+Metadata includes each own note's authored `.name` occurrences under `names`,
+with visible text, nullable type/subtype and original source line/column.
+Local and dependency SQL schemas expose them through `names`; they travel in
+the metadata artifact.
+
+The command prepares SQL tables, page lists, automatic sections and scalar
+expressions before publishing their prose targets. Each source uses its own
+audience for prose declarations: public notes use public providers and usage,
+and GM notes use the complete corpus. Native target maps use the compendium's
+complete SQL corpus and expose only declared prose slugs present there, with
+their actual native page targets. Readable item documentation targets its
+documentation journal. An empty published prose-anchor list declares no prose targets,
+including for pages without a Foundry document. Preparation errors leave all
+three output files untouched.
 
 **OPTIONS**
 

package/docs/content-format.md

@@ -9,7 +9,7 @@ subType: userguide
 
 A content package begins with Markdown notes under `assets/content/`. Each note has YAML frontmatter describing its identity and data, followed by prose. Folder names beneath `assets/content/` are for authors; `type`, `subType`, and Addresses determine what the build creates.
 
-Every typed note requires a nonempty body, including drafts, folders and homepages. An empty or whitespace-only body is an error. A nonempty body with fewer than 25 prose words warns unless tagged `draft`; the tag never exempts an empty body. A `folder` note needs only a nonempty body: any content passes, with or without `draft`.
+Nonempty `data.words` on a language note (`type: skill`, `subType: language`), or `data.glossary` on a culture or affiliation, supplies page content without an authored body. Every other typed note requires a nonempty body, including drafts, folders and homepages. An empty or whitespace-only body is otherwise an error. A nonempty body with fewer than 25 prose words warns unless tagged `draft`; the tag never exempts an empty body. A `folder` note needs only a nonempty body: any content passes, with or without `draft`.
 
 Start with [your first note](authoring/first-note.md). It explains the smallest valid note and shows the JournalEntry, web page, book entry, and content-index record made from it. Then use the chapters below in the order your note needs them.
 
@@ -31,6 +31,11 @@ Leading `:` captions describe the next supported block; `:@` captions also numbe
 
 A code fence with language `poetry` keeps verse lines, stanza breaks and relative indentation. Its numbered caption uses the **Poem** label. Generic `:::` divs and `[inline spans]{.class}` accept attributes. See [poetry](authoring/links-and-markup.md#poetry), [fenced divs](authoring/links-and-markup.md#fenced-divs) and [inline spans](authoring/links-and-markup.md#inline-spans).
 
+Mark a name without a note as `[Name]{.name data-type="being"}`; the optional
+classification uses the declared note vocabulary. The [name-marking
+guide](authoring/links-and-markup.md#marking-names-in-prose) explains its syntax,
+index and grouped lint advice.
+
 Body extensions use braces with space-separated `key=value` attributes:
 `![[icon-harbor|Harbor]]{float=top-left size=medium}` and an SQL fence with
 `{allow-empty=true}` are examples. Inline font glyphs use the package's icon
@@ -166,6 +171,6 @@ Places, affiliations, lore and beings may name their culture in `data.culture`,
 
 An affiliation may name the trade, temple or order tongue it keeps in its own `data.language`. An affiliation that reaches no culture is a warning, in a tree holding a culture note. A language needs no culture and no affiliation. See [type: affiliation](reference/format-details.md#type-affiliation).
 
-A language note (`type: skill`, `subType: language`) states its words in frontmatter: `data.words` states each word as a map of its form, class, field and gloss — one sense or a list of them, which a dictionary numbers — with its source, its variant forms, the pieces it is built from and a note, beside `data.classModifiers`, `data.fields` and `data.affixes`, each affix with the `kind` it makes, for a given name's ending who the name is `given` to, and the stem closes it is barred after; a zero affix states `zero: true` and no form. The notes a word is cited from are derived, not written: a note cites a word by marking it in italics in its prose, matched by form or a variant with diacritics and case set aside. The language of a word is the note it sits on, and none of it reaches the compiled Item. A daughter language names its parent in `data.family` and reads the parent's words as its own; the `language_lineage` relation joins a language to its ancestors. Classes come from the [master word classes](reference/format-details.md#word-classes). A culture or an affiliation states its own glossary terms in `data.glossary`, and every entry resolves to a language — its own `language`, else the affiliation's, its parents' or its culture's, else the culture's — or is an error at the entry. The `words`, `affixes`, `fields`, `glossary` and `language_lineage` relations hold them for `sql` fences, the `dictionary` relation lists each word under every language that has it, inherited words included, and the `terms` relation each glossary entry, rank and office with the cultures it reaches; a fence sets them with `layout=dictionary` or `layout=glossary`. A language note names the tag a dictionary prints for it in `data.abbreviation`. Every fact a check reads about a language's names, sounds and history is frontmatter too: `data.tongues` and `data.register` (every name the setting gives in the language's reach, the notes carrying each derived from the index), `data.retired`, `data.scope`, `data.sounds` (letters with their place, word edges from a closed list, the cluster limit and the groups of clusters inside a word, the stress rule, syllable finals, syllable rules and vowel harmony with each vowel's front partner, the joining of parts, written marks, a root's skeleton vowel and frames, the spellings read past, and named mutations such as wearing and voicing), `data.soundChanges` (named sets of ordered steps), `data.elements` (each standing `opening`, `closing`, `either` or `link`, for one kind of name, with the word it is the stem of and its genitive), `data.roots`, `data.cognates` (with a reconstructed `proto` form), `data.callingNames`, `data.older` (the forms older than the rules), `data.negation` (the negative particle and the mutation it brings) and `data.naming` (how long each class of name runs, the edges names keep that words do not, the element kinds each kind of name draws on, what a place name takes from what it is held from, and the near name), each a relation — `sounds` as `letters`, `edges`, `clusters`, `cluster_groups`, `stress`, `finals`, `syllables`, `joining`, `joins`, `marks`, `skeleton`, `frames`, `read_past` and `mutations`, `soundChanges` as `sound_changes`, `callingNames` as `calling_names` — that a fence sets back on the page. A word's citations also come from a note whose name, alias or rank or office title spells it whole. See [a language's words](reference/format-details.md#a-languages-words), [a language's register, sounds and history](reference/format-details.md#a-languages-register-sounds-and-history), [glossary terms](reference/format-details.md#glossary-terms) and [dictionaries and glossaries](reference/format-details.md#dictionaries-and-glossaries).
+A language note (`type: skill`, `subType: language`) states its words in frontmatter: `data.words` states each word as a map of its form, class, field and gloss — one sense or a list of them, which a dictionary numbers — with its source, its variant forms, the pieces it is built from and a note, beside `data.classModifiers`, `data.fields` and `data.affixes`, each affix with the `kind` it makes, for a given name's ending who the name is `given` to, and the stem closes it is barred after; a zero affix states `zero: true` and no form. The notes a word is cited from are derived, not written: a note cites a word by marking it in italics in its prose, matched by form or a variant with diacritics and case set aside. The language of a word is the note it sits on, and none of it reaches the compiled Item. A daughter language names its parent in `data.family` and reads the parent's words as its own; the `language_lineage` relation joins a language to its ancestors. Classes come from the [master word classes](reference/format-details.md#word-classes). A culture or an affiliation states its own glossary entries in `data.glossary`: common words in its core vocabulary, dictionary words with a context meaning, or phrases, compounds and terms of art outside the dictionary with their own gloss. An entry naming a word of its resolved language takes the word's senses and class and links to its language entry; a `definition` supplies the entry's meaning instead. Common marks belong to the glossary's owner. A language note with nonempty `data.words` receives its full Dictionary section automatically: one alphabetical list with field tags and one key. A culture or affiliation with nonempty `data.glossary` receives only its explicitly declared entries in its Glossary section; ranks and offices stand in the affiliation's own sections. A note without the relevant frontmatter receives no such section. All surfaces show these sections after the authored text, or under an existing `{#dictionary}`, `{#lexicon}` or `{#glossary}` heading after its introduction. There are no setting-wide dictionary or glossary pages. Every entry resolves to a language — its own `language`, else the affiliation's, its parents' or its culture's, else the culture's — or is an error at the entry. The `words`, `affixes`, `fields`, `glossary` and `language_lineage` relations hold them for `sql` fences, the `dictionary` relation lists each word under every language that has it, inherited words included, and the `terms` relation each glossary entry, rank and office with its culture associations; a fence sets custom views with `layout=dictionary` or `layout=glossary`. A language note names the tag a dictionary prints for it in `data.abbreviation`. Every fact a check reads about a language's names, sounds and history is frontmatter too: `data.tongues` and `data.register` (every name the setting gives in the language's reach, the notes carrying each derived from the index), `data.retired`, `data.scope`, `data.sounds` (letters with their place, word edges from a closed list, the cluster limit and the groups of clusters inside a word, the stress rule, syllable finals, syllable rules and vowel harmony with each vowel's front partner, the joining of parts, written marks, a root's skeleton vowel and frames, the spellings read past, and named mutations such as wearing and voicing), `data.soundChanges` (named sets of ordered steps), `data.elements` (each standing `opening`, `closing`, `either` or `link`, for one kind of name, with the word it is the stem of and its joining form), `data.roots`, `data.cognates` (with a reconstructed `proto` form), `data.callingNames`, `data.older` (the forms older than the rules), `data.negation` (the negative particle and the mutation it brings) and `data.naming` (how long each class of name runs, the edges names keep that words do not, the element kinds each kind of name draws on, what a place name takes from what it is held from, and the near name), each a relation — `sounds` as `letters`, `edges`, `clusters`, `cluster_groups`, `stress`, `finals`, `syllables`, `joining`, `joins`, `marks`, `skeleton`, `frames`, `read_past` and `mutations`, `soundChanges` as `sound_changes`, `callingNames` as `calling_names` — that a fence sets back on the page. A word's citations also come from a note whose name, alias or rank or office title spells it whole. See [a language's words](reference/format-details.md#a-languages-words), [a language's register, sounds and history](reference/format-details.md#a-languages-register-sounds-and-history), [glossary terms](reference/format-details.md#glossary-terms) and [dictionaries and glossaries](reference/format-details.md#dictionaries-and-glossaries).
 
 Blockquote alerts use `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, or `[!]`, with optional attributes after the marker. They replace the former info and warn div fences; secret blocks remain supported. See [alerts](authoring/links-and-markup.md#alerts).

package/docs/diagnostics.md

@@ -170,7 +170,7 @@ package-build.config.yaml:382:64: error: package-build config: `site.sections.be
 
 ## A worked case: the three states of a note
 
-A note with an empty body is a **stub**, and the diagnostics about one show each
+A place note with an empty body is a **stub**, and the diagnostics about one show each
 rule above in turn.
 
 An empty body must be deliberate, so a stub that says nothing about itself is an

package/docs/guides/packs.md

@@ -20,7 +20,8 @@ Start with one pack for each document class the notes produce. An Item, Actor,
 Macro, Scene, or Adventure note can also produce a JournalEntry for its prose,
 so a package with those notes generally needs a JournalEntry pack. A missing
 pack for a document a note actually produces is a finding on that note. An
-empty body produces no prose journal and needs no pack for it.
+empty body without automatic Dictionary or Glossary content produces no prose
+journal and needs no pack for it.
 
 ```yaml
 packs:

package/docs/guides/reference-pages.md

@@ -62,10 +62,10 @@ takes.
 
 `data.pack: none` is appropriate when the page belongs on the site and in the
 index but does not need a Foundry compendium entry. A documentation package
-has no packs at all. A page with an empty body is a stub: it remains in the
-index for data references, but publishes no page address or anchors. Write a
-description for a stub and leave off the `draft` tag; use `draft` for a page
-with prose still in progress. The [stub rules](../reference/format-details.md#a-stub-is-a-note-with-an-empty-body)
+has no packs at all. A page with neither an authored body nor automatic
+Dictionary or Glossary content is a stub: it remains in the index for data
+references, but publishes no page address or anchors. Supply content before
+publishing; use `draft` for prose still in progress. The [stub rules](../reference/format-details.md#a-stub-is-a-note-with-an-empty-body)
 and [pack routing](packs.md) cover these cases.
 
 ## Link to the intended target
@@ -165,92 +165,115 @@ reconstructing them from filenames.
 
 ## Set words as a dictionary and terms as a glossary
 
-A language's words and a people's terms are each one `sql` fence, and nothing
-is copied into the note: the words come from the language notes' `data.words`,
-the terms from the `data.glossary` entries of cultures and affiliations and
-from the affiliations' ranks and offices, and a section changes when they do.
-`layout=dictionary` sets rows of the `dictionary` relation and
-`layout=glossary` rows of the `terms` relation. The query decides what
-appears, so any note may carry either.
+A language note's `data.words` supplies its Dictionary section automatically
+on the site, in the Foundry journal and in the book. The dictionary is the
+language's full word list, including inherited words, in one alphabetical
+sequence with letter headings, field tags and one key. A language with absent
+or empty `data.words` receives no Dictionary section.
 
-A language note lists its words, with the words it inherits from its parent
-language:
+The frontmatter states the words:
 
-````markdown
-# Dictionary {#dictionary}
-
-```sql {layout=dictionary section-level=2}
-SELECT * FROM dictionary WHERE language = 'thalorna-note-skill-provnzlng'
+```yaml
+shortcode: provnzlng
+name: { full: Provenzal Language }
+type: skill
+subType: language
+data:
+  classModifiers: [f, m]
+  fields:
+    - { name: Love and its conduct, holds: "Longing, courtship and the courts of love." }
+  words:
+    - {
+        form: solmère,
+        class: n m,
+        pronunciation: sol-MEH-reh,
+        field: Love and its conduct,
+        gloss: "longing; the ache for a person, a place or a time that is gone",
+      }
+    - {
+        form: amère,
+        class: n f,
+        field: Love and its conduct,
+        gloss: ["a beloved", "a sweetheart, in the songs"],
+      }
 ```
-````
 
-A culture note lists the words of its tongue a player is expected to know, and
-its glossary: its own terms and the ranks, offices and terms of every
-affiliation that reaches it.
+A culture or affiliation's `data.glossary` supplies its Glossary section. It
+contains only that owner's declared entries, so each culture and affiliation
+using a language chooses its own common words and context meanings. Ranks
+and offices stand in the affiliation's own sections; an explicit glossary
+entry can name one, but a glossary does not draw in the whole ladder or list
+of offices. A note with absent or empty `data.glossary` receives no Glossary
+section.
 
-````markdown
-# Words Everyone Knows {#common-words}
+The [worked culture glossary](../reference/format-details.md#glossary-terms)
+uses all three reasons for an entry:
 
-```sql {layout=dictionary section-level=2}
-SELECT * FROM dictionary WHERE language = 'thalorna-note-skill-provnzlng' AND common
+```yaml
+data:
+  language: skill-provnzlng
+  glossary:
+    - { name: solmère, common: true }
+    - { name: amère, definition: "a sweetheart, in the songs" }
+    - {
+        name: blood-field,
+        definition: "ground where a battle tore the boundary with the spirit world, and it did not close",
+      }
 ```
 
-# Glossary {#glossary}
-
-```sql {layout=glossary section-level=2}
-SELECT * FROM terms WHERE list_contains(cultures, 'thalorna-note-lore-provenzianclt')
-```
-````
+`solmère` is part of this culture's core vocabulary: the words a player needs
+to adventure there. With no `definition`, it carries the senses and class of
+the dictionary word and links to that word's entry. `amère` supplies a context
+meaning, which takes the place of its dictionary senses while retaining the
+word link and class. `blood-field` supplies a gloss for a term outside the
+dictionary. Common marks belong to the glossary's owner; dictionaries mark
+nothing common. There are no setting-wide dictionary or glossary pages.
 
-The glossary renders as a key, a heading per letter and one paragraph per
-term, each sense tagged with the body or culture it comes from and each term
-in another tongue tagged with it:
+The generated sections follow the note's authored text. A heading with
+`{#dictionary}` or `{#lexicon}` receives the Dictionary list, and a heading
+with `{#glossary}` receives the Glossary list, after the authored text in
+that section. This preserves an introduction or loanword discussion under
+an anchored heading:
 
 ```markdown
-**Key:** _Lit._ Liturgic Language; • a common word, which a player is expected to know by heart.
+# Lexicon {#lexicon}
 
-## K
-
-**Knight-Captain** **1** (_Kingdom of Provenzia_) A knight who leads a company. **2** (_Kingdom of Provenzia_) Commands the guard in the field. — [[thalorna-note-affiliation-kingdom|Kingdom of Provenzia]]
-
-## O
-
-**Ordained Priest** _Lit._ (_Church of the Rite_) Ordained to serve a parish. — [[thalorna-note-affiliation-church|Church of the Rite]]
+The tongue of Provenzia, whose _solmère_ is its own word.
 ```
 
-The culture shapes both through its own `data.glossary`.
-`{name: solmère, common: true, pronunciation: sol-MEH-reh}` marks a word of its
-tongue common, so the first fence lists it, and gives it a respelling;
-`{name: Subject, common: true}` marks a rank and lets in a title of one word,
-which no glossary holds unless an entry names it; and
-`{name: blood-field, definition: …}` is a term of the culture's own.
+The list is generated once under that heading. Without such a heading, the
+build supplies **Dictionary** or **Glossary** at the end of the note.
 
-An affiliation lists its own terms with `WHERE owner = '<its Address>'`. The
-setting's two pages list everything, each word once and each term under every
-owner that holds it:
+### Custom views
 
-````markdown
-```sql {layout=dictionary}
-SELECT * EXCLUDE (common) FROM dictionary WHERE depth = 0
-```
-````
+An `sql` fence with `layout=dictionary` or `layout=glossary` can add a custom
+view of the same `dictionary` and `terms` relations. This one selects only a
+culture's common entries:
 
 ````markdown
-```sql {layout=glossary}
-SELECT * EXCLUDE (common) FROM terms
+# Words Everyone Knows {#common-words}
+
+```sql {layout=glossary section-level=2}
+SELECT * FROM terms WHERE owner = 'thalorna-note-lore-provenzianclt' AND common
 ```
 ````
 
-`package-build content-index` also writes both relations beside the index, for
-reading with `jq`:
+The `terms` relation also holds ranks and offices for custom queries. The
+default Glossary section selects only rows arising from its owner's explicit
+`data.glossary` entries, including an entry naming a rank or office. The
+[layout guide](../authoring/links-and-markup.md#dictionaries-and-glossaries)
+describes query options and rendering.
+
+`package-build content-index` writes both relations beside the index. To
+read a culture's own entries with `jq`:
 
 ```bash
-jq -r 'select(.cultures | index("thalorna-note-lore-provenzianclt")) | .name' \
+jq -r 'select(.owner == "thalorna-note-lore-provenzianclt") | .name' \
   build/content-index/thalorna-terms.jsonl
 ```
 
 The [format reference](../reference/format-details.md#dictionaries-and-glossaries)
-gives every column and every rule.
+gives every column and rule.
 
 ## Resolve another package