@heroiclands/package-build 24.0.4 → 24.1.1

package/docs/commands.md

@@ -1556,6 +1556,89 @@ package-build: This repository declares no end-to-end suite to `run`. Name one u
 
 ## Content operations
 
+### `package-build content build`
+
+**NAME**
+
+Build indexes, calendars, assets and packs from one captured content tree.
+
+**SYNOPSIS**
+
+```text
+package-build content build --calendaria-version <version>
+```
+
+**DESCRIPTION**
+
+The complete content build runs these existing operations in order:
+
+1. Capture authored sources and prepare and publish fresh metadata, dictionary
+   and terms indexes.
+2. Emit calendar definitions and Calendaria imports from the published index.
+3. Stage the configured assets, including calendars, provenance-filtered
+   pictures, base styles and fonts.
+4. Run content lint, link checks and pack compilation with the same live session.
+
+Finish dependency fetching and source generation before invoking the command.
+Public and complete SQL preparations remain separate and each is reused by
+operations needing that audience. No resolved index or source cache survives
+into another invocation. Standalone commands and `content run` remain available.
+
+The command clears its index directory, generated calendar directory, pack JSON
+and configured compiled pack directories before preparing the new build. Other
+stage files, including a manifest written by a parallel packaging task, remain.
+Use `package-build stage reset` before starting the complete packaging workflow
+when the entire stage must start empty. Build output paths must be outside the
+captured content and picture roots. A phase that changes those inputs fails the
+build, invalidates publication readiness and stops further use of the capture;
+source generation belongs before this command.
+
+After all three index files are published successfully, the command writes
+`<paths.contentIndex>/.publication-ready` (normally
+`build/content-index/.publication-ready`). It removes that marker at startup.
+The marker means this invocation published a complete fresh index, even when
+calendar emission, asset staging, lint, link checks or compilation later fails.
+A subsequent index consumer can check it to report independent findings after a
+build failure. Clear the marker before a surrounding workflow starts as well,
+so failures before the command starts cannot expose an earlier run's index.
+Never restore the marker or resolved indexes from a cache.
+
+Preparation failure blocks publication and compilation but preserves useful
+independent lint and link findings. Calendar or asset failure blocks compilation;
+ordinary lint or link findings do not block an otherwise valid compile. Pack
+generation still refuses to compile incomplete output. An advisory warning does
+not fail the command.
+
+The final timing summary includes eager capture and index derivation, SQL by
+audience, publication, calendars, assets, validation, rendering and native pack
+compilation. Stage times are exclusive: a nested SQL preparation is charged to
+SQL rather than its calling stage. Counts, preparation reuse and peak process
+RSS accompany the timings; importing the CLI and validating its arguments happen
+before the measured build interval.
+
+**OPTIONS**
+
+| Option                 | Type   | Default  | Description                            |
+| ---------------------- | ------ | -------- | -------------------------------------- |
+| `--calendaria-version` | string | required | Calendaria import version, e.g. 1.4.2. |
+
+**EXIT STATUS**
+
+0 when every operation succeeds. 1 when arguments, preparation or any build
+operation fails. Publication readiness alone does not mean the build passed.
+
+**EXAMPLES**
+
+```bash
+package-build deps fetch
+package-build content build --calendaria-version 1.4.2
+```
+
+**SEE ALSO**
+
+`package-build content run`, `package-build content-index`, `package-build calendars`,
+`package-build assets`, `package-build package compile`.
+
 ### `package-build content run <targets..>`
 
 **NAME**
@@ -2494,7 +2577,10 @@ the metadata artifact.
 
 Metadata also includes each own note's spans, divs and verse fences marked with
 `lang=`, `font=` or `map=` under `runs`, with the language as written, the tag
-it resolves to, the font, the map and the original source line/column. Local
+it resolves to, the font, the map and the original source line/column. Native
+runs carry `nativefont: true` in the metadata; language-only Roman runs omit
+the flag and do not receive script defaults. The `runs` SQL columns stay the
+same. Local
 and dependency SQL schemas expose them through `runs`, and each mapping note's
 rows through `maps`.
 
