@heroiclands/package-build 24.0.1 → 24.0.3

package/docs/commands.md

@@ -1718,13 +1718,11 @@ package-build deps fetch [--from <zip|dir>] [--id <id>]
 The only action is `fetch`, which fills three caches under `build/cache/`:
 the **content index** of every declared dependency and of every
 `recommends` or `conflicts` relationship that declares `itemCatalog: true`,
-the **item catalogue or
-asset archive** of those that additionally declare `itemCatalog: true` or
-`assetArchive: true`, and the **site navigation** —
+the **item catalogue** of those that additionally declare `itemCatalog: true`,
+and the **site navigation** —
 `https://www.heroiclands.org/nav.json`, the header menu every package site
 renders, fetched for every package because every package publishes a site.
-A relationship declaring both `itemCatalog: true` and `assetArchive: true`
-is fetched once. Its own command rather than a step of `package compile` or
+Its own command rather than a step of `package compile` or
 `site`, so neither reaches the network — a build that downloads silently is
 not reproducible and hides a dependency's version change behind a passing
 run. Each cache is stamped complete only once its fetch finishes, so a
@@ -1766,7 +1764,7 @@ including when the repository declares no dependencies at all.
 ```
 $ package-build deps fetch
 […] Fetched the site navigation to build/cache/navigation/nav.json.
-[…] No relationship declares `itemCatalog: true` or `assetArchive: true`; nothing to fetch.
+[…] No relationship declares `itemCatalog: true`; nothing to fetch.
 […] This package declares no dependencies.
 
 $ package-build deps fetch --from build/dist/module.zip
@@ -3101,11 +3099,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 +3156,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 +3195,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

@@ -606,7 +606,7 @@ HeroicLands layout, resolved against `rootDir`:
 | `paths.packJson`        | `build/packs-json`       | Build-only per-entry JSON intermediate.                                                                                            |
 | `paths.stage`           | `build/stage/packs`      | Compiled LevelDB packs.                                                                                                            |
 | `paths.unpack`          | `build/tmp/packs`        | Where `unpack` extracts JSON back to.                                                                                              |
-| `paths.foreignCache`    | `build/cache/foreign`    | Where a dependency declaring `itemCatalog: true` or `assetArchive: true` is unpacked.                                              |
+| `paths.foreignCache`    | `build/cache/foreign`    | Where a dependency declaring `itemCatalog: true` is unpacked.                                                                      |
 | `paths.metadataCache`   | `build/cache/metadata`   | Where a published content index is fetched to, for every declared dependency and every relationship declaring `itemCatalog: true`. |
 | `paths.navigationCache` | `build/cache/navigation` | Where the site navigation heroiclands.org publishes is fetched to, for the site's menu.                                            |
 
@@ -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:
 
@@ -1212,7 +1228,7 @@ writes its own `sitemap.xml` whether or not it states this key.
 ```yaml
 site:
   base: /
-  sitemaps: [sohl, hm3, thalorna, kethira, thalornaaltart, harnensemble, harnadventures]
+  sitemaps: [sohl, hm3, thalorna, kethira, harnensemble, harnadventures]
 ```
 
 `site.mergeIndexes` names the package sites, by `contentPackage`, whose search
@@ -1259,7 +1275,7 @@ site:
     projects: doc-projects
   feed: blog
   tags: true
-  sitemaps: [sohl, hm3, thalorna, kethira, thalornaaltart, harnensemble, harnadventures]
+  sitemaps: [sohl, hm3, thalorna, kethira, harnensemble, harnadventures]
   mergeIndexes: [sohl, thalorna, kethira, harnensemble]
 ```
 
