@heroiclands/package-build 22.12.2 → 22.13.0

package/engine/address.mjs

@@ -79,41 +79,25 @@
  * to guess which sense was meant. The cost is that `<package>-<type>-<shortcode>`
  * is **not** a written form, so a link into another package states its system.
  *
- * ## The three rules a complete tuple applies
- *
- * - **`system` is derived from the type, then defaulted.** An asset type and a
- *   documentation journal are {@link NO_SYSTEM} because a file and a
- *   JournalEntry belong to no game system, and the segment is therefore a
- *   property of the type rather than of where the reference was written.
- *   Everything else takes the written system, then the position's default.
- * - **`type` may not survive unchanged.** A system-bearing type reached at
- *   `none` is redirected to `doc<type>`, because a note's `none` address *is*
- *   its documentation journal — the Item is the one with a system.
- * - **Acceptability accepts a type's documentation form.** A position that
- *   accepts `weapongear` accepts `docweapongear`, so a target addressed by its
- *   documentation journal is acceptable wherever the note itself would be.
+ * ## Defaults belong to the citing position
+ *
+ * Ordinary wikilinks default to `note`, embeds default to `none`, and typed
+ * frontmatter fields supply their declared system. The authored type stays
+ * the type in the complete tuple. A `doc<type>` qualifier is accepted as an
+ * input spelling for a readable note and resolves to `note-<type>`.
  *
  * ## The tuple keeps no memory of how it was written
  *
  * An abbreviation is a *rendering*, not a different value: `being-kaldor` in a
- * `thalorna` note and `thalorna-none-being-kaldor` are the same Address, and
- * they parse to the same four fields. So does the pair `weapongear-dgr` in prose
- * and `docweapongear-dgr` anywhere, because both name the one documentation
- * journal. Nothing here records what the author typed — a tuple that did would
- * make identity depend on a spelling, and two notes naming one document would
- * compare unequal.
+ * `thalorna` note and `thalorna-note-being-kaldor` are the same Address, and
+ * they parse to the same four fields. Nothing here records what the author
+ * typed — a tuple that did would make identity depend on a spelling.
  *
  * The converse matters just as much: **one written string is two Addresses at
  * two positions**, because the positions supply different defaults.
  * `skill-wpnc` under `sohl.items` defaults its system from the block and names
- * the **Item**; the same string in body prose defaults to `none`, is redirected,
- * and names the **page**. Only the resolved tuple can tell them apart.
- *
- * That is why {@link acceptsType} widens the accepted set rather than reading a
- * remembered pre-redirect type off the tuple. The redirect is not reversible
- * from the four segments alone: `docmacro-autoattack` addresses a `macro`'s
- * journal while `macro-autoattack` addresses the Macro, so `doc`-stripping is a
- * question about the type vocabulary, not about the tuple.
+ * the Item; the same string in body prose defaults to `note` and names the
+ * readable page. Only the resolved tuple can tell them apart.
  *
  * ## What this module does not do
  *
@@ -132,17 +116,15 @@
 // `engine/systems.mjs` imports nothing but `engine/address-charset.mjs`, so the
 // direction is toward the leaf and cannot close a cycle.
 import { isAddressSegment } from "./address-charset.mjs";
-import { NO_SYSTEM, assertSystemSegment, isSystemSegment } from "./systems.mjs";
-// The asset vocabulary, for the one thing the address grammar asks of it:
-// whether a type's `<system>` segment is fixed. `engine/asset-types.mjs` is a
-// leaf, so the direction cannot close a cycle.
-import { isAssetType } from "./asset-types.mjs";
+import { NO_SYSTEM, NOTE_SYSTEM, assertSystemSegment, isSystemSegment } from "./systems.mjs";
+// Document subtype maps identify the system of a note's own Actor or Item.
 import { systemOf } from "./document-subtypes.mjs";
 import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
 // `ids.mjs` is a leaf with no local imports, and `pack-config.mjs` reaches only
 // the configuration loader and the diagnostics writer — neither reads an
 // address, so the grammar sits below everything that consumes it.