@@ -3081,7 +3167,7 @@ package-build transliterate <map> [--lang <language>] [--font <slug>] [--hex] [t
 
 Reads the content index, as `package-build lint` does, and prints the passage
 rewritten by the mapping note whose `data.map.name` is `<map>`, through the
-same code the build sets a run marked `map=<map> lang=<language> font=<slug>`
+same code the build sets a run marked `lang=<language> .nativefont map=<map> font=<slug>`
 with. With `--lang`, each word the language's lexicon states a native form for
 is written by it and every other word is spelled by the rows; without it, the
 rows alone apply. See

package/docs/configuration.md

@@ -764,12 +764,15 @@ shortcode, whose type defaults to `skill`. A run marked with the language and a
 `map=` writes each word the lexicon states a native form for by that form, and
 spells every other word by the map's rows; see
 [a map reads the dictionary first](reference/format-details.md#a-map-reads-the-dictionary-first).
-Every word of such a run is a word of the lexicon, of a name the language note's
+Language word-book validation applies to Roman and native runs alike,
+independently of `.nativefont` or mapping: every word 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
+`data.writtenIn: { map, font }`, and a run explicitly marked with both the language and `.nativefont` is
+then mapped and set in it. Language-only runs retain authored Roman spelling
+and the surrounding prose font. Native `map=` and `font=` override the
+configured halves independently; missing halves require explicit overrides; 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

package/docs/content-format.md

@@ -29,11 +29,12 @@ A nonempty note body creates one system-agnostic Foundry JournalEntry. Content b
 
 Leading `:` captions describe the next supported block; `:@` captions also number it. The optional type accepts `figure`, `table`, `verse`, `code`, `prose`, and `example`. Captions support identifiers, classes and named attributes; unsupported following blocks are errors. See [captions and numbered references](authoring/links-and-markup.md#captions-and-numbered-references).
 
-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 code fence with language `verse` keeps verse lines, stanza breaks and relative indentation. Leading periods set indent levels and are removed from the text; leading spaces do not count. Blank lines separate verse units and `***` separates stanzas. 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. `cols=N` sets a positive whole number of columns and defaults to one. With `cols` above one, each content line starts with an integer and one or more spaces; numbers lie in `1..cols` and are nondecreasing within each blank-separated logical row. Any column may be omitted and keeps an empty cell. A column may repeat without limit: its first reading is foreground and its later readings are grey, independently for every column and row. Number prefixes are not displayed; `numstep` counts logical rows. `***` separates stanzas. Inline language and native presentation are explicit on each authored run. See [verse in columns](authoring/links-and-markup.md#verse-in-columns).
 
-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 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 `.nativefont` requires an explicit language and a font supplied by a language default or an override; mapping is optional when no default supplies it. 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).
+A span, a generic div, a verse fence or a scroll fence identifies its language with `lang=` and keeps its authored spelling and the surrounding prose font. Explicit `.nativefont` on that same construct, with its own explicit `lang=`, requests the language's configured `data.writtenIn` map and font; `map=` and `font=` override their halves independently. A missing font default requires `font=` rather than inference; mapping is optional when the language supplies none. Native font or map keys require `.nativefont`; Roman `font=mono`, `serif` and `sans` remain available independently. Unmarked text follows its passage, while a marked language-only child stays Roman, even in the same language as a native parent. Standalone wikilinks make the same choice: `[[address|Name]]{lang=vyl}` stays Roman and `[[address|Name]]{lang=vyl .nativefont}` uses native presentation without changing its destination or presentation cues. `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. Language word-book validation applies to Roman and native runs alike,
+independently of `.nativefont` or mapping: every word 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](authoring/links-and-markup.md#metre). 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. Actual bold or italic markup inside a span whose effective language is not English is an error, whether that language is declared or inherited and whether or not the text uses a font; English text remains eligible. 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

package/docs/diagnostics.md

@@ -256,45 +256,73 @@ resolves it. The rules are under
 
 ## A worked case: a verse in columns
 
-A [verse in columns](authoring/links-and-markup.md#verse-in-columns) is
-checked line by line, and every finding sits on the text that makes it wrong.
-Each is an error, from `package-build lint` and from every build that sets the
-page.
-
-A verse line that leaves out a language its columns name is located at the
-group's first line, and names the column that asks for it. A language given
-twice is located at the second span, and one no column sets at its span:
+A [verse in columns](authoring/links-and-markup.md#verse-in-columns) has a
+positive whole-number `cols` value. Invalid counts are located at their
+value. With multiple columns, every content line needs a numeric prefix and
+one or more spaces. Missing prefixes point to the line's first content
+character; out-of-range or decreasing numbers point to the authored number.
+
+This row has a decreasing column number on its third content line:
+
+````markdown
+```verse {cols=3 lang=en}
+1 The first reading.
+3 A later column.
+2 Out of order within this row.
+```
+````
+
+The finding points to `2`. A blank line before it would start another row,
+where the column order begins again. A number above three or below one is
+out of bounds. Skipping a column is valid and leaves an empty cell; repeating
+a number is valid and adds another reading to that column. The first reading
+in every column is foreground and its later readings are grey.
+
+Language and native-font findings retain their authored locations inside a
+reading, including the column prefix and indentation before it. An unknown
+mapping or face points to that run's attribute; an unknown word or a character
+the face cannot draw points to the original word or character. A language-only
+Roman repeat is checked in its own language, independently of a native run.
+The build reports invalid input rather than publishing an inferred layout.
+
+## Emphasis in non-English spans
+
+Bold or italic Markdown inside a span whose effective language tag is not
+English is an error at the opening emphasis marker. This applies to declared
+and BCP 47 languages, including spans that inherit a language from an enclosing
+span, div or fence. English tags (`en` and tags beginning `en-`) remain
+eligible. Escaped or unmatched delimiters are literal text. The diagnostic
+names the language supplied by the span or inherited from its enclosing
+construct:
 
 ```text
-assets/content/Lore/Walking_of_the_Line.md:14:1: error: this verse line has no `en` line, which `col2=` sets
-assets/content/Lore/Walking_of_the_Line.md:18:1: error: this verse line gives `en` twice; give each language once
-assets/content/Lore/Walking_of_the_Line.md:22:1: error: no column sets `khel`; a verse line gives the languages `col1=` and `col2=` name
+a span in non-English language `vyl` holds no bold or italic markup
 ```
 
-A finding about the columns themselves is located in the opening line, at the
-key or at the entry. A third column is located at its key; a malformed entry
-at the entry; an unknown mapping or font at that part of its entry, with the
-nearest name the package knows:
+For example, `[a *word*]{lang=vyl}` locates the finding at the `*` that opens
+the emphasis. A font does not make the markup valid; the language rule applies
+to the span whether its text uses a script face or ordinary type.
 
-```text
-assets/content/Lore/Walking_of_the_Line.md:9:85: error: `col3=` is not a column: a verse has at most two, `col1=` and `col2=`
-assets/content/Lore/Walking_of_the_Line.md:9:81: error: `vyl/a/b/c` in `col2=` is not an entry: an entry is `language[/mapping[/font]]`
-assets/content/Lore/Walking_of_the_Line.md:9:45: error: `vyl-semron` is not a map: `map=` names the `data.map.name` of a mapping note; did you mean `vyl-semaron`?
-```
+## Native presentation is explicit
 
-The text an entry sets is checked as a span with that entry's keys, and its
-findings sit on the character of the verse line they come from. A character
-the face does not draw, after the mapping, is located at the character as the
-note wrote it:
+A language-only run keeps its authored spelling and prose font. Native
+presentation requires `.nativefont` and an explicit `lang=` on that same
+span, div, verse fence or scroll fence. An inherited language does not satisfy
+this requirement. Findings point to the authored class or override:
 
 ```text
-assets/content/Lore/Walking_of_the_Line.md:19:8: error: `7` (U+0037) is not drawn by the font `semaron-kuriale`, and the map `vyl-semaron` has no row for it
+`.nativefont` requires an explicit `lang=` on the same construct
+native `font=semaron-kuriale` requires `.nativefont` and an explicit `lang=` on the same construct
+`map=semaron` requires `.nativefont` and an explicit `lang=` on the same construct
+`.nativefont` has no default `font=` for `vyl`; state `font=` explicitly
 ```
 
-A key that names nothing is the one finding: a line set through an unknown
-mapping or font is not then checked against a face or a lexicon it cannot
-reach. A verse in columns with any finding is set as its lines are written,
-and the build fails on the error.
+A missing font needs an explicit `font=` or a language font default. Mapping is
+optional when the language supplies none; configured maps still apply to
+native runs unless explicitly overridden. `font=serif`, `sans` and `mono`
+remain independent Roman choices. Each authored reading makes its own presentation choice in parallel verse,
+for example `1 [Zaron]{lang=vyl .nativefont}` and
+`3 [Zaron]{lang=vyl}` inside a `cols=3` poem. The Roman repeat stays Roman.
 
 ## Summary counts and prose are not findings
 

package/docs/guides/book.md

@@ -505,7 +505,7 @@ the font registry.
 
 ### Fonts for marked text
 
-Text marked with `font=` and one of the faces of `@heroiclands/fonts` is set in
+Native text marked with `lang=` and `.nativefont` in one of the faces of `@heroiclands/fonts` is set in
 that face once the package installs the fonts package in `devDependencies`.
 The build then adds the fonts package's `fonts/` directory, which holds the
 TrueType files, to the compiler's font search path after the shipped faces and

package/docs/guides/module-project.md

@@ -691,10 +691,10 @@ package-build: Cannot stage assets — these paths do not exist:
 
 ### Fonts for marked text
 
-A module shows text marked with `font=` and one of the faces of
+A module shows native text marked with `lang=` and `.nativefont` in one of the faces of
 `@heroiclands/fonts` in that face once the package installs the fonts package
 in `devDependencies`. Nothing is configured: the build reads which faces the
-notes use from their `font=` keys.
+notes use from explicit `font=` overrides or opted-in language defaults.
 
 `package-build assets` then stages the font stylesheet, the WOFF2 files and the
 licence under `fonts/heroiclands/` in the package; the staged stylesheet lists

package/docs/guides/site.md

@@ -270,12 +270,12 @@ part of the site.
 
 ## Show marked text in its font
 
-A site shows text marked with `font=` and one of the faces of
+A site shows native text marked with `lang=` and `.nativefont` in one of the faces of
 `@heroiclands/fonts` in that face once the package installs the fonts package
 in `devDependencies`, as the
 [authoring guide](../authoring/links-and-markup.md#marking-language-font-and-mapping)
 describes. Nothing else is configured: the build reads which faces the notes use
-from their `font=` keys.
+from explicit `font=` overrides or opted-in language defaults.
 
 `package-build site build` copies the font stylesheet, the WOFF2 files and the
 licence to a path that names the fonts package's version,