@heroiclands/package-build 25.6.1 → 25.6.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @heroiclands/package-build
 
+## 25.6.3
+
+**Rendering and sites**
+
+- Build a preview at another address with `site build --base-url` and serve its images from another asset root with `--assets`. Pages, links, script fonts and search use the preview prefix, while the package's authored configuration stays unchanged.
+
+## 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/bin/content-commands.mjs

@@ -46,7 +46,12 @@ import log from "loglevel";
 import prefix from "loglevel-plugin-prefix";
 import { readStdin } from "../engine/read-stdin.mjs";
 import { compilePacks, cleanPacks, unpackPacks } from "../engine/compendiums.mjs";
-import { compilesFoundryDocuments, publishesContentPages, siteBase } from "../content-config.mjs";
+import {
+    compilesFoundryDocuments,
+    publishesContentPages,
+    siteBase,
+    siteBuildConfig,
+} from "../content-config.mjs";
 import { loadPackConfig, packConfigPath } from "../engine/pack-config.mjs";
 import { buildPdf, listBookAssets } from "../engine/pdf-build.mjs";
 import { summaryLines } from "../engine/pdf-coverage.mjs";
@@ -115,7 +120,7 @@ import {
 } from "../engine/encoding-lexicon.mjs";
 import { checkFormatting, checkPrettierConventions, lintMarkdown } from "../engine/prose-lint.mjs";
 import { lintProse, scoreProseTree } from "../engine/readability-lint.mjs";
