@heroiclands/package-build 24.0.0 → 24.0.2

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @heroiclands/package-build
 
+## 24.0.2
+
+### Patch Changes
+
+**Languages**
+
+- A language whose stress always falls on the first syllable says so with `stress: { two: first, longer: first }`, and its verse is scanned that way.
+- A reference note can state a setting's spelling guide as data: its letters and marks, with an `ipa` sound for each letter and final, and the languages that write each letter.
+
+**Scripts**
+
+- A `scroll` fence sets text in a script written in columns as a handscroll: columns read right to left, scrolling sideways on screen and continuing on panels in the book.
+- A language note names the script it is written in with `data.writtenIn: { map, font }`, so text marked with the language alone is set in that script; a run's own `map=` or `font=` still chooses another.
+
+## 24.0.1
+
+### Patch Changes
+
+**Sites**
+
+- The sitemap and site search list only the pages a reader can reach from the homepage, so a page can be published and read at its address before anything links it.
+- Related links, previous and next, and the other generated link sections point only to pages a reader can reach.
+- `site build` finishes writing the search index before it reports success.
+
+**Queries**
+
+- A query on a note's `data` reads the same however other notes are shaped; adding a field to one note no longer breaks unrelated queries.
+
 ## 24.0.0
 
 ### Major Changes

package/assets/preview/gitea.ini

@@ -9,7 +9,7 @@ RENDER_CONTENT_MODE = sanitized
 [markup.sanitizer.markdown.previewDiv]
 ELEMENT = div
 ALLOW_ATTR = class
-REGEXP = ^(hl-preview(?:-[a-z-]+)?|content-figure(?:-[a-z-]+)?|verse(?:-[a-z-]+)?|border)( (hl-preview(?:-[a-z-]+)?|content-figure(?:-[a-z-]+)?|verse(?:-[a-z-]+)?|border))*$
+REGEXP = ^(hl-preview(?:-[a-z-]+)?|content-figure(?:-[a-z-]+)?|verse(?:-[a-z-]+)?|scroll|border)( (hl-preview(?:-[a-z-]+)?|content-figure(?:-[a-z-]+)?|verse(?:-[a-z-]+)?|scroll|border))*$
 
 [markup.sanitizer.markdown.previewSpan]
 ELEMENT = span

package/assets/styles/content-base.css

@@ -285,6 +285,39 @@
     text-align: start;
 }
 
