@heroiclands/package-build 24.0.1 → 24.0.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @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

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

@@ -3101,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**
 
@@ -3158,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`
@@ -3196,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:
 

package/docs/content-format.md

@@ -31,7 +31,9 @@ Leading `:` captions describe the next supported block; `:@` captions also numbe
 
 A code fence with language `verse` keeps verse lines, stanza breaks and relative indentation. Its numbered caption uses the **Poem** label. Generic `:::` divs and `[inline spans]{.class}` accept attributes. See [verse](authoring/links-and-markup.md#verse), [fenced divs](authoring/links-and-markup.md#fenced-divs) and [inline spans](authoring/links-and-markup.md#inline-spans). `numstep=N` numbers every Nth line. `col1=` and `col2=` set the poem in at most two columns, each a `:`-joined stack of `language[/mapping[/font]]` entries, the first in the normal tone and the rest in grey; with columns, each blank-line group of `[text]{lang=…}` spans is one verse line, every entry sets the span in its language, and a `***` line breaks the stanza. See [verse in columns](authoring/links-and-markup.md#verse-in-columns).
 
-A span, a generic div or a verse fence marks its text's language with `lang=`, the font it is set in with `font=` and a mapping with `map=`, each optional, and the runs inside a div or a fence inherit its keys. `lang=` is a name the package declares in `languages` or a BCP 47 tag, and gives the language tag alone. `font=` is a face of the installed `@heroiclands/fonts`, named by its class without `hl-`, or `mono`, `serif` or `sans`. `map=` names a mapping note: a `doc` note whose `data.map` lists the fonts it is drawn in and rows that rewrite the text before it is set, a font's own rows first. With `lang=` naming a language whose configured `note` names its language note, a word whose entry states a `native` form for the map is written by it, and the rows spell every other word. A map stating `logographic: true` spells no word by its rows: each word is written by its own `native` entry or its parts' writings, and a word with neither, or whose form stands for entries written differently, is a located error. Every word of such a run is a lexicon form, a word of a name the language note's own register lists under a tongue other than `translation`, or a form a plural row, the verb pattern or an affix stating `replaces` derives from a lexicon form, and any other word is an error at the word. A character a face does not draw, after the map, is an error at the character it came from. A verse fence that states `scan=` (the `name` of a `data.metres` entry of a `doc` note) with a `lang=` whose language note states `data.sounds.stress` is counted line by line by the beat convention, and a line that cannot have the metre's beats is a warning at the line; see [metres](reference/format-details.md#metres). Text with a font, a map or a declared language is plain, except that text set in a face takes `*…*` and `**…**`: they render by the convention its language note's `data.emphasis` states, else the one the script note listing its face states in `data.script` (`rubric` or `overline`), else plainly, and a language whose `data.emphasis` is `words` makes them an error. Every marked construct is a row of the `runs` relation, every mapping row of the `maps` relation, and every native form of the `natives` relation. See [marking language, font and mapping](authoring/links-and-markup.md#marking-language-font-and-mapping).
+A code fence with language `scroll` sets text in a script whose script note states `direction: vertical-rl` as columns, top to bottom, read from the right. The lines of a paragraph are joined, and each paragraph starts a fresh column. `rows=N` is the characters in a column and `cols=M` the columns in a panel, each a whole number above zero; `lang=`, `font=` and `map=` mark the text as on a verse fence, and a fence naming no `font=` takes the face of a map drawn in one. The site, the preview and Foundry set it with `writing-mode: vertical-rl` in a panel that scrolls sideways from the right; the book draws its panels as images from the face's outlines, each with its roman text as alt text. A scroll fence in a script written in lines is an error. See [scrolls](authoring/links-and-markup.md#scrolls).
+
+A span, a generic div, a verse fence or a scroll fence marks its text's language with `lang=`, the font it is set in with `font=` and a mapping with `map=`, each optional, and the runs inside a div or a fence inherit its keys. `lang=` is a name the package declares in `languages` or a BCP 47 tag, and gives the language tag; where the language note states `data.writtenIn`, the script the language is written in as a `map` and a `font` the map lists, a run marked with the language alone takes that map and face, and a run's own `map=` or `font=` overrides its half of the default. `font=` is a face of the installed `@heroiclands/fonts`, named by its class without `hl-`, or `mono`, `serif` or `sans`. `map=` names a mapping note: a `doc` note whose `data.map` lists the fonts it is drawn in and rows that rewrite the text before it is set, a font's own rows first. With `lang=` naming a language whose configured `note` names its language note, a word whose entry states a `native` form for the map is written by it, and the rows spell every other word. A map stating `logographic: true` spells no word by its rows: each word is written by its own `native` entry or its parts' writings, and a word with neither, or whose form stands for entries written differently, is a located error. Every word of such a run is a lexicon form, a word of a name the language note's own register lists under a tongue other than `translation`, or a form a plural row, the verb pattern or an affix stating `replaces` derives from a lexicon form, and any other word is an error at the word. A character a face does not draw, after the map, is an error at the character it came from. A verse fence that states `scan=` (the `name` of a `data.metres` entry of a `doc` note) with a `lang=` whose language note states `data.sounds.stress` is counted line by line by the beat convention, and a line that cannot have the metre's beats is a warning at the line; see [metres](reference/format-details.md#metres). Text with a font, a map or a declared language is plain, except that text set in a face takes `*…*` and `**…**`: they render by the convention its language note's `data.emphasis` states, else the one the script note listing its face states in `data.script` (`rubric` or `overline`), else plainly, and a language whose `data.emphasis` is `words` makes them an error. Every marked construct is a row of the `runs` relation, every mapping row of the `maps` relation, and every native form of the `natives` relation. See [marking language, font and mapping](authoring/links-and-markup.md#marking-language-font-and-mapping).
 
 Mark a name without a note as `[Name]{.name data-type="being"}`; the optional
 classification uses the declared note vocabulary. The [name-marking
@@ -175,6 +177,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 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`. A `doc` note states a setting's core concepts in `data.concepts`, a language note says it must cover them with `data.core: true`, and a word names the concepts it serves in `concept`; `package-build core` lists what each covering language has no word for (see [the core vocabulary](reference/format-details.md#the-core-vocabulary)). 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, and a name tagged `other:<tongue>` or `exonym:<tongue>` one that the tongue's own language note registers under that tongue), `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 (`two`, `longer` and `mark`), 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).
+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`. A `doc` note states a setting's core concepts in `data.concepts`, a language note says it must cover them with `data.core: true`, and a word names the concepts it serves in `concept`; `package-build core` lists what each covering language has no word for (see [the core vocabulary](reference/format-details.md#the-core-vocabulary)). 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, and a name tagged `other:<tongue>` or `exonym:<tongue>` one that the tongue's own language note registers under that tongue), `data.retired`, `data.scope`, `data.sounds` (letters with their place, their IPA and the tongues that write them, each a declared tag or a language note's Address, word edges from a closed list, the cluster limit and the groups of clusters inside a word, the stress rule (`two`, `longer`, which may be `first`, and `mark`), syllable finals with their IPA, 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 `doc` note may state a spelling guide's `data.sounds.letters` and `data.sounds.marks` alone, its letter rows naming tongues by language note Addresses, and they join the `letters` and `marks` relations under the guide's Address. 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).