@heroiclands/package-build 22.9.2 → 22.11.0

package/engine/wikilinks.mjs

@@ -82,15 +82,30 @@
  * Plain ESM with no Foundry and no filesystem access, so it is unit-testable.
  */
 
+import { resolveShortcodeReference } from "./shortcode-references.mjs";
+
+import { readWikilink } from "./wikilink-syntax.mjs";
 import crypto from "crypto";
 
 import { compendiumUuid, ITEM_PACK, packForType, pageUuid, PACK_BY_TYPE } from "./ids.mjs";
 import { readCanonicalKey } from "./content-address.mjs";
+// The address grammar. A wikilink *contains* an Address, so what counts as one
+// is stated there and read here — the anchor and the label are this module's,
+// and the tuple inside them is not.
+import {
+    ITEM_DOC_PREFIX,
+    readQualifier,
+    resolveItemDocType,
+    parseAddress,
+    renderAddress,
+    isAddressTuple,
+    completeAddress,
+} from "./address.mjs";
 import { ASSET_TYPE_NAMES } from "./asset-types.mjs";
-import { isSystemSegment, NO_SYSTEM } from "./systems.mjs";
+import { NO_SYSTEM } from "./systems.mjs";
 import { systemOf } from "./document-subtypes.mjs";
 import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
-import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
+import { itemDocEntryId } from "./item-docs.mjs";
 import { replaceOutsideCode } from "./code-fences.mjs";
 // The syntax lives in `./wikilink-syntax.mjs`, so the web resolver and this
 // one cannot disagree about what counts as a link.