-import { loadPackageBuildConfig } from "../config.mjs";
+import { checkHomepage, loadPackageBuildConfig } from "../config.mjs";
 import {
     emitContentIndex,
     prepareContentIndex,
@@ -520,7 +525,7 @@ function withIndexPreflight(command, shouldCheck = () => true) {
         handler: async (argv) => {
             let config;
             try {
-                config = loadPackConfig();
+                config = argv[CONTENT_CONFIG] ?? loadPackConfig();
                 if (shouldCheck(config, argv)) cachedMetadataIndexes(config);
             } catch (err) {
                 if (config) {
@@ -2279,9 +2284,11 @@ function siteCommand() {
         builder: (yargs) =>
             yargs
                 .command(
-                    withIndexPreflight(
-                        withBodyPreflight(siteBuildCommand()),
-                        publishesContentPages,
+                    withSiteBuildConfig(
+                        withIndexPreflight(
+                            withBodyPreflight(siteBuildCommand()),
+                            publishesContentPages,
+                        ),
                     ),
                 )
                 .command(
@@ -2294,6 +2301,29 @@ function siteCommand() {
     };
 }
 
+/** Apply runtime site settings before the index and body preflights. */
+function withSiteBuildConfig(command) {
+    const handler = command.handler;
+    return {
+        ...command,
+        handler: async (argv) => {
+            if (argv.baseUrl === undefined && argv.assets === undefined) return handler(argv);
+            try {
+                const authored = argv[CONTENT_CONFIG] ?? loadPackConfig();
+                checkHomepage(authored.homepage, authored.contentPackage, authored.site.base);
+                const config = siteBuildConfig(authored, {
+                    baseUrl: argv.baseUrl,
+                    assets: argv.assets,
+                });
+                return await handler({ ...argv, [CONTENT_CONFIG]: config });
+            } catch (err) {
+                reportFailure(err);
+                process.exitCode = 1;
+            }
+        },
+    };
+}
+
 /**
  * Report what the layouts, or the build's section gate, found about a site.
  *
@@ -2342,10 +2372,21 @@ function siteBuildCommand() {
         command: "build",
         describe: "Render the content tree as a website and index it for search",
         builder: (yargs) =>
-            yargs.option("out", {
-                type: "string",
-                describe: `The directory that is deployed (default: ${DEPLOY_ROOT})`,
-            }),
+            yargs
+                .option("out", {
+                    type: "string",
+                    describe: `The directory that is deployed (default: ${DEPLOY_ROOT})`,
+                })
+                .option("base-url", {
+                    type: "string",
+                    requiresArg: true,
+                    describe: "Absolute HTTP(S) site URL for this build, ending in /",
+                })
+                .option("assets", {
+                    type: "string",
+                    requiresArg: true,
+                    describe: "Absolute HTTP(S) asset root for this build",
+                }),
         handler: async (argv) => {
             try {
                 const config = argv[CONTENT_CONFIG] ?? loadPackConfig();

package/content-config.mjs

@@ -228,6 +228,78 @@ export function siteBase(config) {
     return config.site.base || `/${config.contentPackage}/`;
 }
 
+/**
+ * Apply validated runtime site URLs to a resolved configuration, without changing it.
+ * The caller checks the authored homepage before applying these build options.
+ *
+ * @param {ContentBuildConfig} config - The resolved authored configuration.
+ * @param {object} options - Runtime options.
+ * @param {string} [options.baseUrl] - Absolute HTTP(S) site URL ending in `/`.
+ * @param {string} [options.assets] - Absolute HTTP(S) asset root.
+ * @returns {ContentBuildConfig} The effective configuration, frozen.
+ */
+export function siteBuildConfig(config, { baseUrl, assets }) {
+    if (baseUrl === undefined && assets === undefined) return config;
+    const homepage = baseUrl === undefined ? config.homepage : buildUrl(baseUrl, "--base-url").href;
+    const base =
+        baseUrl === undefined ? config.site.base : normalizeSiteBase(new URL(homepage).pathname);
+    const assetRoot =
+        assets === undefined ?
+            config.site.assets
+        :   normalizeSiteAssets(buildUrl(assets, "--assets").href);
+    checkSiteSitemaps(config.site.sitemaps, base, config.contentPackage);
+    return Object.freeze({
+        ...config,
+        homepage,
+        site: Object.freeze({ ...config.site, base, assets: assetRoot }),
+    });
+}
+
+/**
+ * A runtime web root must survive URL joining and mapping to a local directory.
+ *
+ * @param {string} value - The command-line value.
+ * @param {string} option - The option naming it.
+ * @returns {URL} The checked URL.
+ */
+function buildUrl(value, option) {
+    // URL parsing consumes both literal and escaped dot segments.
+    const rawPath = /^https?:\/\/[^/?#]+([^?#]*)/i.exec(value)?.[1] ?? "";
+    if (
+        rawPath.includes("%") ||
+        rawPath.split("/").some((segment) => segment === "." || segment === "..")
+    ) {
+        throw new TypeError(
+            `${option} must use a plain path without percent escapes or dot segments`,
+        );
+    }
+    let url;
+    try {
+        url = new URL(value);
+    } catch {
+        throw new TypeError(`${option} must be an absolute HTTP(S) URL`);
+    }
+    if (
+        !/^https?:\/\/[^/]+/i.test(value) ||
+        /[\s\\]/.test(value) ||
+        !["http:", "https:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        value.includes("?") ||
+        value.includes("#") ||
+        url.pathname.includes("//") ||
+        url.pathname.includes("%")
+    ) {
+        throw new TypeError(
+            `${option} must be an absolute HTTP(S) URL with a plain path and no credentials, query or fragment`,
+        );
+    }
+    if (option === "--base-url" && !url.pathname.endsWith("/")) {
+        throw new TypeError(`${option} must end with /`);
+    }
+    return url;
+}
+
 /**
  * Whether this package publishes the pages its content tree compiles to.
  *
@@ -1874,6 +1946,23 @@ function packageSiteList(value, field, contentPackage) {
     );
 }
 
+/**
+ * @param {readonly string[]} sitemaps - The configured package sitemaps.
+ * @param {string} base - The site path.
+ * @param {string} contentPackage - The package id.
+ * @returns {void}
+ */
+function checkSiteSitemaps(sitemaps, base, contentPackage) {
+    if (sitemaps.length && base !== "/") {
+        fail(
+            "site.sitemaps",
+            "names the package sites a sitemap index lists, and a sitemap index and " +
+                "`robots.txt` belong at the root of an origin; this site is served at " +
+                `\`${base || `/${contentPackage}/`}\`, so declare \`site.base: /\` or drop the key`,
+        );
+    }
+}
+
 /**
  * The `site` section — how this repository frames the website it publishes.
  *
@@ -1939,14 +2028,7 @@ function normalizeSite(value, contentPackage) {
     const base = normalizeSiteBase(input.base);
     const search = optionalBoolean(input.search, "site.search", true);
     const sitemaps = packageSiteList(input.sitemaps, "site.sitemaps", contentPackage);
-    if (sitemaps.length && base !== "/") {
-        fail(
-            "site.sitemaps",
-            "names the package sites a sitemap index lists, and a sitemap index and " +
-                "`robots.txt` belong at the root of an origin; this site is served at " +
-                `\`${base || `/${contentPackage}/`}\`, so declare \`site.base: /\` or drop the key`,
-        );
-    }
+    checkSiteSitemaps(sitemaps, base, contentPackage);
     const mergeIndexes = packageSiteList(input.mergeIndexes, "site.mergeIndexes", contentPackage);
     if (mergeIndexes.length && !search) {
         fail(

package/docs/api.md

@@ -2193,20 +2193,21 @@ const config = defineConfig({
 });
 ```
 
-| Export                     | Signature                          | Returns                                                    | Use it when                                                                                                                                                                                                                              |
-| -------------------------- | ---------------------------------- | ---------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `defineConfig`             | `defineConfig(config)`             | `ContentBuildConfig` — the frozen, defaulted configuration | validating and normalizing a content configuration; every configuration reaches this function whether authored as YAML or as `.mjs`                                                                                                      |
-| `PACKAGE_KINDS`            | `const PACKAGE_KINDS`              | —                                                          | reading the three kinds of Foundry package a content module can be built into — `systems`, `modules`, and `documentation`, the kind that compiles no Foundry document at all (also the Foundry install directory name for the first two) |
-| `DOCUMENTATION_KIND`       | `const DOCUMENTATION_KIND`         | —                                                          | naming the `packageKind` value that compiles no Foundry documents, spelled once so the validator, the CLI and the compile passes cannot disagree about what it means                                                                     |
-| `AUTHOR_ROLES`             | `const AUTHOR_ROLES`               | `readonly string[]`                                        | reading the closed list an `authors` entry's `role` is drawn from — the configuration check refuses any other value                                                                                                                      |
-| `RELATIONSHIP_KEYS`        | `const RELATIONSHIP_KEYS`          | `readonly string[]`                                        | reading every key a declared relationship may carry — the configuration check refuses anything else, and the manifest writer drops the ones Foundry's own schema does not name                                                           |
-| `compilesFoundryDocuments` | `compilesFoundryDocuments(config)` | `boolean`                                                  | checking whether a resolved configuration compiles Foundry documents at all — false only for a `documentation` package                                                                                                                   |
-| `PACK_DOCUMENT_TYPES`      | `const PACK_DOCUMENT_TYPES`        | —                                                          | reading the Foundry document types this toolchain is able to compile a compendium pack of                                                                                                                                                |
-| `DEFAULT_PATHS`            | `const DEFAULT_PATHS`              | —                                                          | reading the conventional directory layout a build reads from and writes to, relative to `rootDir`                                                                                                                                        |
-| `DEFAULT_ADDRESS_SCHEME`   | `const DEFAULT_ADDRESS_SCHEME`     | —                                                          | reading an unconfigured repository's address-scheme defaults (`prefix`, where the content tree mounts inside the package)                                                                                                                |
-| `DERIVED_SYSTEM_VERSION`   | `const DERIVED_SYSTEM_VERSION`     | —                                                          | the loader-only symbol key `defineConfig` uses internally to receive a resolved system version; not something a configuration author writes                                                                                              |
-| `publishesContentPages`    | `publishesContentPages(config)`    | `boolean`                                                  | checking whether the authored content tree contains notes beyond its homepage, shared by site, PDF, index, and Foundry address emission                                                                                                  |
-| `siteBase`                 | `siteBase(config)`                 | `string`                                                   | reading the path a package's site is served at — `site.base` where the configuration states one, `/<contentPackage>/` otherwise                                                                                                          |
+| Export                     | Signature                                      | Returns                                                    | Use it when                                                                                                                                                                                                                              |
+| -------------------------- | ---------------------------------------------- | ---------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `defineConfig`             | `defineConfig(config)`                         | `ContentBuildConfig` — the frozen, defaulted configuration | validating and normalizing a content configuration; every configuration reaches this function whether authored as YAML or as `.mjs`                                                                                                      |
+| `PACKAGE_KINDS`            | `const PACKAGE_KINDS`                          | —                                                          | reading the three kinds of Foundry package a content module can be built into — `systems`, `modules`, and `documentation`, the kind that compiles no Foundry document at all (also the Foundry install directory name for the first two) |
+| `DOCUMENTATION_KIND`       | `const DOCUMENTATION_KIND`                     | —                                                          | naming the `packageKind` value that compiles no Foundry documents, spelled once so the validator, the CLI and the compile passes cannot disagree about what it means                                                                     |
+| `AUTHOR_ROLES`             | `const AUTHOR_ROLES`                           | `readonly string[]`                                        | reading the closed list an `authors` entry's `role` is drawn from — the configuration check refuses any other value                                                                                                                      |
+| `RELATIONSHIP_KEYS`        | `const RELATIONSHIP_KEYS`                      | `readonly string[]`                                        | reading every key a declared relationship may carry — the configuration check refuses anything else, and the manifest writer drops the ones Foundry's own schema does not name                                                           |
+| `compilesFoundryDocuments` | `compilesFoundryDocuments(config)`             | `boolean`                                                  | checking whether a resolved configuration compiles Foundry documents at all — false only for a `documentation` package                                                                                                                   |
+| `PACK_DOCUMENT_TYPES`      | `const PACK_DOCUMENT_TYPES`                    | —                                                          | reading the Foundry document types this toolchain is able to compile a compendium pack of                                                                                                                                                |
+| `DEFAULT_PATHS`            | `const DEFAULT_PATHS`                          | —                                                          | reading the conventional directory layout a build reads from and writes to, relative to `rootDir`                                                                                                                                        |
+| `DEFAULT_ADDRESS_SCHEME`   | `const DEFAULT_ADDRESS_SCHEME`                 | —                                                          | reading an unconfigured repository's address-scheme defaults (`prefix`, where the content tree mounts inside the package)                                                                                                                |
+| `DERIVED_SYSTEM_VERSION`   | `const DERIVED_SYSTEM_VERSION`                 | —                                                          | the loader-only symbol key `defineConfig` uses internally to receive a resolved system version; not something a configuration author writes                                                                                              |
+| `publishesContentPages`    | `publishesContentPages(config)`                | `boolean`                                                  | checking whether the authored content tree contains notes beyond its homepage, shared by site, PDF, index, and Foundry address emission                                                                                                  |
+| `siteBase`                 | `siteBase(config)`                             | `string`                                                   | reading the path a package's site is served at — `site.base` where the configuration states one, `/<contentPackage>/` otherwise                                                                                                          |
+| `siteBuildConfig`          | `siteBuildConfig(config, { baseUrl, assets })` | `ContentBuildConfig`                                       | applying optional runtime site URLs to a frozen effective configuration; the caller first validates the authored homepage with `checkHomepage`; the CLI uses it before index/body preflight                                              |
 
 ## `./config`
 
@@ -2891,8 +2892,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/commands.md

@@ -2685,7 +2685,7 @@ it for search.
 **SYNOPSIS**
 
 ```
-package-build site build [--out <dir>]
+package-build site build [--out <dir>] [--base-url <url>] [--assets <url>]
 ```
 
 **DESCRIPTION**
@@ -2760,9 +2760,27 @@ run fails before the search index is built.
 
 `--out <dir>` — the directory that is deployed. Defaults to `build/site`.
 
+`--base-url <url>` — the absolute HTTP(S) address of this build. Its pathname
+becomes the effective `site.base`, and must end with `/`; `/` serves the site
+at the origin's root. Pages, local links, theme files, script fonts and search
+all use that prefix. Output lands under `<out>/<pathname>/`.
+
+`--assets <url>` — the absolute HTTP(S) asset root for this build. It may
+include a path; trailing slashes are trimmed.
+
+Both options are optional and independent. Without them, the build uses the
+authored `homepage`, `site.base` and `site.assets`. Overrides apply in memory
+before preflight and rendering; they never rewrite `package.json` or
+`package-build.config.yaml`. The authored homepage must still pass its usual
+validation. Both URLs require plain paths without percent escapes, dot
+segments (`.` or `..`), or doubled slashes, and reject credentials, queries,
+fragments, whitespace and backslashes.
+Invalid overrides fail before output is replaced. A site declaring
+`site.sitemaps` must still be served at `/`.
+
 **EXIT STATUS**
 
-1 if `package.json` declares no `homepage`, or one that does not end
+1 if a runtime URL override is invalid. 1 if `package.json` declares no `homepage`, or one that does not end
 `/<contentPackage>/`; if the site declares no title, description or `assets`
 host; or if the navigation has not been fetched (`package-build deps fetch`
 fills the cache and is named in the message). 1 if any gate fires — no
@@ -2774,6 +2792,15 @@ findings of severity `warning` included.
 
 **EXAMPLES**
 
+```bash
+package-build site build \
+    --base-url https://www.internal.heroiclands.org/thalorna/ \
+    --assets https://cdn.internal.heroiclands.org
+package-build site build \
+    --base-url https://www.internal.heroiclands.org/pr/thalorna/123/thalorna/ \
+    --assets https://cdn.internal.heroiclands.org
+```
+
 ```
 $ package-build site build
 […] indexing content

package/docs/configuration.md

@@ -1284,6 +1284,11 @@ site:
   mergeIndexes: [sohl, thalorna, kethira, harnensemble]
 ```
 
+The optional [`site build --base-url` and `--assets` flags](commands.md#package-build-site-build)
+apply runtime overrides to these resolved settings. The base URL supplies the
+effective homepage and `site.base`; the asset URL supplies effective
+`site.assets`. The authored configuration stays unchanged and must be valid.
+
 ### What the site build reads
 
 `package-build site build` composes the site's settings from sources the

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/site.md

@@ -306,6 +306,36 @@ The terminal reports indexing, rendering, writing and search indexing as they
 start, including page counts where available. Progress is on stdout;
 diagnostics retain their file, line and column on stderr.
 
+For an internal main preview, supply the build's address and asset root:
+
+```bash
+package-build site build \
+    --base-url https://www.internal.heroiclands.org/thalorna/ \
+    --assets https://cdn.internal.heroiclands.org
+```
+
+For a pull request preview, include the whole prefix:
+
+```bash
+package-build site build \
+    --base-url https://www.internal.heroiclands.org/pr/thalorna/123/thalorna/ \
+    --assets https://cdn.internal.heroiclands.org
+```
+
+The second build writes to `build/site/pr/thalorna/123/thalorna/`. Its local
+links, theme files, script fonts and search stay under that prefix; its images
+use the supplied asset root. `--out` changes the deployment directory above the
+prefix. Both URL options are optional and independent, and require absolute
+HTTP(S) URLs. The base URL's path ends with `/`; the asset root may include a
+path and has trailing slashes trimmed. Use plain paths without percent escapes,
+dot segments (`.` or `..`), or doubled slashes, credentials, queries or fragments.
+
+The options apply to this build only. Authored `package.json` and YAML stay
+unchanged, and the authored homepage still has to match the configured site.
+Invalid overrides fail before replacing output. A site with `site.sitemaps`
+requires a base URL at the origin's root. See the
+[command reference](../commands.md#package-build-site-build) for URL validation.
+
 ```bash
 package-build site serve
 ```

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.3",
     "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/content-config.d.mts

@@ -25,6 +25,20 @@ export function siteBase(config: {
         base: string;
     };
 }): string;
+/**
+ * Apply validated runtime site URLs to a resolved configuration, without changing it.
+ * The caller checks the authored homepage before applying these build options.
+ *
+ * @param {ContentBuildConfig} config - The resolved authored configuration.
+ * @param {object} options - Runtime options.
+ * @param {string} [options.baseUrl] - Absolute HTTP(S) site URL ending in `/`.
+ * @param {string} [options.assets] - Absolute HTTP(S) asset root.
+ * @returns {ContentBuildConfig} The effective configuration, frozen.
+ */
+export function siteBuildConfig(config: ContentBuildConfig, { baseUrl, assets }: {
+    baseUrl?: string | undefined;
+    assets?: string | undefined;
+}): ContentBuildConfig;
 /**
  * Whether this package publishes the pages its content tree compiles to.
  *

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;