@heroiclands/package-build 25.6.1 → 25.6.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @heroiclands/package-build
 
+## 25.6.2
+
+**Languages and scripts**
+
+- Encoding documents can choose a mapping according to the letter before it, as well as the following letter and word position.
+
 ## 25.6.1
 
 **Languages and scripts**

package/docs/api.md

@@ -2891,8 +2891,8 @@ expose their schema `key`.
 Encoding rules default to exact, uniquely decodable outputs. A note may state
 `rules.roundTrip: canonical` to permit aliases and empty code sequences;
 `decodeText` then returns the authored conventional reading without restoring
-erased Roman characters. Contextual rules accept `before: vowel|consonant`
-and `at: start|end|line-start`; supplied conditions combine with AND. Accent
+erased Roman characters. Contextual rules accept `after` (one exact NFC Unicode letter, `vowel` or
+`consonant`), `before: vowel|consonant` and `at: start|end|line-start`; supplied conditions combine with AND. `after` governs forward encoding only. Accent
 permission blocks accept explicit Boolean values. See [Encoding text](encoding-core.md).
 
 ### `engine.encodingLanguage`

package/docs/encoding-core.md

@@ -55,7 +55,7 @@ second behaviour.
 | `vowel-groups`        | `{reading: established, allow-splitting: false, unrecognized-adjacent-vowels: separate, groups: [...]}`; the explicit group list determines where an acute belongs on its first vowel.                                                                |
 | `diaeresis`           | `{allowed: boolean}`; false forbids diaeresis characters; true derives plain-vowel mappings and restores splits of distinctly mapped declared groups.                                                                                                 |
 | `grave-accent`        | `{allowed: boolean}` permits or forbids explicitly mapped grave-accent characters.                                                                                                                                                                    |
-| `contextual-mappings` | A list of `{match, emit, before?, at?}`; following-letter or source-position conditions precede unconditional mappings.                                                                                                                               |
+| `contextual-mappings` | A list of `{match, emit, after?, before?, at?}`; preceding-letter, following-letter or source-position conditions precede unconditional mappings.                                                                                                     |
 | `y`                   | `{kind: consonant, sound: "y in yes", vowel-reading: false}`; y cannot also appear in `data.vowels`.                                                                                                                                                  |
 
 The accent blocks accept an explicit Boolean `allowed`. False forbids that
@@ -80,13 +80,28 @@ empty outputs or store invisible metadata to restore the original spelling.
 A language's authoritative vocabulary can recover fuller word spellings.
 Shared word spaces remain spaces in both modes.
 
-Contextual entries use `{match, emit, before?, at?}` and require at least one
-condition. `before` is `vowel` or `consonant`; `at` is `start`, `end` or
+Contextual entries use `{match, emit, after?, before?, at?}` and require at least one
+condition. `after` tests the immediately preceding Unicode scalar in the NFC
+matching stream (including derived diaeresis-to-plain vowel projection). It is
+`vowel`, `consonant`, or one literal NFC Unicode letter, compared exactly and
+case-sensitively; astral letters are permitted. Category conditions require
+`data.vowels`; a literal does not. Neither category matches a missing predecessor, punctuation or space. A literal
+matches only that letter. `after` is a
+positive condition, so refusing an unlisted predecessor requires authored
+allowed alternatives with no unconditional fallback. For example,
+`{match: k, after: a, emit: K_AFTER_A}` selects that font code after `a`.
+
+`after` governs forward encoding only, like `at`; decoding does not validate a
+preceding-source condition. Existing inverse `before` checks remain strict in
+exact mode. Source validation permits spellings without mapping coverage for
+authoritative native entries; `encodeText` refuses uncovered source text.
+
+`before` is `vowel` or `consonant`; `at` is `start`, `end` or
 `line-start`. `start` and `end` refer to word boundaries. A consonant is a
 letter outside the declared `data.vowels`. Line start follows a newline or
 verse slash and permits preceding indentation carets. Multiple conditions
 combine with AND. Entries for the same source may use different conditions;