-import { currentType, ITEM_PACK, packForType } from "./ids.mjs";
+import { currentType, ITEM_PACK, JOURNAL_TYPES, packForType } from "./ids.mjs";
+import { HOMEPAGE_TYPE } from "./homepage.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
 
 export { NO_SYSTEM };
@@ -166,32 +148,18 @@ export const ADDRESS_SEPARATOR = "-";
  */
 export const CANONICAL_KEY_SEGMENTS = 4;
 
-/**
- * The qualifier prefix that addresses a note's **documentation** rather than
- * the note's own document: `docskill-wpnc` is the JournalEntry that
- * `skill-wpnc`'s prose compiled into.
- *
- * Every doc-carrying type has a `doc<type>` counterpart, formed by prefix and
- * never enumerated, so the prefix itself is the whole of that vocabulary.
- *
- * @type {string}
- */
+/** The accepted `doc<type>` input prefix for readable note links. */
 export const ITEM_DOC_PREFIX = "doc";
 
 /** Package, system and type are one spelling each, so they fold to lowercase. */
 const norm = (s) => String(s).toLowerCase().trim();
 
 /**
- * A complete Address: four segments, and nothing else.
- *
- * `type` is the segment the canonical string carries, after the `doc<type>`
- * redirect. There is no fifth field recording the written form, because the
- * written form is a rendering rather than part of the value.
+ * A complete Address: four segments, with no memory of the authored form.
  *
  * @typedef {object} AddressTuple
  * @property {string} package - The owning **content** package.
- * @property {string} system - The system whose document this addresses, or
- *   `none`.
+ * @property {string} system - `note`, `none`, or a game system id.
  * @property {string} type - The type segment of the canonical Address.
  * @property {string} shortcode - The note's `shortcode`.
  */
@@ -218,29 +186,8 @@ const norm = (s) => String(s).toLowerCase().trim();
  */
 
 /**
- * Every content type whose **prose compiles into a JournalEntry of its own**,
- * addressed by the virtual `doc<type>` qualifier.
- *
- * Every item type, every actor type, every map type, plus `macro` — a macro
- * note's body documents the script the note also compiles into a Macro, which
- * is the same shape as an item and its description: one note, two documents,
- * the prose living in the journals pack.
- *
- * **One set, read by the compilers and by the grammar alike.** The journals
- * pass decides what to compile from it, the link manifest decides what to
- * publish a `doc<type>` entry for, and the parser decides whether `doc<type>`
- * is a legal type segment. Held apart, the three drift into a manifest that
- * asserts documentation nothing compiled, a compiled entry no consumer can
- * address, or an authored `doc<type>` link that stops parsing. It is composed
- * exactly once, in `defineConfig`, and read from there — never recomposed at a
- * call site.
- *
- * `doc` notes are absent, for the reason that applies to them alone: a `doc`
- * note's single document *is* its prose, so there is no second document for a
- * `doc<type>` address to name.
- *
- * An accessor rather than a hoisted constant, so that importing this module
- * needs no configuration.
+ * The configured types whose prose compiles into a separate JournalEntry.
+ * The journal has a `note` Address with the authored type segment.
  *
  * @returns {ReadonlySet<string>} The configured doc-carrying types.
  */
@@ -265,50 +212,20 @@ export function hasDocEntry(type) {
     return docEntryTypes().has(String(currentType(type)));
 }
 