@@ -1629,17 +1645,15 @@ system relationship it declares — see [`stats.systemVersion`](#statssystemvers
 
 Each entry, in any of the four lists:
 
-| Key (under `relationships.<kind>[]`)       | Type                            | Required | Default |
-| ------------------------------------------ | ------------------------------- | -------- | ------- |
-| `relationships.systems[].id`               | string                          | yes      | —       |
-| `relationships.systems[].contentPackage`   | string                          | no       | the id  |
-| `relationships.systems[].type`             | string                          | no       | none    |
-| `relationships.systems[].manifest`         | string                          | no       | none    |
-| `relationships.systems[].compatibility`    | object, `{minimum?, verified?}` | no       | none    |
-| `relationships.systems[].itemCatalog`      | boolean                         | no       | `false` |
-| `relationships.systems[].assetArchive`     | boolean                         | no       | `false` |
-| `relationships.systems[].contentIndex`     | boolean                         | no       | `true`  |
-| `relationships.systems[].assetReplacement` | boolean                         | no       | `false` |
+| Key (under `relationships.<kind>[]`)     | Type                            | Required | Default |
+| ---------------------------------------- | ------------------------------- | -------- | ------- |
+| `relationships.systems[].id`             | string                          | yes      | —       |
+| `relationships.systems[].contentPackage` | string                          | no       | the id  |
+| `relationships.systems[].type`           | string                          | no       | none    |
+| `relationships.systems[].manifest`       | string                          | no       | none    |
+| `relationships.systems[].compatibility`  | object, `{minimum?, verified?}` | no       | none    |
+| `relationships.systems[].itemCatalog`    | boolean                         | no       | `false` |
+| `relationships.systems[].contentIndex`   | boolean                         | no       | `true`  |
 
 (the same keys apply under `requires[]`, `recommends[]` and
 `conflicts[]`.)
@@ -1648,7 +1662,7 @@ Each entry, in any of the four lists:
 
 > ``package-build config: `relationships.<kind>[<index>].id` must be a non-empty string.``
 
-> ``package-build config: `relationships.<kind>[<index>].<key>` is not a recognized option (expected one of: id, contentPackage, type, manifest, compatibility, itemCatalog, assetArchive, contentIndex, assetReplacement).``
+> ``package-build config: `relationships.<kind>[<index>].<key>` is not a recognized option (expected one of: id, contentPackage, type, manifest, compatibility, itemCatalog, contentIndex).``
 
 `contentPackage` names what the other package's _content_ is called, where
 that differs from its Foundry id. A note addresses a file by the content
@@ -1669,31 +1683,6 @@ embedded-item addresses the compile does. It requires a `manifest`:
 
 > ``package-build config: `relationships.<kind>[<index>].itemCatalog` needs a `manifest` naming the package to fetch.``
 
-`assetArchive` opts into unpacking the named package's release archive for
-its asset bytes alone — the sibling of `itemCatalog`, for a dependency whose
-bytes are wanted and whose items are not. It builds no item catalogue from
-the archive, which is what distinguishes it from `itemCatalog: true`. It
-requires a `manifest`:
-
-> ``package-build config: `relationships.<kind>[<index>].assetArchive` must be true or false.``
-
-> ``package-build config: `relationships.<kind>[<index>].assetArchive` needs a `manifest` naming the package to fetch.``
-
-A relationship with no items of its own to extract, such as an asset
-replacement module, declares only `assetArchive: true`:
-
-```yaml
-relationships:
-  requires:
-    - id: thalornaaltart
-      manifest: https://…/releases/latest/download/module.json
-      compatibility: { verified: "1.0.0" }
-      assetArchive: true
-```
-
-A relationship declaring both `itemCatalog: true` and `assetArchive: true` is
-fetched once: `deps fetch` does not download the archive twice for one entry.
-
 `contentIndex` and `itemCatalog` are the two edges a relationship may declare,
 and a package may have either without the other. `itemCatalog` says a
 dependency supplies _items_; `contentIndex`, `true` by default, says
@@ -1713,35 +1702,6 @@ demand.
 
 > ``package-build config: `relationships.<kind>[<index>].contentIndex` cannot be false together with `itemCatalog: true` — a catalogue is fetched from the same index.``
 
-`assetReplacement` opts a relationship into serving this package's own asset
-addresses from the named dependency's tree instead of its local one —
-`engine/asset-replacement.mjs`'s `resolveAssetReplacement` is what reads the
-declaration. Off by default: declaring a dependency is not the same as
-wanting its pictures in place of the ones this package ships itself. It
-requires a fetched index to check the replacement against, so it cannot pair
-with `contentIndex: false`:
-
-```yaml
-relationships:
-  requires:
-    - id: thalornaaltart
-      manifest: https://…/releases/latest/download/module.json
-      assetReplacement: true
-      contentIndex: true
-```
-
-With that declared, an address `thalorna` would otherwise answer itself —
-`thalorna-none-image-thorn` — resolves against
-`thalornaaltart-none-image-thorn` first, falling back to `thalorna`'s own
-record when `thalornaaltart` carries no file at that address. A package
-declaring more than one `assetReplacement: true` relationship is tried in
-the order the relationships are declared, and the first one carrying the
-address wins.
-
-> ``package-build config: `relationships.<kind>[<index>].assetReplacement` must be true or false.``
-
-> ``package-build config: `relationships.<kind>[<index>].assetReplacement` cannot be true together with `contentIndex: false` — a replacement with no fetched index to check against resolves nothing.``
-
 ### `systems`
 
 **Type:** object (`{id: spec}`) · **Optional** · default `{}`. Refused in a

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).

package/docs/guides/site.md

@@ -247,7 +247,9 @@ generated after a note's text (Within, Governed by, Governed places,
 Chronology, Events, Accounts, What followed, In song and story). Each is drawn
 without a link to a page outside the reachable set, and a section left with
 nothing under it is not drawn. An infobox value that names an unreachable page
-is set as plain text. A link written in prose or produced by a query is kept
+is set as plain text. So is a link in a dictionary or glossary entry, whether
+it names a word's entry, cites a note or sits in a gloss; it does not make its
+target reachable. A link written in prose or produced by a query is kept
 wherever it points, and it is what makes its target reachable.
 
 A page that is not reachable is the way to preview a page in place. Write the

package/docs/guides/writing-in-invented-scripts.md

@@ -142,6 +142,29 @@ address of the language's `skill` note of `subType: language`, whose
 Without `note`, `lang=` only tags: there is no dictionary and no lexicon check.
 `package-build lint` checks at the key that `note` names a language note.
 