-repeating the same source and condition tuple is an error. Equal-length
+repeating the same `(match, after, before, at)` tuple is an error. Equal-length
 contextual matches retain authored order.
 
 ```yaml

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

@@ -153,8 +153,14 @@ An encoding's output must decode unambiguously, including across adjacent
 mappings and spaces. The compiler refuses indistinguishable spellings rather
 than choosing a guessed reading. See [the executable rules](../encoding-core.md).
 
-Mappings match longest first; contextual before-vowel rules precede their
-unconditional alternatives. A case rule may allow lowercase and initial-capital
+Mappings match longest first; contextual rules precede their unconditional
+alternatives. A contextual mapping may use `after: vowel`, `after: consonant`
+or one exact NFC letter such as `after: a` to test the preceding source letter.
+It may combine this with `before` and `at`; all supplied conditions must hold.
+The categories use `data.vowels`. These positive conditions need explicit
+allowed alternatives to refuse a predecessor, with no unconditional fallback.
+`after` governs encoding only; see [the executable rules](../encoding-core.md)
+for normalization and decoding details. A case rule may allow lowercase and initial-capital
 groups while refusing other mixed or uppercase group spellings. Encoding keeps
 authored case and never rewrites a word's Roman spelling.
 

package/docs/reference/format-details.md

@@ -8352,8 +8352,9 @@ did not foresee. Holes found in play are fixed in the scenario itself.
 | `rules.diaeresis.allowed`                         | true or false                                                         | False forbids the diaeresis; true derives plain-vowel mappings and restores splits where a declared group's native mapping distinguishes joined and separate vowels. Exact conversion refuses an unrecoverable derived group split; canonical conversion keeps its conventional reading. |
 | `rules.grave-accent`                              | a map                                                                 | Whether grave-accent mappings are allowed.                                                                                                                                                                                                                                               |
 | `rules.grave-accent.allowed`                      | true or false                                                         | False forbids the accent; true permits explicitly mapped and accepted characters.                                                                                                                                                                                                        |
-| `rules.contextual-mappings`                       | a list of conditional mappings                                        | Alternatives conditioned on the following letter or source position, applied before unconditional mappings.                                                                                                                                                                              |
+| `rules.contextual-mappings`                       | a list of conditional mappings                                        | Alternatives conditioned on the preceding letter, following letter or source position, applied before unconditional mappings.                                                                                                                                                            |
 | `rules.contextual-mappings[].match`               | a string                                                              | The source sequence.                                                                                                                                                                                                                                                                     |
+| `rules.contextual-mappings[].after`               | one NFC Unicode letter, vowel or consonant                            | Match after one exact NFC Unicode letter, a declared vowel or another letter.                                                                                                                                                                                                            |
 | `rules.contextual-mappings[].before`              | a string                                                              | Match before a declared vowel or another letter.                                                                                                                                                                                                                                         |
 | `rules.contextual-mappings[].at`                  | a string                                                              | Match at word start, word end or line start.                                                                                                                                                                                                                                             |
 | `rules.contextual-mappings[].emit`                | a glyph code or list of codes (empty only with canonical round trips) | The font codes written by this alternative.                                                                                                                                                                                                                                              |

package/docs/reference/note-types.md

@@ -1054,8 +1054,9 @@ Lore records in-world knowledge. A `culture` describes a people; a `custom` desc
 | `data.rules.diaeresis.allowed`                         | true or false                                                         | yes      | False forbids the diaeresis; true derives plain-vowel mappings and restores splits where a declared group's native mapping distinguishes joined and separate vowels. Exact conversion refuses an unrecoverable derived group split; canonical conversion keeps its conventional reading. |
 | `data.rules.grave-accent`                              | a map                                                                 | no       | Whether grave-accent mappings are allowed.                                                                                                                                                                                                                                               |
 | `data.rules.grave-accent.allowed`                      | true or false                                                         | yes      | False forbids the accent; true permits explicitly mapped and accepted characters.                                                                                                                                                                                                        |
-| `data.rules.contextual-mappings`                       | a list of conditional mappings                                        | no       | Alternatives conditioned on the following letter or source position, applied before unconditional mappings.                                                                                                                                                                              |
+| `data.rules.contextual-mappings`                       | a list of conditional mappings                                        | no       | Alternatives conditioned on the preceding letter, following letter or source position, applied before unconditional mappings.                                                                                                                                                            |
 | `data.rules.contextual-mappings[].match`               | a string                                                              | yes      | The source sequence.                                                                                                                                                                                                                                                                     |
+| `data.rules.contextual-mappings[].after`               | one NFC Unicode letter, vowel or consonant                            | no       | Match after one exact NFC Unicode letter, a declared vowel or another letter.                                                                                                                                                                                                            |
 | `data.rules.contextual-mappings[].before`              | a string                                                              | no       | Match before a declared vowel or another letter.                                                                                                                                                                                                                                         |
 | `data.rules.contextual-mappings[].at`                  | a string                                                              | no       | Match at word start, word end or line start.                                                                                                                                                                                                                                             |
 | `data.rules.contextual-mappings[].emit`                | a glyph code or list of codes (empty only with canonical round trips) | yes      | The font codes written by this alternative.                                                                                                                                                                                                                                              |

package/engine/encoding-integrity.mjs

@@ -16,20 +16,20 @@
 /**
  * Check codeword integrity with a trie and finite Sardinas–Patterson residuals.
  * Source-equivalent compositions are redundant rules, not distinct spellings.
- * @param {Array<{from:string,to:string,key:string,before?:string,at?:string}>} rows - Validated ordinary rows.
+ * @param {Array<{from:string,to:string,key:string,after?:string,before?:string,at?:string}>} rows - Validated ordinary rows.
  * @param {(key:string,message:string)=>never} fault - Positioned schema-error constructor.
  */
 export function assertUniqueOutputs(rows, fault) {
     const bySource = new Map();
     for (const row of rows) {
-        if (row.before || row.at) continue;
+        if (row.after || row.before || row.at) continue;
         const first = [...row.from][0];
         if (!bySource.has(first)) bySource.set(first, []);
         bySource.get(first).push(row);
     }
     for (const group of bySource.values()) group.sort((a, b) => b.from.length - a.from.length);
     const redundant = (row) => {
-        if (row.before || row.at || [...row.from].length < 2) return false;
+        if (row.after || row.before || row.at || [...row.from].length < 2) return false;
         let at = 0,
             output = "";
         while (at < row.from.length) {

package/engine/encoding-template.mjs

@@ -271,11 +271,25 @@ export function templateProgram(data, options, fault) {
         const seen = new Set();
         for (const [i, row] of rules["contextual-mappings"].entries()) {
             const key = `rules.contextual-mappings.${i}`;
-            closed(row, ["match", "before", "at", "emit"], key);
+            closed(row, ["match", "after", "before", "at", "emit"], key);
             if (!scalar(row.match) || !row.match || row.match !== row.match.normalize("NFC"))
                 fault(`${key}.match`, "A contextual match must be nonempty NFC text");
-            if (row.before === undefined && row.at === undefined)
-                fault(key, "A contextual mapping requires before or at");
+            if (row.after === undefined && row.before === undefined && row.at === undefined)
+                fault(key, "A contextual mapping requires after, before or at");
+            if (row.after !== undefined) {
+                if (
+                    !["vowel", "consonant"].includes(row.after) &&
+                    (typeof row.after !== "string" ||
+                        !/^\p{L}$/u.test(row.after) ||
+                        row.after !== row.after.normalize("NFC"))
+                )
+                    fault(`${key}.after`, "after is one NFC Unicode letter, vowel or consonant");
+                if (["vowel", "consonant"].includes(row.after) && !vowels)
+                    fault(
+                        `${key}.after`,
+                        "After-vowel or after-consonant mappings require declared vowels",
+                    );
+            }
             if (row.before !== undefined && !["vowel", "consonant"].includes(row.before))
                 fault(`${key}.before`, "before is vowel or consonant");
             if (row.at !== undefined && !["start", "end", "line-start"].includes(row.at))
@@ -285,7 +299,12 @@ export function templateProgram(data, options, fault) {
                     `${key}.before`,
                     "Before-vowel or before-consonant mappings require declared vowels",
                 );
-            const condition = JSON.stringify([row.match, row.before ?? null, row.at ?? null]);
+            const condition = JSON.stringify([
+                row.match,
+                row.after ?? null,
+                row.before ?? null,
+                row.at ?? null,
+            ]);
             if (seen.has(condition))
                 fault(
                     `${key}.match`,
@@ -298,6 +317,7 @@ export function templateProgram(data, options, fault) {
             contextual.push({
                 from: row.match,
                 to,
+                ...(row.after !== undefined ? { after: row.after } : {}),
                 ...(row.before !== undefined ? { before: row.before } : {}),
                 ...(row.at !== undefined ? { at: row.at } : {}),
             });

package/engine/encoding-terms.mjs

@@ -114,12 +114,19 @@ export const ENCODING_RULE_FIELDS = Object.freeze([
         kind: "list",
         shape: "a list of conditional mappings",
         describe:
-            "Alternatives conditioned on the following letter or source position, applied before unconditional mappings.",
+            "Alternatives conditioned on the preceding letter, following letter or source position, applied before unconditional mappings.",
         entries: {
             kind: "map",
             shape: "a contextual mapping",
             fields: [
                 text("match", "The source sequence.", true),
+                {
+                    ...text(
+                        "after",
+                        "Match after one exact NFC Unicode letter, a declared vowel or another letter.",
+                    ),
+                    shape: "one NFC Unicode letter, vowel or consonant",
+                },
                 {
                     ...text("before", "Match before a declared vowel or another letter."),
                     allowed: ["vowel", "consonant"],

package/engine/encoding.mjs

@@ -114,14 +114,14 @@ function rows(value, key, vowels, allowEmpty) {
     if (!Array.isArray(value)) fault(key, `\`${key}\` must be a list of rows`);
     return value.map((value, order) => {
         const at = `${key}.${order}`;
-        let from, to, before, position;
+        let from, to, after, before, position;
         if (Array.isArray(value)) {
             if (value.length !== 2) fault(at, "A row is two strings, [from, to]");
             [from, to] = value;
         } else if (object(value)) {
-            keys(value, new Set(["from", "to", "before", "at"]), at);
-            ({ from, to, before, at: position } = value);
-        } else fault(at, "A row is [from, to] or {from, to, before?, at?}");
+            keys(value, new Set(["from", "to", "after", "before", "at"]), at);
+            ({ from, to, after, before, at: position } = value);
+        } else fault(at, "A row is [from, to] or {from, to, after?, before?, at?}");
         string(from, `${at}.from`, true);
         string(to, `${at}.to`);
         if (from.includes(OPEN) || from.includes(CLOSE))
@@ -130,12 +130,23 @@ function rows(value, key, vowels, allowEmpty) {
             fault(`${at}.from`, "Whitespace is stated by separator");
         if (!to && !allowEmpty && from !== " ")
             fault(`${at}.to`, "An exact row must write a nonempty output");
+        if (after !== undefined) {
+            if (
+                !["vowel", "consonant"].includes(after) &&
+                (typeof after !== "string" ||
+                    !LETTER.test(after) ||
+                    after !== after.normalize("NFC"))
+            )
+                fault(`${at}.after`, "after is one NFC Unicode letter, vowel or consonant");
+            if (["vowel", "consonant"].includes(after) && !vowels)
+                fault(`${at}.after`, "after categories need vowels");
+        }
         if (before !== undefined && !["vowel", "consonant"].includes(before))
             fault(`${at}.before`, "before is vowel or consonant");
         if (before && !vowels) fault(`${at}.before`, "before needs vowels");
         if (position !== undefined && !["start", "end", "line-start"].includes(position))
             fault(`${at}.at`, "at is start, end or line-start");
-        return Object.freeze({ from, to, before, at: position, order, key: at });
+        return Object.freeze({ from, to, after, before, at: position, order, key: at });
     });
 }
 function indexRows(rows) {
@@ -149,7 +160,8 @@ function indexRows(rows) {
         group.sort(
             (a, b) =>
                 length(b.from) - length(a.from) ||
-                Number(Boolean(b.before || b.at)) - Number(Boolean(a.before || a.at)) ||
+                Number(Boolean(b.after || b.before || b.at)) -
+                    Number(Boolean(a.after || a.before || a.at)) ||
                 a.order - b.order,
         );
     return index;
@@ -328,6 +340,15 @@ function beforeHolds(condition, char, vowels) {
     );
 }
 function holds(row, text, start, end, vowels) {
+    if (row.after) {
+        const preceding = start > 0 ? previousAt(text, start) : undefined;
+        if (
+            ["vowel", "consonant"].includes(row.after) ?
+                !beforeHolds(row.after, preceding, vowels)
+            :   preceding !== row.after
+        )
+            return false;
+    }
     if (row.before && !beforeHolds(row.before, firstAt(text, end), vowels)) return false;
     if (row.at === "line-start") {
         let slash = text.lastIndexOf("/", start - 1);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "25.6.1",
+    "version": "25.6.2",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package \u2014 content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

package/types/engine/encoding-integrity.d.mts

@@ -2,13 +2,14 @@
 /**
  * Check codeword integrity with a trie and finite Sardinas–Patterson residuals.
  * Source-equivalent compositions are redundant rules, not distinct spellings.
- * @param {Array<{from:string,to:string,key:string,before?:string,at?:string}>} rows - Validated ordinary rows.
+ * @param {Array<{from:string,to:string,key:string,after?:string,before?:string,at?:string}>} rows - Validated ordinary rows.
  * @param {(key:string,message:string)=>never} fault - Positioned schema-error constructor.
  */
 export function assertUniqueOutputs(rows: Array<{
     from: string;
     to: string;
     key: string;
+    after?: string;
     before?: string;
     at?: string;
 }>, fault: (key: string, message: string) => never): void;