-/**
- * Whether a note type's **own** document carries a game system.
- *
- * True for the types some shipped map compiles into an Item or an Actor; false
- * for the core-document types — `doc`, `lore`, `place`, `scenario`, `macro` and
- * the map types — whose documents Foundry itself defines and which therefore
- * already live at `none`.
- *
- * It is what the `doc<type>` redirect tests rather than {@link hasDocEntry}: a
- * `macro` has a documentation journal *and* a `none` address of its own, so
- * redirecting on "has a doc entry" would collapse two live addresses into one
- * and a `[[macro-autoattack|]]` would stop naming the Macro.
- *
- * @param {string} type - The note type.
- * @returns {boolean} True when the type compiles into a system document.
- */
-function isSystemBearing(type) {
-    return systemOf(type, KNOWN_DOCUMENT_SUBTYPE_MAPS) !== NO_SYSTEM;
+/** The segment of a note's own document. */
+export function ownDocumentSystem(type) {
+    return JOURNAL_TYPES.has(String(type)) || type === HOMEPAGE_TYPE ?
+            NOTE_SYSTEM
+        :   systemOf(type, KNOWN_DOCUMENT_SUBTYPE_MAPS);
 }
 
 /**
- * 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 docEntryTypes} — the set the journals compiler and the link manifest
- * read too), **or** for one that routes to the items pack. The second clause
- * covers the open, unenumerated set: types that compile into items are not
- * enumerated anywhere, 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 type segment.
- * @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.
+ * Read a `doc<type>` input qualifier as the underlying authored type.
+ * A real type with that spelling takes precedence.
+ *
+ * @param {string} qualifier - The type segment from the input.
+ * @param {Set<string>} types - Types in the content tree.
+ * @returns {string|null} The underlying type, or `null`.
  */
 export function resolveItemDocType(qualifier, types) {
     if (types.has(qualifier)) return null; // a real type owns its own name
@@ -445,21 +362,11 @@ export function renderAddress(tuple) {
 }
 
 /**
- * Whether the type an Address names is one this position accepts.
- *
- * The second of the two questions, and separate from the first because the
- * accepted **set** is a property of the position while the grammar is not.
- *
- * **An accepted type carries its documentation form with it.** A position
- * accepting `weapongear` accepts `docweapongear`, because the journal that
- * documents a weapon is the same thing to a position that wanted a weapon — and
- * a prose address of one *is* the journal, so refusing it would refuse the form
- * an author most often writes. It is the widening `defineConfig` applies to the
- * types a package may claim, applied here to the types a position may take.
+ * Whether the canonical type an Address names is accepted at this position.
  *
- * @param {AddressTuple} tuple - A parsed Address.
- * @param {Iterable<string>} allowed - The types this position accepts.
- * @returns {boolean} True when the Address names one of them.
+ * @param {AddressTuple} tuple - A complete Address.
+ * @param {Iterable<string>} allowed - Accepted types.
+ * @returns {boolean} Whether the type is accepted.
  */
 export function acceptsType(tuple, allowed) {
     const type = norm(tuple?.type ?? "");
@@ -467,7 +374,7 @@ export function acceptsType(tuple, allowed) {
     for (const one of allowed ?? []) {
         const want = norm(one);
         if (!want) continue;
-        if (type === want || type === `${ITEM_DOC_PREFIX}${want}`) return true;
+        if (type === want) return true;
     }
     return false;
 }
@@ -475,9 +382,7 @@ export function acceptsType(tuple, allowed) {
 /**
  * Apply the defaults to a partial reading, giving a complete Address.
  *
- * The three rules of the module note, applied in the order they depend on each
- * other: the package, then the system the type may fix, then the redirect the
- * system may force.
+ * Complete a parsed Address using the citing position's package and system.
  *
  * @param {{type: string, shortcode: string, package?: string, system?: string,
  *   itemDoc?: boolean}} read - A partial reading, as {@link readQualifier}
@@ -490,27 +395,8 @@ export function completeAddress(read, where = {}) {
     if (isAddressTuple(read)) return read;
     const written = read.type;
     const pkg = read.package ?? where.package;
-    // A documentation journal is a core document, so it is `none` however it was
-    // reached, and an **asset** is `none` for a stronger reason: a file belongs
-    // to no game system, so the segment is a property of the type rather than of
-    // where the reference was written. Without that, a `sohl:` block naming
-    // `icon-anvil` would expand to `sohl-sohl-icon-anvil` and resolve to
-    // nothing, which is exactly where an embedded item's art is written.
-    // Otherwise the block's system, which body prose reports as `none`.
-    const system =
-        read.itemDoc || isAssetType(written) ?
-            NO_SYSTEM
-        :   (read.system ?? where.system ?? NO_SYSTEM);
-    // **Under `none`, a system-bearing type addresses its documentation
-    // journal.** A note's `none` address *is* its `doc<type>` entry — the Item
-    // is the one with a system — so a prose `[[affiliation-sirvadar|…]]` names
-    // the page, which is almost always what prose means. A value that means the
-    // Item states the system and gets it. A `doc<type>` written explicitly is
-    // `none` wherever it appears, even inside a system block: no game system
-    // defines a JournalEntry.
-    const redirected = system === NO_SYSTEM && isSystemBearing(written);
-    const type = read.itemDoc || redirected ? `${ITEM_DOC_PREFIX}${written}` : written;
-    return addressTuple({ package: pkg, system, type, shortcode: read.shortcode });
+    const system = read.itemDoc ? NOTE_SYSTEM : (read.system ?? where.system ?? NOTE_SYSTEM);
+    return addressTuple({ package: pkg, system, type: written, shortcode: read.shortcode });
 }
 
 /**

package/engine/art-fields.mjs

@@ -88,7 +88,7 @@ export function artSlot(key) {
  *   not parse; or `not-accepted` when it parses to a type outside `accepts`.
  */
 export function artTarget(value, defaultType, accepts, vocabulary = {}) {
-    const tuple = parseAddress(value, { ...vocabulary, type: defaultType });
+    const tuple = parseAddress(value, { ...vocabulary, system: ASSET_SYSTEM, type: defaultType });
     if (tuple.reason) return tuple;
     if (accepts && !acceptsType(tuple, accepts)) {
         return { reason: "not-accepted", type: tuple.type };

package/engine/bundles.mjs

@@ -71,7 +71,7 @@ import {
 import { contentPackage } from "./content-package.mjs";
 import { FOLDER_TYPE } from "./folder-notes.mjs";
 import { HOMEPAGE_TYPE } from "./homepage.mjs";
-import { itemDocEntryId } from "./item-docs.mjs";
+import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
 import { folderField, renderFoundryMarkdown, resolveName } from "./helpers.mjs";
 import { packForType } from "./ids.mjs";
 import { readQualifier } from "./wikilinks.mjs";
@@ -251,8 +251,9 @@ export class Bundles extends BasePackCompiler {
 
         const baseType =
             isAddressTuple(read) ? resolveItemDocType(read.type, index.types) : undefined;
-        const itemDoc = read.itemDoc || Boolean(baseType);
         const type = baseType ?? read.type;
+        const itemDoc =
+            read.itemDoc || Boolean(baseType) || (read.system === "note" && hasDocEntry(type));
         const note = index.byShortcode.get(`${type}/${read.shortcode}`);
         if (!note) {
             throw new Error(

package/engine/content-address.mjs

@@ -45,7 +45,7 @@ import { DEFAULT_ADDRESS_SCHEME } from "../content-config.mjs";
 // The system vocabulary is the `<system>` segment's own registry, and
 // `engine/systems.mjs` imports nothing but `engine/address-charset.mjs`, so
 // the direction is toward the leaf and cannot close a cycle.
-import { NO_SYSTEM, isSystemSegment } from "./systems.mjs";
+import { NO_SYSTEM, NOTE_SYSTEM, isSystemId } from "./systems.mjs";
 
 // The address grammar, which sits below this module: a page URL is derived from
 // an address, so the rule for reading and writing one is stated there and
@@ -171,12 +171,9 @@ export function packageAddress(fm) {
  *
  * The **enclosing system block** decides, at any depth within it, and nothing
  * else does: `sohl.items[3].model` and `sohl.system.body.structure` are both
- * `sohl` because both sit under `sohl:`. Everywhere else is {@link NO_SYSTEM} —
- * top-level frontmatter, the shared `data:` container, and body prose, which has
- * no key path at all and passes `undefined`.
- *
- * It is the block rather than the field, so an `Address` field needs no opinion
- * about systems and no per-field table has to be kept in step with the schema.
+ * `sohl` because both sit under `sohl:`. Everywhere else takes
+ * {@link NOTE_SYSTEM}; fields declared for assets or folders supply their own
+ * `none` default at the field parser.
  *
  * The first segment must **be** a declared system, not merely look like one:
  * `sohlish.items` is a key called `sohlish`, and `notes.sohl.thing` names no
@@ -187,9 +184,9 @@ export function packageAddress(fm) {
  * @returns {string} The system id, or `none`.
  */
 export function blockSystem(keyPath) {
-    if (typeof keyPath !== "string" || !keyPath) return NO_SYSTEM;
+    if (typeof keyPath !== "string" || !keyPath) return NOTE_SYSTEM;
     const first = keyPath.split(".")[0].trim().toLowerCase();
-    return isSystemSegment(first) && first !== NO_SYSTEM ? first : NO_SYSTEM;
+    return isSystemId(first) ? first : NOTE_SYSTEM;
 }
 
 /**

package/engine/content-index.mjs

@@ -102,12 +102,13 @@ import unidecode from "unidecode";
 import { metadataFileName } from "./metadata-index.mjs";
 import { collectAssetRecords } from "./asset-index.mjs";
 import { addressSlug, canonicalKey } from "./content-address.mjs";
+import { ownDocumentSystem } from "./address.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
 // One reader for a note's anchors, shared with the link checker and with the
 // builds that emit a link. Re-exported because this is where callers
 // have always addressed it.
 import { collectAnchors } from "./anchors.mjs";
-import { subtypeRow, NO_SYSTEM, systemOf } from "./document-subtypes.mjs";
-import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./note-claims.mjs";
+import { NO_SYSTEM } from "./document-subtypes.mjs";
 
 /**
  * The `<system>` a note belongs to when it belongs to none.
@@ -204,7 +205,7 @@ export function noteAddress(frontmatter, contentPackage) {
         slug,
         canonical: canonicalKey(
             contentPackage,
-            systemOf(frontmatter.type, KNOWN_DOCUMENT_SUBTYPE_MAPS),
+            ownDocumentSystem(frontmatter.type),
             frontmatter.type,
             frontmatter.shortcode,
         ),
@@ -504,10 +505,7 @@ export function buildIndexRecord({
                             link: address ? `${address.slug}#${a.slug}` : null,
                         }))
                     ),
-                foundry: foundryBlock(
-                    entries?.own,
-                    systemOf(frontmatter?.type, KNOWN_DOCUMENT_SUBTYPE_MAPS),
-                ),
+                foundry: foundryBlock(entries?.own, ownDocumentSystem(frontmatter?.type)),
                 // Forward link to the note's documentation journal, which is its
                 // own record. Named rather than nested, because the journal is a
                 // separate document with its own address — see `buildDocRecord`.
@@ -536,7 +534,7 @@ export function buildIndexRecord({
  *
  * An item note compiles into two documents — the item, and a JournalEntry
  * holding its prose — and the second is a document in its own right: its own
- * canonical address (`doc<type>/<shortcode>`), its own UUID, its own pages.
+ * canonical `note` address with the authored type, its own UUID and pages.
  * So it gets its own record, and resolving `docaffliction/blkdth` is the same
  * lookup as resolving anything else. Nested inside the item's record it would
  * be the one address in the index reachable only by knowing to look somewhere
@@ -572,7 +570,7 @@ function buildDocRecord({ frontmatter, address, entry, file, contentPackage, anc
     return /** @type {Record<string, any>} */ (
         sortKeysDeep({
             package: contentPackage,
-            type: `doc${frontmatter.type}`,
+            type: frontmatter.type,
             shortcode: frontmatter.shortcode,
             name: frontmatter.name,
             // The journal's own `_id`, taken from the entry rather than
@@ -586,7 +584,7 @@ function buildDocRecord({ frontmatter, address, entry, file, contentPackage, anc
             // the forward link on that record, so either end reaches the other.
             documents: address.canonical,
             anchors: made ? anchors : null,
-            foundry: foundryBlock(entry), // a journal: no system key
+            foundry: foundryBlock(entry, NOTE_SYSTEM),
             file,
         })
     );

package/engine/content-links.mjs

@@ -76,8 +76,8 @@ import { ASSET_TYPE_NAMES } from "./asset-types.mjs";
 import { resolveEmbeds } from "./content-embeds.mjs";
 import { foundryAddressProblem, servesFoundry } from "./pathnames.mjs";
 import { hasDocEntry } from "./item-docs.mjs";
-import { NO_SYSTEM, systemOf } from "./document-subtypes.mjs";
-import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./note-claims.mjs";
+import { ownDocumentSystem } from "./address.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
 import { searchableFrontmatter } from "./note-package.mjs";
 import {
@@ -138,12 +138,8 @@ export function anchorsOf(body) {
  * before, since the walk read the file and it then read it again for the raw
  * text.
  *
- * The index mirrors what both builds construct, including the two addresses a
- * doc-carrying note answers to: `type/shortcode` for the document, and
- * `doc<type>/shortcode` for the JournalEntry its prose compiles into. Once a
- * manifest publishes `doc<type>` entries that prefix is a *known type*, and the
- * virtual reading that used to answer for it no longer fires — a real type owns
- * its own name — so the note is indexed under both.
+ * The index holds each compiled document under its complete Address. Readable
+ * content uses `note`, and system documents use their declared system.
  *
  * @param {string} contentBase - Root of the content tree.
  * @param {object} [opts]
@@ -250,24 +246,20 @@ export function buildLinkIndex(
             // once for the whole build.
             const canonical =
                 encodeAddresses(record.address?.canonical) ??
-                canonicalKey(pkg, systemOf(type, KNOWN_DOCUMENT_SUBTYPE_MAPS), type, fm.shortcode);
+                canonicalKey(pkg, ownDocumentSystem(type), type, fm.shortcode);
             // A note with no address publishes no page, so its identity is
             // filed where a link cannot reach it and a reference still can.
             const into = record.address ? byKey : byStub;
             into.set(canonical, note);
             if (hasDocEntry(type)) {
-                // A documentation journal is `none`: no game system defines a
-                // JournalEntry, and one note has one of them however many
-                // system blocks it carries.
-                into.set(canonicalKey(pkg, NO_SYSTEM, `doc${type}`, fm.shortcode), note);
+                // The prose has one `note` Address across all system blocks.
+                into.set(canonicalKey(pkg, NOTE_SYSTEM, type, fm.shortcode), note);
             }
         }
     }
 
     // The types a link may name, which are the ones notes declare. A
-    // documentation journal's `doc<type>` is deliberately not among them: it is
-    // virtual, and `readQualifier` resolves it from the base type rather than
-    // from a type any tree declares.
+    // The `doc<type>` input spelling is an alias, not a published type.
     //
     // The **asset** types join unconditionally, whether or not this tree holds
     // a file of each. They are a closed vocabulary rather than a census of what
@@ -423,7 +415,7 @@ export function buildLinkIndex(
         for (const [all, rawInner] of matchAllOutsideCode(body, new RegExp(WIKILINK.source, "g"))) {
             const parsed = readWikilink(rawInner, {
                 package: pkg,
-                system: "none",
+                system: "note",
                 types,
                 packages,
                 noIndexPackages,

package/engine/content-tables.mjs

@@ -1041,7 +1041,7 @@ export function renderContentTable(spec, rows, linkable, self) {
             const label = text.replace(/\\?\|/g, "/");
             const target = completeAddress(
                 { type: doc.fm.type, shortcode: doc.fm.shortcode },
-                { package: doc.fm.package ?? contentPackage(), system: "none" },
+                { package: doc.fm.package ?? contentPackage(), system: "note" },
             );
             return `[[${renderAddress(target)}\\|${label}]]`;
         }),

package/engine/foundry-entries.mjs

@@ -60,7 +60,8 @@ import path from "node:path";
 
 import { noteAddressContext } from "./note-addresses.mjs";
 import { canonicalKey, packageAddress } from "./content-address.mjs";
-import { NO_SYSTEM, systemOf } from "./document-subtypes.mjs";
+import { ownDocumentSystem } from "./address.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
 import {
     KNOWN_DOCUMENT_SUBTYPE_MAPS,
     NEVER_PACKED_TYPES,
@@ -150,12 +151,7 @@ export function anchorsOf(entryUuid, entryId, body, name) {
  */
 export function entriesForNote(fm, name, address, body, ctx) {
     const { contentPackage, foundryPackageId, packRouter } = ctx;
-    const key = canonicalKey(
-        contentPackage,
-        systemOf(fm.type, KNOWN_DOCUMENT_SUBTYPE_MAPS),
-        fm.type,
-        fm.shortcode,
-    );
+    const key = canonicalKey(contentPackage, ownDocumentSystem(fm.type), fm.type, fm.shortcode);
     // `buildManifest` records `packageRelative(url, base)`, so the pair it is
     // given has to round-trip. The address is already package-relative, so the
     // honest pair is the address under a base of `"/"` — which strips straight
@@ -244,7 +240,7 @@ export function entriesForNote(fm, name, address, body, ctx) {
         // `NO_SYSTEM`, whatever the item is: a documentation journal is a
         // JournalEntry, which no game system defines, and there is one of them
         // however many system blocks the note carries.
-        const docKey = canonicalKey(contentPackage, NO_SYSTEM, `doc${fm.type}`, fm.shortcode);
+        const docKey = canonicalKey(contentPackage, NOTE_SYSTEM, fm.type, fm.shortcode);
         const docEntryId = fm.id ? itemDocEntryId(fm.id) : undefined;
         const docUuid = uuidFor("doc", docEntryId);
         return [

package/engine/frontmatter-lint.mjs

@@ -1109,7 +1109,7 @@ export function lintNote(
     const fm = note.fm ?? {};
     const referenceContext = {
         package: index?.contentPackage,
-        system: "none",
+        system: "note",
         ...addressContext,
         types: new Set([
             ...Object.keys(vocabulary ?? {}),
@@ -1773,7 +1773,7 @@ export function lintFrontmatter(
                 index: references ? index : undefined,
                 addressContext: {
                     package: index.contentPackage,
-                    system: "none",
+                    system: "note",
                     types: index.types,
                 },
                 ...(systems ? { systems } : {}),

package/engine/metadata-index.mjs

@@ -54,7 +54,12 @@ import { metadataFileName, PACKAGEBUILD_PACKAGE } from "./packages.mjs";
 import { packageBuildRecords } from "./packagebuild-index.mjs";
 
 export { metadataFileName };
-import { PACKAGE_BASE, readCanonicalKey, resolvePackageUrl } from "./content-address.mjs";
+import {
+    PACKAGE_BASE,
+    canonicalKey,
+    readCanonicalKey,
+    resolvePackageUrl,
+} from "./content-address.mjs";
 import { HOMEPAGE_TYPE } from "./homepage.mjs";
 
 /**
@@ -369,11 +374,23 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
                 error.position = line >= 0 ? { line: line + 1 } : {};
                 throw error;
             }
-            referenceRecords.push(record);
-            const key = encodeAddresses(record?.address?.canonical);
+            let key = encodeAddresses(record?.address?.canonical);
             if (!key) continue;
-            const parts = readCanonicalKey(key);
+            let parts = readCanonicalKey(key);
             if (!parts) continue;
+            if (
+                parts.system === "none" &&
+                record.documents &&
+                parts.type.startsWith("doc") &&
+                record.type === parts.type
+            ) {
+                record.type = parts.type.slice(3);
+                key = canonicalKey(parts.package, "note", record.type, parts.shortcode);
+                parts = readCanonicalKey(key);
+                record.foundry = { note: record.foundry?.none };
+                record.address.canonical = key;
+            }
+            referenceRecords.push(record);
             // First writer wins, so two packages claiming one address cannot
             // make the build depend on the order the cache was read in.
             if (index.has(key)) continue;
@@ -436,11 +453,11 @@ export function loadForeignIndexes(config, localPackages, bases = PACKAGE_BASE)
             if (entry.url) {
                 const identity = completeAddress({
                     package: record.package,
-                    system: "none",
+                    system: "note",
                     type: record.type,
                     shortcode: record.shortcode,
                 });
-                if (identity.type !== record.type)
+                if (key !== renderAddress(identity))
                     pageAliases.push([
                         renderAddress(identity),
                         {