@@ -104,227 +119,14 @@ import {
 export { ITEM_PACK, PACK_BY_TYPE, packForType };
 
 /**
- * The qualifier prefix that addresses an item's **documentation** rather than
- * the item: `docskill/wpnc` is the JournalEntry that `skill/wpnc`'s prose
- * compiled into. See {@link resolveItemDocType}.
- */
-const ITEM_DOC_PREFIX = "doc";
-
-const norm = (s) => String(s).toLowerCase().trim();
-
-/**
- * Reads a qualifier as the **virtual `doc<type>`** form, or reports that it is
- * not one.
- *
- * A document and its documentation are two documents in two packs, so they
- * need two addresses. `skill/wpnc` is the item; `docskill/wpnc` is the
- * JournalEntry its prose compiled into, and `docmacro/autoattack` is the same
- * arrangement for a macro.
- *
- * The virtual form exists for a type that carries separate documentation
- * ({@link sohl.utils.packs.docEntryTypes} — the set the journals compiler and
- * the link manifest read too), **or** for one that routes to the items pack.
- * The second clause is the older rule and stays: types that compile into items
- * are the open, unenumerated set, and a foreign package may publish an
- * item type this build has never heard of. Dropping it would silently unlink
- * every `doc<type>` address into such a package.
- *
- * A **real** type of the same name always wins: the virtual reading is only
- * consulted for a qualifier no authored note claims.
- *
- * @param {string} qualifier - The already-normalised text before the `/`.
- * @param {Set<string>} types - Every type the content tree contains.
- * @returns {string|null} The underlying document type, or `null` when the
- *   qualifier is not a virtual one.
- */
-export function resolveItemDocType(qualifier, types) {
-    if (types.has(qualifier)) return null; // a real type owns its own name
-    if (!qualifier.startsWith(ITEM_DOC_PREFIX)) return null;
-    const base = qualifier.slice(ITEM_DOC_PREFIX.length);
-    if (!base || !types.has(base)) return null;
-    if (hasDocEntry(base)) return base;
-    return packForType(base).docType === ITEM_PACK.docType ? base : null;
-}
-
-/**
- * Read a link target as a **qualified** `type-shortcode` reference, or report
- * that it does not parse as one.
- *
- * Two separators are accepted, and they are **not** interchangeable in how
- * confidently they mark a target as qualified:
- *
- * - **`type-shortcode`** and its qualified forms — the canonical spelling.
- * Obsidian reads `/` inside a wikilink as a *path* and resolves it
- *   against the vault's folders, so a slash-qualified link is a broken link in
- *   the editor where the content is now authored.
- * - **`type/shortcode`** — the legacy form, still resolved so that a link
- *   written before the vault migrated does not silently die. A slash is
- *   *unconditionally* a qualifier: nothing else uses one, so an unknown type
- *   before it is reported rather than guessed at. The split is at the **last**
- *   slash, as it always was.
- *
- * **The grammar is strict, and omission runs left to right**:
- *
- * ```text
- * [[[[<package>-]<system>-]<type>-]<shortcode>]
- * ```
- *
- * So the written forms are exactly the suffixes of the canonical address —
- * `type-shortcode`, `system-type-shortcode`, `package-system-type-shortcode` —
- * and **`package-type-shortcode` is not one of them**. A link into another
- * package must therefore be fully qualified, which is the price of the segment
- * being positional rather than tagged.
- *
- * **Parsing is plain positional counting**, the same rule
- * {@link readCanonicalKey} follows, and it is sound for the same reason: every
- * segment matches `ADDRESS_SEGMENT_PATTERN` (enforced on shortcodes by
- * `content-lint.mjs`), so the hyphen is purely a
- * separator and the count alone determines every field. Verified across the
- * four content trees: 138,204 authored shortcodes, none carrying a separator.
- *
- * That replaced a first-hyphen split which let a shortcode contain a hyphen
- * (`trauma-self-pro` → `trauma` + `self-pro`). The tolerance predates the
- * charset rule and
- * outlived it; no tree has used it, and keeping it would make a three-segment
- * target ambiguous between a system and a hyphenated shortcode.
- *
- * **`sohl` is both a package and a system**, and positional counting is what
- * makes that harmless: three segments is `<system>-<type>-<shortcode>` whatever
- * the first segment could also have named, and four is the full form. Nothing
- * has to guess which sense was meant.
- *
- * **A partial address states what it states, and the rest is not invented.** An
- * omitted **system** is a *wildcard* — most links target items, which belong to
- * a system — so the caller matches on the segments supplied and requires
- * exactly one hit. An omitted **package** is instead *defaulted* to the citing
- * note's own, so an unqualified link resolves locally and only locally.
- *
- * @param {string} target - The link target, anchor already removed.
- * @param {Set<string>} types - Every type the content tree contains.
- * @param {Set<string>} [packages] - Every package an address may name. Omitted
- *   by callers that resolve within one package, where the form cannot occur.
- * @param {Set<string>} [noIndexPackages] - Packages declared `contentIndex:
- *   false` — a Foundry dependency only, with no fetched index. A fully
- *   qualified target naming one is refused with `no-content-index` before its
- *   type is even considered, since there is no index to resolve it against.
- * @returns {{type: string, shortcode: string, itemDoc: boolean,
- *   package?: string, system?: string, reason?: undefined}
- *   | {reason: "unknown-type"|"no-content-index", package?: string} | null}
- *   The resolved qualifier; a `reason` when the target is definitely qualified
- *   but names no known type or no fetched index; or `null` when it is not an
- *   address at all.
- */
-export function readQualifier(target, types, packages, noIndexPackages) {
-    // **Package, system and type are lowercase; the shortcode is not.** A
-    // shortcode is case-sensitive and routinely mixed — `Clb`, `LtShoe`,
-    // `HsTunic` — so it is written as the note declares it. The three segments
-    // in front of it are closed vocabularies with one spelling each, and
-    // accepting `Skill` beside `skill` would bless two ways of writing one
-    // address. Reported rather than folded, so the corpus has one form.
-    //
-    // Tested only once the target *parses*: a note name is full of capitals
-    // (`[[Shock State]]`), and calling that a badly-cased address rather than
-    // not an address would name the wrong mistake. Neither tree carries a
-    // violation — 10,538 authored targets — so this pins a rule already kept.
-    const read = readQualifierCased(target, types, packages, noIndexPackages);
-    if (read && !read.reason && qualifyingSegments(target).some((s) => /[A-Z]/.test(s))) {
-        return { reason: "not-lowercase" };
-    }
-    return read;
-}
-
-/**
- * The segments of a target that must be lowercase — everything but the
- * shortcode, which is case-sensitive and keeps whatever the note declares.
- *
- * @param {string} target - The link target, anchor already removed.
- * @returns {string[]} The package / system / type segments, as written.
- */
-function qualifyingSegments(target) {
-    const slash = target.lastIndexOf("/");
-    // The legacy `type/shortcode` form states only a type.
-    if (slash > 0) return [target.slice(0, slash)];
-    const parts = target.split("-");
-    return parts.slice(0, -1);
-}
-
-/**
- * {@link readQualifier} without the lowercase rule — the grammar alone.
+ * The address grammar, under the names the link resolvers hold it by.
  *
- * @param {string} target
- * @param {Set<string>} types
- * @param {Set<string>} [packages]
- * @param {Set<string>} [noIndexPackages]
- * @returns {object|null}
+ * {@link readQualifier} reads a link target as the partial Address the matchers
+ * consume, and {@link resolveItemDocType} is the `doc<type>` reading it applies.
  */
-function readQualifierCased(target, types, packages, noIndexPackages) {
-    // The slash form is legacy and states neither package nor system, so it is
-    // read first and separately. A slash is unconditionally a qualifier —
-    // nothing else uses one — which is why an unknown type before it is
-    // *reported* rather than read as prose.
-    const slash = target.lastIndexOf("/");
-    if (slash > 0) {
-        const read = readTypeAndCode(target.slice(0, slash), target.slice(slash + 1), types);
-        return read ?? { reason: "unknown-type" };
-    }
-
-    const parts = target.split("-");
-    switch (parts.length) {
-        // `<type>-<shortcode>`
-        case 2:
-            return readTypeAndCode(parts[0], parts[1], types);
-
-        // `<system>-<type>-<shortcode>` — the package defaults to local.
-        case 3: {
-            const system = norm(parts[0]);
-            if (!isSystemSegment(system)) return null;
-            const read = readTypeAndCode(parts[1], parts[2], types);
-            return read && { ...read, system };
-        }
-
-        // `<package>-<system>-<type>-<shortcode>` — the only form that names
-        // another package, and the reason a cross-package link must be fully
-        // qualified.
-        case 4: {
-            const pkg = norm(parts[0]);
-            // Checked before the type: a package with no fetched index has no
-            // vocabulary to resolve the rest of the target against, and the
-            // fix is the config declaration, not the shortcode.
-            if (noIndexPackages?.has(pkg)) return { reason: "no-content-index", package: pkg };
-            if (!packages?.has(pkg)) return null;
-            const system = norm(parts[1]);
-            if (!isSystemSegment(system)) return null;
-            const read = readTypeAndCode(parts[2], parts[3], types);
-            return read && { ...read, system, package: pkg };
-        }
-
-        // One segment is a bare name, which is not an address; five or
-        // more is not a hyphenated shortcode but a name that happens to carry
-        // separators, since no segment may contain one.
-        default:
-            return null;
-    }
-}
+export { readQualifier, resolveItemDocType };
 
-/**
- * Resolve a qualifier/shortcode pair, honouring the virtual `doc<type>` form.
- *
- * @param {string} rawType
- * @param {string} rawCode
- * @param {Set<string>} types
- * @returns {{type: string, shortcode: string, itemDoc: boolean} | null}
- *   `null` when the qualifier names no known type, or the shortcode is empty.
- */
-function readTypeAndCode(rawType, rawCode, types) {
-    const shortcode = norm(rawCode);
-    if (!shortcode) return null;
-
-    let type = norm(rawType);
-    const base = resolveItemDocType(type, types);
-    if (base) return { type: base, shortcode, itemDoc: true };
-    if (!types.has(type)) return null;
-    return { type, shortcode, itemDoc: false };
-}
+const norm = (s) => String(s).toLowerCase().trim();
 
 /**
  * The deterministic JournalEntryPage id for one anchor: SHA-256 of
@@ -384,7 +186,7 @@ export function buildWikilinkIndex(
     packageId,
     foreign,
     contentPackage,
-    { assets, noIndexPackages } = {},
+    { assets, noIndexPackages, referenceTargets, foreignReferences } = {},
 ) {
     if (!packageId) {
         throw new Error(
@@ -479,6 +281,8 @@ export function buildWikilinkIndex(
 
     return {
         byShortcode,
+        referenceTargets,
+        foreignReferences,
         types,
         uuidByDoc,
         packageId,
@@ -654,8 +458,14 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
     // one capture group. It is what makes two identical unresolved links on
     // one note tellable apart, and a position reportable at all.
     const out = replaceOutsideCode(markdown, WIKILINK, (all, rawInner, offset) => {
-        const parsed = parseWikilink(rawInner);
-        const target = parsed.target;
+        const parsed = readWikilink(rawInner, {
+            package: index.contentPackage,
+            system: "none",
+            types: index.types,
+            packages: index.packages,
+            noIndexPackages: index.noIndexPackages,
+        });
+        const target = parsed.rawTarget;
         const slug = parsed.anchor || null;
 
         // **Every link carries a label**. Without one there is nothing
@@ -692,12 +502,7 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
         if (target === "" && slug) {
             doc = { type, id, pack, docPack };
         } else {
-            const qualified = readQualifier(
-                target,
-                index.types,
-                index.packages,
-                index.noIndexPackages,
-            );
+            const qualified = parsed.problem ?? parsed.target;
             qualifiedRead = qualified;
             // A target that does not parse as an address is a defect: there is
             // no second namespace left to fall through to.
@@ -723,11 +528,10 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
             // their own documents are core ones already at `none`, so
             // `macro-autoattack` names the Macro and `docmacro-autoattack` its
             // journal — two live addresses the redirect would collapse.
-            itemDoc =
-                qualified.itemDoc ||
-                ((qualified.system ?? NO_SYSTEM) === NO_SYSTEM &&
-                    systemOf(qualified.type, KNOWN_DOCUMENT_SUBTYPE_MAPS) !== NO_SYSTEM);
-            doc = index.byShortcode.get(`${qualified.type}/${qualified.shortcode}`);
+            const baseType = resolveItemDocType(qualified.type, index.types);
+            itemDoc = Boolean(baseType);
+            if (qualified.package === index.contentPackage)
+                doc = index.byShortcode.get(`${baseType ?? qualified.type}/${qualified.shortcode}`);
         }
         if (!doc) {
             // Nothing local answers. A foreign package may publish this
@@ -843,42 +647,6 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
     return { markdown: out, unresolved };
 }
 
-/**
- * The short `type/shortcode` view of an index's foreign entries.
- *
- * Derived once per index and memoised: a compile resolves references on every
- * one of thousands of notes, and rebuilding the view per note would rescan a
- * dependency's whole published index each time. Keyed on the index object, so
- * it is discarded with it.
- *
- * An address two foreign packages both claim is left out rather than resolved
- * to whichever loaded first — the same rule the wikilink resolver follows.
- *
- * @type {WeakMap<object, Map<string, object>>}
- */
-const FOREIGN_BY_SHORTCODE = new WeakMap();
-
-/** The memoised short view of `index.foreign`. */
-function foreignByShortcode(index) {
-    const cached = FOREIGN_BY_SHORTCODE.get(index);
-    if (cached) return cached;
-    const short = new Map();
-    const ambiguous = new Set();
-    for (const [key, value] of index?.foreign ?? []) {
-        const parts = readCanonicalKey(key);
-        if (!parts) continue;
-        const shortKey = `${norm(parts.type)}/${norm(parts.shortcode)}`;
-        if (short.has(shortKey) && short.get(shortKey).package !== value.package) {
-            ambiguous.add(shortKey);
-        } else {
-            short.set(shortKey, value);
-        }
-    }
-    for (const key of ambiguous) short.delete(key);
-    FOREIGN_BY_SHORTCODE.set(index, short);
-    return short;
-}
-
 /**
  * Resolve one reference against a compile's address index.
  *
@@ -892,46 +660,64 @@ function foreignByShortcode(index) {
  * @param {object} index - From {@link buildWikilinkIndex}.
  * @param {unknown} ref - The reference, as authored.
  * @param {object} [hint] - `{type}`, where the caller knows what it expects.
- * @returns {{name?: string, uuid?: string, address?: string, subType?: string}|undefined}
+ * @returns {{name?: string, uuid?: string, address?: import("./address.mjs").AddressTuple, subType?: string}|undefined}
  *   The target, or `undefined` where nothing answers.
  */
 export function resolveReference(index, ref, hint) {
-    if (typeof ref !== "string" || !ref) return undefined;
-    const wanted = norm(ref);
-    const keys = [];
-    if (hint?.type) keys.push(`${norm(hint.type)}/${wanted}`);
-    if (wanted.includes("-")) {
-        const segments = wanted.split("-");
-        if (segments.length >= 2) {
-            keys.push(`${segments[segments.length - 2]}/${segments[segments.length - 1]}`);
-        }
-    }
-    if (!hint?.type) {
-        for (const type of [...(index?.types ?? [])].sort()) keys.push(`${type}/${wanted}`);
-    }
-
-    const foreign = foreignByShortcode(index);
-    for (const key of keys) {
-        const local = index?.byShortcode?.get(key);
-        if (local) {
-            return {
-                ...(local.name ? { name: local.name } : {}),
-                ...(local.subType ? { subType: local.subType } : {}),
-                ...(index.uuidByDoc?.get(local)?.uuid ?
-                    { uuid: index.uuidByDoc.get(local).uuid }
-                :   {}),
-                address: key.replace("/", "-"),
-            };
-        }
-        const away = foreign.get(key);
-        if (away) {
-            return {
-                ...(away.name ? { name: away.name } : {}),
-                ...(away.uuid ? { uuid: away.uuid } : {}),
-                ...(away.subType ? { subType: away.subType } : {}),
-                address: key.replace("/", "-"),
-            };
+    if (hint?.kind === "shortcode")
+        return resolveShortcodeReference(
+            [index.referenceTargets, index.foreignReferences ?? index.foreign],
+            ref,
+            hint,
+        );
+    const tuple = parseAddress(ref, {
+        package: index.contentPackage,
+        system: "none",
+        types: index.types,
+        packages: index.packages,
+        noIndexPackages: index.noIndexPackages,
+        type: hint?.type,
+    });
+    if (tuple.reason) return undefined;
+    const key = renderAddress(tuple);
+    const published =
+        index.referenceTargets?.get(key) ??
+        index.foreignReferences?.get(key) ??
+        index.foreign?.get(key);
+    if (published)
+        return {
+            name: published.name,
+            subType: published.subType,
+            ...(published.uuid ? { uuid: published.uuid } : {}),
+            address: tuple,
+        };
+    if (index.referenceTargets) return undefined;
+    {
+        const key = renderAddress(tuple);
+        if (tuple.package !== index.contentPackage) {
+            const foreign = index.foreign?.get(key);
+            if (foreign) return { ...foreign, address: tuple };
+            return undefined;
         }
+        const base = resolveItemDocType(tuple.type, index.types);
+        const type = base ?? tuple.type;
+        if (tuple.system !== (base ? NO_SYSTEM : systemOf(type, KNOWN_DOCUMENT_SUBTYPE_MAPS)))
+            return undefined;
+        const local = index.byShortcode?.get(`${type}/${tuple.shortcode}`);
+        if (!local) return undefined;
+        const addresses = index.uuidByDoc?.get(local);
+        const uuid =
+            base ?
+                Object.hasOwn(local, "documentationUuid") ?
+                    local.documentationUuid
+                :   addresses?.docUuid
+            :   addresses?.uuid;
+        return {
+            name: local.name,
+            subType: local.subType,
+            ...(uuid ? { uuid } : {}),
+            address: tuple,
+        };
     }
     return undefined;
 }

package/hm3/actors.mjs

@@ -26,13 +26,9 @@
  * the note says which, by writing `hm3.type`. An absent one is an error naming
  * the note, never a default.
  *
- * **What is emitted, and what is deliberately not.** Four rows of the content
- * format's `being` mapping table give HM3 a destination — `data.portrait` →
- * `system.bioImage`, `data.species`, `data.gender`, `data.occupation`, and
- * `data.templatePriority` → `flags.hm3.templatePriority` — and every one of
- * them is *declared as that source* rather than as the bare key the corpus
- * writes, so the specification's mapping is executable rather than
- * aspirational. Plus the two anchored prose sections: `{#appearance}` is HM3's
+ * Shared gender, occupation and template priority map to HM3's native fields.
+ * Native species text is independent of the lore Address in `data.species`.
+ * The anchored prose section `{#appearance}` supplies HM3's
  * `description` and `{#dossier}` its
  * `biography`. Everything else an HM3 actor carries — the thirteen abilities,
  * the sunsign, `move`, `fatigue`, `shockIndex`, a creature's `loadRating` — has
@@ -70,31 +66,19 @@ import {
 import { blockField, blockProperty, mergeSystemData } from "../engine/system-block.mjs";
 
 /**
- * The shared `data:` facts every HM3 actor takes, whatever its subtype.
+ * Native HM3 facts shared by its actor subtypes.
  *
- * Declared rather than read by hand, so a value resolves by the same order
- * every other declared field does — `hm3.system.<to>` first, then the in-block
- * position, then the shared source, then the default — and so the
- * author-facing reference can be generated from the same statement the compiler
- * obeys.
- *
- * **Both positions, named separately.** The specification maps
- * `data.species` onto `system.species`, and every HM3 note in the corpus writes
- * `hm3.species`. Until the sweep those are two live positions for one
- * field, so the declaration names both: `name` is the shared source, `legacyKey`
- * the key the block still carries, and the block wins while it is there. Naming
- * only one of them is what made the row unreadable — a plain `species` could
- * not see `data.species`, and a dotted `data.species` could not see the 2,512
- * notes that carry `hm3.species`, each yielding `""` in silence.
+ * Species is native text. The note's lore Address in `data.species` is
+ * independent and supplies no native value.
  *
  * @type {readonly import("../engine/field-spec.mjs").FieldSpec[]}
  */
 const ACTOR_FIELDS = Object.freeze([
     {
-        name: "data.species",
-        legacyKey: "species",
+        name: "species",
         to: "species",
         ...STRING,
+        topLevelMeans: "The shared species is a lore Address, independent of native species text.",
         default: "",
         describe: "The kind of creature this is.",
     },

package/hm3/item-fields.mjs

@@ -76,7 +76,8 @@ import { AS_AUTHORED, NUMBER } from "../engine/field-spec.mjs";
  */
 const GEAR_COMMON = Object.freeze([
     {
-        name: "weight",
+        name: "data.weight",
+        legacyKey: "weight",
         to: "weight",
         ...AS_AUTHORED,
         kind: "number",
@@ -84,7 +85,8 @@ const GEAR_COMMON = Object.freeze([
         describe: "Weight of one, in pounds.",
     },
     {
-        name: "value",
+        name: "data.value",
+        legacyKey: "value",
         to: "value",
         ...AS_AUTHORED,
         kind: "number",
@@ -104,7 +106,8 @@ const GEAR_COMMON = Object.freeze([
  * @type {import("../engine/field-spec.mjs").FieldSpec}
  */
 const QUANTITY = Object.freeze({
-    name: "quantity",
+    name: "data.quantity",
+    legacyKey: "quantity",
     to: "quantity",
     ...NUMBER,
     default: 1,
@@ -124,6 +127,11 @@ const QUANTITY = Object.freeze({
  * a registry is addressed by what a note calls itself. What the document is
  * called is the map's answer, and only the map's.
  *
+ * Each field names both of its authored positions, as
+ * {@link module:hm3/actors} does and for the same reason: `name` is the shared
+ * source the content format's mapping tables state, and `legacyKey` is the key
+ * the `hm3:` block still carries.
+ *
  * @type {Readonly<Record<string, readonly import("../engine/field-spec.mjs").FieldSpec[]>>}
  */
 export const HM3_ITEM_FIELDS = Object.freeze({
@@ -139,7 +147,8 @@ export const HM3_ITEM_FIELDS = Object.freeze({
     containergear: Object.freeze([
         ...GEAR_COMMON,
         {
-            name: "capacity",
+            name: "data.capacity",
+            legacyKey: "capacity",
             to: "capacity.max",
             ...NUMBER,
             default: 0,
@@ -161,7 +170,8 @@ export const HM3_ITEM_FIELDS = Object.freeze({
     // through, and only the mastery level is declared here.
     skill: Object.freeze([
         {
-            name: "masteryLevel",
+            name: "data.masteryLevel",
+            legacyKey: "masteryLevel",
             to: "masteryLevel",
             ...NUMBER,
             default: 0,

package/package.json

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