+**A language names its script.** Most tongues are written in one script, so the
+language note says which, as one map and one face:
+
+```yaml
+data:
+  writtenIn: { map: semaron, font: semaron-kuriale }
+```
+
+A run marked with the language alone then takes both: `[Zaron lonak]{lang=vyl}`
+is mapped through Semaron and checked against Vylari exactly as
+`[Zaron lonak]{lang=vyl font=semaron-kuriale map=semaron}` is, and so is a div,
+a verse fence or a `scroll` fence marked `lang=vyl`. A run that states one of
+the two keys keeps it, and takes the other from the language only where the
+two agree: `font=` alone takes the language's map where that map is drawn in
+the face, and `map=` alone takes the language's face where the map is drawn in
+it. So a tongue written in several scripts states its usual one, and a run in
+another names that script's keys. A language whose note states no `writtenIn`
+only tags, as above. The checks are at the key:
+
+> `` `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` ``
+
 **A run inherits from its passage and overrides it.** A span inside a marked
 div or fence takes the passage's keys, and its own keys win. A Khelathi phrase
 inside a Vylari poem is checked against Khelathi's lexicon and tagged Khelathi
@@ -805,8 +828,8 @@ Lokamen lonak zaron.
 
 **The stress rule** is `data.sounds.stress`, `{ two, longer, mark }`. `two`
 (`first` or `last`) places the stress in a word of two syllables; `longer`
-(`antepenultimate`, `penultimate` or `final`) places it in a word of three or
-more, counted from its end; `mark` (`acute`, `grave` or `circumflex`) is a
+(`first`, `antepenultimate`, `penultimate` or `final`) places it in a word of
+three or more, on its first syllable or counted from its end; `mark` (`acute`, `grave` or `circumflex`) is a
 diacritic that moves the stress to the syllable it sits on. Syllables are vowel
 groups: a vowel is a letter whose base is `a`, `e`, `i`, `o` or `u`, and a pair
 that the language lists in `data.sounds.syllables.vowelPairs` is one syllable.
@@ -850,6 +873,43 @@ A repeated metre name is an error too:
 
 > `` `data.metres[1].name` is `trimeter`, which this note declares twice; a metre's name is unique ``
 
+## Scripts written in columns
+
+A script written in vertical columns, read from the right, states it on its
+script note:
+
+```yaml
+data:
+  script:
+    fonts: [teng-chou]
+    emphasis: rubric
+    direction: vertical-rl
+```
+
+A passage in that script goes in a `scroll` fence. Its lines are joined into
+paragraphs, and each paragraph starts at the top of a fresh column. `rows=`
+sets the characters in a column and `cols=` the columns in a panel:
+
+````markdown
+```scroll {rows=25 cols=12 lang=tsu map=tengchou}
+chen teng chou hing
+tan tsou dou rou
+
+gen chei chou tsuen
+```
+````
+
+Where the Tantsou note states `writtenIn: { map: tengchou, font: teng-chou }`,
+` ```scroll {rows=25 cols=12 lang=tsu} ` is enough.
+
+The site, the preview and Foundry set it in columns, in a panel that scrolls
+sideways from the right. The book draws it as panel images from the face's
+outlines, each with its roman text as alt text. A span in the same script stays
+horizontal, inline in its line. A `scroll` fence in a script that states no
+direction is an error. See
+[scrolls](../authoring/links-and-markup.md#scrolls) for every attribute, the
+defaults on each target and the errors.
+
 ## The core vocabulary
 
 A setting can name the concepts every one of its languages has a word for, and
@@ -907,8 +967,9 @@ whose notes set no text in a face, ships none of it.
 `package-build transliterate <map> [--lang <language>] [--font <slug>] [--hex] [text..]`
 maps a passage exactly as the build maps a run marked `map=<map> lang=<language>
 font=<slug>`. The text is the words given; `-` or none reads standard input.
-`--font` is required when the mapping lists more than one face, and `--hex`
-prints `U+XXXX` code points separated by spaces.
+`--font` defaults to the language's `writtenIn` face where the mapping is drawn
+in it, and is otherwise required when the mapping lists more than one face.
+`--hex` prints `U+XXXX` code points separated by spaces.
 
 ```console
 $ package-build transliterate semaron --lang vyl --hex zaron lonak
@@ -920,8 +981,9 @@ U+F0246 U+F0230 U+F023F U+F023D U+F023C
 The first run writes `zaron` by its exception, and the second, with no
 `--lang`, spells it by the rows.
 
-`package-build lexicon <language> --map <map> [--font <slug>] [--derived] [--json]`
-lists every word of the language with its native form, tab-separated: the form,
+`package-build lexicon <language> [--map <map>] [--font <slug>] [--derived] [--json]`
+lists every word of the language with its native form under the map, or under
+the language's `writtenIn` script when `--map` is left out, tab-separated: the form,
 the native form, `exception` or `rows`, the class and the gloss. `--derived`
 adds the forms the language's rules derive, each with the word it comes from,
 `--json` prints an array instead, and under a logographic map the third column