+/*
+ * A scroll: a script written in columns, top to bottom, read from the right,
+ * as a handscroll unrolls. Each paragraph starts a fresh column, flush at the
+ * top. The line height sets the column pitch: one em for the character and
+ * half an em between columns. `--scroll-rows` sets a column's length in
+ * characters; without it a column runs as long as its paragraph.
+ * `--scroll-cols` sets the panel's width in columns; without it the panel is
+ * as wide as its text. A panel wider than its container scrolls sideways,
+ * starting at the right.
+ */
+:is(.journal-entry-page, .journal-entry-content, .editor-content, .prosemirror) .scroll {
+    writing-mode: vertical-rl;
+    line-height: 1.5;
+    inline-size: max-content;
+    max-block-size: 100%;
+    overflow-x: auto;
+    overflow-y: hidden;
+    margin: 1rem 0;
+}
+
+:is(.journal-entry-page, .journal-entry-content, .editor-content, .prosemirror) .scroll[data-rows] {
+    inline-size: calc(var(--scroll-rows) * 1em);
+}
+
+:is(.journal-entry-page, .journal-entry-content, .editor-content, .prosemirror) .scroll[data-cols] {
+    block-size: calc(var(--scroll-cols) * 1.5em);
+}
+
+:is(.journal-entry-page, .journal-entry-content, .editor-content, .prosemirror) .scroll p {
+    margin: 0;
+    text-indent: 0;
+}
+
 /*
  * Emphasis in a script follows the script's convention, never a weight or a
  * slant the face does not have: the element keeps the face's Regular, and its

package/bin/content-commands.mjs

@@ -31,7 +31,7 @@
  *   npx package-build map [--tree] [--from <shortcode>] [--chart <shortcode>] [--travel] [--out <dir>]
  *   npx package-build reachability <dir> [file] [--index <shortcode>]
  *   npx package-build transliterate <map> [--lang <language>] [--font <slug>] [--hex] [text..]
- *   npx package-build lexicon <language> --map <map> [--font <slug>] [--derived] [--json]
+ *   npx package-build lexicon <language> [--map <map>] [--font <slug>] [--derived] [--json]
  *   npx package-build addresses diff --from <zip|dir> [--strict]
  *   npx package-build npc new (--spec <json> | --specfile <path>) [--seed <text>] [--out <path>]
  *
@@ -2472,7 +2472,8 @@ function transliterateCommand() {
                 })
                 .option("font", {
                     type: "string",
-                    describe: "The face; required when the map lists more than one",
+                    describe:
+                        "The face; the language's `data.writtenIn` face where the map is drawn in it, and required when neither it nor the map gives one",
                 })
                 .option("hex", {
                     type: "boolean",
@@ -2518,7 +2519,7 @@ function transliterateCommand() {
 }
 
 /**
- * `package-build lexicon <language> --map <map>` — every word of a language's
+ * `package-build lexicon <language> [--map <map>]` — every word of a language's
  * lexicon with its native form under a map, as the build writes it; with
  * `--derived`, the forms its rules derive follow, each naming its word in a
  * sixth column. Under a logographic map the third column says where a
@@ -2540,12 +2541,13 @@ function lexiconCommand() {
                 })
                 .option("map", {
                     type: "string",
-                    demandOption: true,
-                    describe: "The `data.map.name` of a mapping note",
+                    describe:
+                        "The `data.map.name` of a mapping note; the language's `data.writtenIn` map where left out",
                 })
                 .option("font", {
                     type: "string",
-                    describe: "The face; required when the map lists more than one",
+                    describe:
+                        "The face; the language's `data.writtenIn` face where the map is drawn in it, and required when neither it nor the map gives one",
                 })
                 .option("derived", {
                     type: "boolean",
@@ -2567,7 +2569,7 @@ function lexiconCommand() {
                 }
                 const listed = lexiconEntries(read.ctx, {
                     lang: String(argv.language),
-                    map: String(argv.map),
+                    map: argv.map === undefined ? undefined : String(argv.map),
                     font: argv.font,
                     derived: Boolean(argv.derived),
                 });

package/docs/api.md

@@ -1735,11 +1735,12 @@ A note's markdown, and a document plan, rendered as Typst source. **This module
 
 Which glyph an icon name resolves to, read from the font that carries it. {@link module:engine/content-icons} states an icon's family and its name and **deliberately holds no codepoints**: writing them out by hand would be a second copy of a table the font already owns, wrong the first time the icon set renumbers anything, and wrong silently. So the renderer resolves a name against the file it is going to embed, which is this module.
 
-| Export              | Signature                                        | Returns                                                             | Use it when                                                          |
-| ------------------- | ------------------------------------------------ | ------------------------------------------------------------------- | -------------------------------------------------------------------- |
-| `glyphTable`        | `function glyphTable(file)`                      | {Map<string, number>} Name → codepoint.                             | Every glyph name a font carries, with the codepoint that reaches it. |
-| `familyName`        | `function familyName(file)`                      | {string} The family name, or "" when the table cannot be read.      | The family name a font file announces, for Typst's `text(font: …)`.  |
-| `resolveIconGlyphs` | `function resolveIconGlyphs(registry, iconFonts` | {Map<string, {font: string, codepoint: number}>} Icon name → glyph. | Resolve every icon in a registry against the fonts a consumer named. |
+| Export              | Signature                                        | Returns                                                              | Use it when                                                          |
+| ------------------- | ------------------------------------------------ | -------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| `glyphTable`        | `function glyphTable(file)`                      | {Map<string, number>} Name → codepoint.                              | Every glyph name a font carries, with the codepoint that reaches it. |
+| `familyName`        | `function familyName(file)`                      | {string} The family name, or "" when the table cannot be read.       | The family name a font file announces, for Typst's `text(font: …)`.  |
+| `resolveIconGlyphs` | `function resolveIconGlyphs(registry, iconFonts` | {Map<string, {font: string, codepoint: number}>} Icon name → glyph.  | Resolve every icon in a registry against the fonts a consumer named. |
+| `tableDirectory`    | `function tableDirectory(buf)`                   | {Map<string, {offset: number, length: number}>} Its table directory. | The tables an sfnt file holds, by tag.                               |
 
 ### `engine.pdfBuild`
 

package/docs/authoring/links-and-markup.md

@@ -546,13 +546,105 @@ as a grid with a row per verse line.
 Each finding is an error at the text that is wrong; see
 [a verse in columns](../diagnostics.md#a-worked-case-a-verse-in-columns).
 
+### Scrolls
+
+Some scripts are written in vertical columns, top to bottom, with the columns
+read from the right, as on a handscroll. A `scroll` fence sets a passage in one
+of these scripts:
+
+````markdown
+```scroll {rows=25 cols=12 lang=tsu map=tengchou}
+chen teng chou hing
+tan tsou dou rou
+
+gen chei chou tsuen
+```
+````
+
+A scroll fence is a real code fence, so Markdown never reformats its body.
+
+- **Paragraphs.** The lines of a paragraph are joined into one text. Where
+  the source breaks a line makes no difference to where a column breaks. A
+  blank line starts a new paragraph, flush at the top of a fresh column, with
+  no indent and no mark between paragraphs. This follows classical practice.
+- **`rows=`** is the number of characters in a column, and **`cols=`** the
+  number of columns in a panel. Each is a whole number above zero, and either
+  may be left out.
+- **`lang=`, `font=` and `map=`** work as they do on a verse fence. See
+  [marking language, font and mapping](#marking-language-font-and-mapping).
+  The text is mapped before it is laid out, so under a
+  [logographic map](#logographic-maps) each word is written by its
+  characters, one to a morpheme. The map's rows decide what is written
+  between words, and a map for a script that runs its characters together
+  writes a space as nothing. If the fence names no `font=`, it takes the face
+  of its map, provided the map is drawn in exactly one face. A fence marked
+  only with a language whose note names its script, such as
+  ` ```scroll {rows=25 cols=12 lang=tsu} `, takes that script's map and face;
+  see [a language's script](#a-languages-script).
+- **The direction comes from the script.** The face's script note states
+  `direction: vertical-rl` in its `data.script`; see
+  [script notes and emphasis](../reference/format-details.md#script-notes-and-emphasis).
+  A script that states no direction is written in lines, and a scroll fence
+  set in it is an error. Markup never states a direction itself.
+- **Spans stay horizontal.** A `[…]{lang=… font=… map=…}` span in the same
+  script sets its characters left to right, inline, so a short phrase can sit
+  in a line of prose.
+
+**On the site, in the preview and in Foundry**, a scroll is a `<div
+class="scroll">` with one `<p>` for each paragraph. The stylesheet sets it
+with `writing-mode: vertical-rl`. A column is one em wide, with half an em
+between columns, so the column pitch is 1.5em.
+
+| Attribute | Stated                                                                      | Left out                                                    |
+| --------- | --------------------------------------------------------------------------- | ----------------------------------------------------------- |
+| `rows=N`  | Each column is N ems tall: `inline-size: calc(var(--scroll-rows) * 1em)`    | Each paragraph is a single column, as long as the paragraph |
+| `cols=M`  | The panel is M columns wide: `block-size: calc(var(--scroll-cols) * 1.5em)` | The panel is as wide as its text                            |
+
+The sizes are carried as `data-rows` and `data-cols`, and as the custom
+properties `--scroll-rows` and `--scroll-cols` in the element's `style`. A
+panel wider than its page, or than `cols` columns, scrolls sideways. It opens
+at the right, where the text begins, and unrolls to the left like a
+handscroll.
+
+**In the book**, Typst has no vertical writing, so the build draws each panel
+as an image from the face's own TrueType outlines. Each panel is an SVG of at
+most `rows` × `cols` characters, with its columns read from the right. Its alt
+text is the roman text it was written from. Panels follow one another from
+right to left and wrap down the page. Emphasis follows the script's convention:
+rubric characters are drawn in the book's red, and an overline is a rule to the
+right of the column.
+
+| Attribute | Stated                           | Left out                                                                                     |
+| --------- | -------------------------------- | -------------------------------------------------------------------------------------------- |
+| `rows=N`  | Each column holds N characters   | Each column holds as many characters as the longest paragraph, up to 40                      |
+| `cols=M`  | Each panel holds up to M columns | Each column is a panel of its own, so as many columns sit side by side as the measure allows |
+
+In the book, a space that a map leaves in the text takes up a whole cell.
+
+**Errors.** Each of these is an error at its line and column, reported by
+`lint`, the site build, the Foundry compile and the book:
+
+| Message                                                                                                                                                                                          | Fix                                                        |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------- |
+| `` `rows=0` is not a number of characters: `rows=` is a whole number above zero ``                                                                                                               | Write a whole number above zero, or leave the key out.     |
+| `` `cols=two` is not a number of columns: `cols=` is a whole number above zero ``                                                                                                                | Write a whole number above zero, or leave the key out.     |
+| `` `width=` is not a scroll attribute; a scroll takes `rows=`, `cols=`, `lang=`, `font=` and `map=` ``                                                                                           | Remove the key.                                            |
+| ``a `scroll` fence names the face it is set in, with `font=`, a map drawn in one face, with `map=`, or a language whose note names its script in `data.writtenIn`, with `lang=` ``               | Name the face, the map, or a language with a script.       |
+| ``the map `x` is drawn in more than one face; a `scroll` fence names its face with `font=` ``                                                                                                    | Add `font=`.                                               |
+| ``a `scroll` fence sets a script written in columns, and the script of `semaron-kuriale` is written in lines; set it in a face whose script note states `direction: vertical-rl`, or use a div`` | Set the text in a script written in columns, or use a div. |
+| `scroll fence is empty`, `scroll fence needs a closing code fence`, `` a scroll fence takes no `#id` ``                                                                                          | Write the text, close the fence, or remove the id.         |
+
+A fence with an error in its opening line is shown as code. A fence whose text
+has an error is set exactly as written.
+
 ## Marking language, font and mapping
 
-Three keys go in the attribute block a span, a fenced div or a verse fence
-already takes. Each is optional, and each does one thing:
+Three keys go in the attribute block a span, a fenced div, a verse fence or a
+[scroll fence](#scrolls) already takes. Each is optional, and each does one thing:
 
 - **`lang=`** names the language of the text. It becomes the element's
-  language tag and changes nothing else.
+  language tag, and where the language's note names
+  [its script](#a-languages-script), the run takes that script's map and face.
 - **`font=`** names the font the text is set in: one of the faces of
   `@heroiclands/fonts`, or `mono`, `serif` or `sans`.
 - **`map=`** names a [mapping note](#mapping-notes), which rewrites the text
@@ -606,6 +698,60 @@ Zaron tholmeza, [an oath, a vow]{lang=en font=serif}.
 :::
 ```
 
+### A language's script
+
+A language note can name the script its language is written in, as one map and
+one face, in `data.writtenIn`:
+
+```yaml
+data:
+  writtenIn: { map: semaron, font: semaron-kuriale }
+```
+
+A run marked with that language alone is then mapped and set as though it named
+both. With Vylari's note stating the default above, these two spans are set
+identically:
+
+```markdown
+The lintel is cut with [Zaron tholmeza]{lang=vyl}.
+The lintel is cut with [Zaron tholmeza]{lang=vyl font=semaron-kuriale map=semaron}.
+```
+
+The same holds for a div, a verse fence and a [scroll fence](#scrolls). A run
+fills in what it leaves unstated, and an explicit key overrides its half of the
+default:
+
+| The run states             | It takes from the language                                     |
+| -------------------------- | -------------------------------------------------------------- |
+| neither `map=` nor `font=` | the map and the face                                           |
+| `font=` alone              | the map, where the map is drawn in that face; otherwise no map |
+| `map=` alone               | the face, where that map is drawn in it; otherwise no face     |
+| both                       | nothing                                                        |
+
+So a language written in more than one script names its usual one in
+`data.writtenIn` and marks a run in another with that script's keys:
+`[Gar-Anlagh]{lang=khel font=qalezu-hand map=qalezu}`. `[Zaron]{lang=vyl
+font=serif}` sets Vylari in the page's serif, unmapped, since Semaron's map is
+not drawn in it.
+
+The default is the run's own language's, read after a div or fence around the
+run gives it its keys. Inside `::: {lang=vyl}`, a gloss marked
+`[an oath]{lang=en}` takes no face from Vylari. A language whose note states no
+`data.writtenIn` marks its runs with its tag alone.
+
+`lint` checks the key on the language note: `map` must be the `data.map.name`
+of a mapping note in the package, and `font` one of the faces that map lists.
+Each is an error at its value, and the default then fills no run:
+
+> `` `data.writtenIn.map` is `semoran`, which no mapping note's `data.map.name` declares; did you mean `semaron`? ``
+>
+> `` `data.writtenIn.font` is `teng-chou`, which the map `semaron` is not drawn in; it is drawn in `semaron-kuriale` ``
+>
+> `` `data.writtenIn` names the script a language is written in, and this note's `subType` is not `language` ``
+
+The face a language's script names is delivered with the package's fonts, as a
+face named by `font=` is.
+
 ### What `lang=` takes
 
 `lang=` is read in this order:
@@ -622,7 +768,8 @@ still a well-formed tag, such as `vly` for `vyl`, is read as the tag of a real
 language. When such a value is within one edit of a declared name (a letter
 added, dropped or changed, two neighbours swapped, or a different case), `lint`
 warns and names the declared language. Text marked with `lang=` alone is not
-checked against any lexicon; a run with `lang=` and `map=` is, as
+checked against any lexicon unless its language names
+[its script](#a-languages-script); a run with `lang=` and a map is, as
 [a mapped run's words](#a-mapped-runs-words) describes.
 
 ### What `font=` takes
@@ -993,13 +1140,14 @@ finding the lint reports in `data.map`.
 Every target rewrites marked text first, so a page, a Foundry journal and a
 book all show the same thing.
 
-| Marking                                | The text                           | The element                                                              |
-| -------------------------------------- | ---------------------------------- | ------------------------------------------------------------------------ |
-| `lang=` alone                          | As written                         | Tagged with the language's tag, `lang="art-x-vyl"`                       |
-| `map=`                                 | Rewritten by the map, line by line | As below                                                                 |
-| `font=` a face                         | As written, or as the map wrote it | The tag, `script` and the face's class; not indexed by the site's search |
-| `font=mono`, `serif`, `sans`           | As written, or as the map wrote it | The tag and `font-mono`, `font-serif` or `font-sans`                     |
-| A div or fence in a right-to-left face | As above                           | Also `dir="rtl"`; a div also carries `script-block`                      |
+| Marking                                | The text                           | The element                                                               |
+| -------------------------------------- | ---------------------------------- | ------------------------------------------------------------------------- |
+| `lang=` alone                          | As written                         | Tagged with the language's tag, `lang="art-x-vyl"`                        |
+| `map=`                                 | Rewritten by the map, line by line | As below                                                                  |
+| `font=` a face                         | As written, or as the map wrote it | The tag, `script` and the face's class; not indexed by the site's search  |
+| `font=mono`, `serif`, `sans`           | As written, or as the map wrote it | The tag and `font-mono`, `font-serif` or `font-sans`                      |
+| A div or fence in a right-to-left face | As above                           | Also `dir="rtl"`; a div also carries `script-block`                       |
+| A scroll fence                         | Each paragraph on one line         | `scroll`, the tag, `script` and the face's class; see [scrolls](#scrolls) |
 
 No target writes `<bdo>`, `<bdi>` or a Unicode direction control character: a
 right-to-left face's code points carry their own direction. Text with an error
@@ -1135,7 +1283,7 @@ SELECT owner, kind, tag, font, line FROM runs WHERE lang = 'vyl' ORDER BY owner,
 ```
 ````
 
-Its columns are `owner`, `kind` (`span`, `block` or `verse`), `lang` as written,
+Its columns are `owner`, `kind` (`span`, `block`, `verse` or `scroll`), `lang` as written,
 the `tag` it resolves to (`NULL` when it resolves to none), `font`, `map`, `line`
 and `column`. A run inside a div or a fence records the keys it inherits. See
 [the `runs` relation](../reference/format-details.md#content-tables).
@@ -1297,7 +1445,7 @@ A column's heading is its SQL alias, so `AS "Name"` is what a reader sees. A cel
 | `entries`          | Every note, stubs included.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `events`           | One row per event a `lore`, `place` or `affiliation` note writes in `data.events`, with `whenSort` to order them by date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `names`            | Each authored `.name` span, with its containing NOTE Address, visible text, optional type/subtype and source line/column.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `runs`             | Each span, div and verse fence marked with `lang=`, `font=` or `map=`, with its containing NOTE Address, its `kind`, `lang` as written, the `tag` it resolves to, `font`, `map`, and source line/column. See [marking language, font and mapping](#marking-language-font-and-mapping).                                                                                                                                                                                                                                                                                                                                                 |
+| `runs`             | Each span, div and verse fence marked with `lang=`, `font=` or `map=`, with its containing NOTE Address, its `kind`, `lang` as written, the `tag` it resolves to, the `font` and `map` it is set with (its own, inherited, or its language's [script](#a-languages-script)), and source line/column. See [marking language, font and mapping](#marking-language-font-and-mapping).                                                                                                                                                                                                                                                     |
 | `maps`             | One row per row of a mapping note's `data.map`, with its containing NOTE Address, the map's `name`, the `font` whose own row it is (`NULL` for a shared row), the row's 1-based place as `"row"`, and its `"from"`, `"to"`, `before` and `"at"`. See [mapping notes](#mapping-notes).                                                                                                                                                                                                                                                                                                                                                  |
 | `natives`          | One row per native form a language note's word states in `native`, with that note as its `language`, the word's place as `word`, its `form`, the entry's place as `native`, and its `map`, `font` and `"text"`. See [what `map=` takes](#what-map-takes).                                                                                                                                                                                                                                                                                                                                                                              |
 | `words`            | One row per word a language note writes in `data.words`, with that note as its `language`, its `position` and what it is built from.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
@@ -1311,16 +1459,16 @@ A column's heading is its SQL alias, so `AS "Name"` is what a reader sees. A cel
 | `tongues`          | One row per tag a language note writes in `data.tongues`: `tag`, `meaning` and `tongue_language`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `retired`          | One row per form a language note writes in `data.retired`: `form`, `instead` as a list, and `why`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `scope`            | One row per value of a language note's `data.scope`: the `kind` it is under and the `value`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `letters`          | One row per entry of a language note's `data.sounds.letters`: `letters` as a list, `kind`, `like`, `place` and `tongue`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `letters`          | One row per entry of a language note's or a spelling guide's `data.sounds.letters`: `letters` as a list, `kind`, `like`, `place`, `ipa` and `tongue`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `edges`            | One row per entry of a language note's `data.sounds.edges`: the `edge` and its `sounds` as a list.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `clusters`         | One row per language note stating `data.sounds.clusters`, with its `max`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `cluster_groups`   | One row per group of a language note's `data.sounds.clusters.groups`: `what`, `clusters` as a list, and `use`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `stress`           | One row per language note stating `data.sounds.stress`, with its `two`, `longer` and `mark` (`NULL` where unstated).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `finals`           | One row per entry of a language note's `data.sounds.finals`: `final` and `like`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `finals`           | One row per entry of a language note's `data.sounds.finals`: `final`, `like` and `ipa`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `syllables`        | One row per language note stating `data.sounds.syllables`: each rule a column, the harmony as `harmony_back`, `harmony_front`, `harmony_neutral`, `harmony_neutralAs` and `harmony_partners`, a list of `{ vowel, partner }`.                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `joining`          | One row per entry of a language note's `data.sounds.joining`: `first`, `second`, `written` and `example`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `joins`            | One row per entry of a language note's `data.sounds.joins`: `meeting`, `rule`, `letters` and `"where"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `marks`            | One row per entry of a language note's `data.sounds.marks`: `mark`, `letters`, `kind` and `"limit"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `marks`            | One row per entry of a language note's or a spelling guide's `data.sounds.marks`: `mark`, `letters`, `kind` and `"limit"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `skeleton`         | One row per entry of a language note's `data.sounds.skeleton`: `second` and `between`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `frames`           | One row per frame of a language note's `data.sounds.frames`: `frame`, `shape`, `class`, `makes` and `examples` as `{ root, form }`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `read_past`        | One row per entry of a language note's `data.sounds.readPast`: `written`, `readAs` and `what`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |

package/docs/commands.md

@@ -657,12 +657,14 @@ The rules are scoped to those hostnames, so a site deployed under a domain of
 its own stays indexable.
 
 With `_headers` written, the rendered site is indexed for search. Pagefind
-reads every page under `<out>/<contentPackage>/` and writes the index into
+reads the pages under `<out>/<contentPackage>/` that are reachable from the
+homepage (see [the pages a reader finds](guides/site.md#decide-which-pages-a-reader-finds))
+and writes the index into
 `<out>/<contentPackage>/pagefind/`, so it is deployed with the pages and served
 at `/<contentPackage>/pagefind/`; the theme loads `pagefind.js` from there,
 relative to the site's base URL, and the browser bundle derives the prefix from
 its own address, so nothing about the prefix is configured on either side. What
-is indexed is the body of every page and the homepage; the theme marks its own
+is indexed is the body of every reachable page and the homepage; the theme marks its own
 chrome — header, footer, breadcrumbs, infobox, the related-pages card —
 `data-pagefind-ignore`, and carries `data-pagefind-filter` attributes for a
 page's `type` and `package`, so a search can be narrowed to one kind of page.
@@ -2577,7 +2579,7 @@ emptied first:
   `site.sections` names at its section, every other note at
   `<type>-<shortcode>/` — each minified;
 - `404.html`, the page-not-found page `site.notfound` describes;
-- `sitemap.xml`, every page by its full address;
+- `sitemap.xml`, the full address of every page reachable from the homepage;
 - the theme's stylesheets, scripts, icon font and images, and `css/code.css`;
 - the script fonts the notes set text in, under
   `fonts/heroiclands/<version>/`;
@@ -2595,8 +2597,8 @@ page-not-found page and reported as a warning located at that entry of
 the content tree is an error located at its entry, and writes nothing.
 
 Then, as `package-build site-root` does, `_headers` is written at `<out>/` and
-the pages are indexed for search into `pagefind/` inside the site's directory,
-unless `site.search` is `false`. With `site.mergeIndexes`, the search reads
+the pages reachable from the homepage are indexed for search into `pagefind/`
+inside the site's directory, unless `site.search` is `false`. With `site.mergeIndexes`, the search reads
 each package site's index beside its own. What a page tells the search is set
 out in the [site guide](guides/site.md#search).
 
@@ -3099,11 +3101,11 @@ from standard input, less one trailing newline. Writes nothing.
 | `map`      | string           | —       | The `data.map.name` of a mapping note. |
 | `text`     | string, variadic | stdin   | The passage; `-` reads it from stdin.  |
 
-| Option   | Type    | Default                    | Description                                                                     |
-| -------- | ------- | -------------------------- | ------------------------------------------------------------------------------- |
-| `--lang` | string  | —                          | A language declared in `languages`, whose lexicon is read first.                |
-| `--font` | string  | the map's one face, if one | The face, whose own rows come first; required when the map lists more than one. |
-| `--hex`  | boolean | `false`                    | Print the code points, as `U+XXXX` separated by spaces.                         |
+| Option   | Type    | Default                                                                           | Description                                                                                           |
+| -------- | ------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `--lang` | string  | —                                                                                 | A language declared in `languages`, whose lexicon is read first.                                      |
+| `--font` | string  | the language's face where the map is drawn in it, else the map's one face, if one | The face, whose own rows come first; required when neither gives one and the map lists more than one. |
+| `--hex`  | boolean | `false`                                                                           | Print the code points, as `U+XXXX` separated by spaces.                                               |
 
 **EXIT STATUS**
 
@@ -3156,14 +3158,15 @@ List a language's words with their native forms under a map.
 **SYNOPSIS**
 
 ```
-package-build lexicon <language> --map <map> [--font <slug>] [--derived] [--json]
+package-build lexicon <language> [--map <map>] [--font <slug>] [--derived] [--json]
 ```
 
 **DESCRIPTION**
 
 Reads the content index and lists every word of the language note
 [`languages.<language>.note`](configuration.md#languages) names, in `data.words`
-order, each with its native form under `<map>`: the stated exception where the
+order, each with its native form under `<map>`, or under the script the
+language note names in `data.writtenIn` when `--map` is left out: the stated exception where the
 word has one, else the rows' spelling, each exactly as
 `package-build transliterate` and the build give it. Each line holds, separated
 by tabs, the word's `form`, its native form, `exception` or `rows`, its `class`
@@ -3194,17 +3197,18 @@ the lexicon's own words. A derived line carries its word's `class` and `gloss`.
 | ---------- | ------ | ------- | --------------------------------------------------- |
 | `language` | string | —       | A declared language whose `note` names its lexicon. |
 
-| Option      | Type    | Default                    | Description                                                                                                                                                                                                                                      |
-| ----------- | ------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `--map`     | string  | —                          | Required: the `data.map.name` of a mapping note.                                                                                                                                                                                                 |
-| `--font`    | string  | the map's one face, if one | The face; required when the map lists more than one.                                                                                                                                                                                             |
-| `--derived` | boolean | `false`                    | Also list the forms the language's rules derive, each with the word it comes from.                                                                                                                                                               |
-| `--json`    | boolean | `false`                    | Print a JSON array of `{ form, native, exception, class, gloss }` instead; a derived form adds `from`. Under a logographic map `source` (`own`, `parts` or `none`) takes the place of `exception`, and an ambiguous word adds `ambiguous: true`. |
+| Option      | Type    | Default                                                                           | Description                                                                                                                                                                                                                                      |
+| ----------- | ------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `--map`     | string  | the language's `data.writtenIn` map                                               | The `data.map.name` of a mapping note; required when the language note states no `data.writtenIn`.                                                                                                                                               |
+| `--font`    | string  | the language's face where the map is drawn in it, else the map's one face, if one | The face; required when neither gives one and the map lists more than one.                                                                                                                                                                       |
+| `--derived` | boolean | `false`                                                                           | Also list the forms the language's rules derive, each with the word it comes from.                                                                                                                                                               |
+| `--json`    | boolean | `false`                                                                           | Print a JSON array of `{ form, native, exception, class, gloss }` instead; a derived form adds `from`. Under a logographic map `source` (`own`, `parts` or `none`) takes the place of `exception`, and an ambiguous word adds `ambiguous: true`. |
 
 **EXIT STATUS**
 
 1 if the content index could not be built for any note, or the language, the
-map or the face names nothing, the language states no `note`, or a capitalised
+map or the face names nothing, no map is named and the language note states no
+`data.writtenIn`, the language states no `note`, or a capitalised
 word has a native form the rows cannot capitalise, each reported as a finding.
 Otherwise 0.
 

package/docs/configuration.md

@@ -767,11 +767,27 @@ spells every other word by the map's rows; see
 Every word of such a run is a word of the lexicon, of a name the language note's
 own register lists, or a regular form of a lexicon word, and any other word is an error; see
 [a mapped run's words](authoring/links-and-markup.md#a-mapped-runs-words).
+The language note may also name the script the language is written in, as
+`data.writtenIn: { map, font }`, and a run marked with the language alone is
+then mapped and set in it; see
+[a language's script](authoring/links-and-markup.md#a-languages-script). The
+script belongs to the language note, and the configuration never states it.
 A language with no `note` tags its text and has no lexicon. Whether the note
 resolves is checked by `package-build lint`, at the key:
 
 > ``package-build.config.yaml:5:5: error: `languages.vyl.note` is `skill-vylarilg`, which names no language note in thalorna; it names a skill note whose subType is language``
 
+**The direction text is written in** belongs to the script, not to the
+language, and the configuration never states it. Where the script note listing
+a face states `direction: vertical-rl` in its `data.script`, text in that face
+is written in columns, top to bottom, with the columns read from the right. A
+passage of it goes in a
+[`scroll` fence](authoring/links-and-markup.md#scrolls). On the site, in the
+preview and in Foundry, the fence is set with `writing-mode: vertical-rl` in a
+panel that scrolls sideways from the right. In the book, its panels are images
+drawn from the face's TrueType file, which the installed fonts package lists
+under `files.ttf`. A span in the same face stays horizontal.
+
 The shape is checked when the configuration loads, and each fault is a
 configuration error at its key: