@heroiclands/package-build 22.12.3 → 22.13.0

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),
                         {

package/engine/note-addresses.mjs

@@ -24,7 +24,13 @@ export { AddressEntries, encodeAddresses, cloneAddressState } from "./address-va
 
 /** Structured positions whose Address is nested inside a declared container. */
 export const STRUCTURED_ADDRESSES = Object.freeze([
-    { path: ["packFolder"], shape: "scalar-or-map", type: "folder", accepts: ["folder"] },
+    {
+        path: ["packFolder"],
+        shape: "scalar-or-map",
+        type: "folder",
+        accepts: ["folder"],
+        system: "none",
+    },
     {
         noteType: "affiliation",
         path: ["data", "governance", "ranks", "*", "lore"],
@@ -67,6 +73,9 @@ export function addressPositions(fm, context = {}) {
                 shape,
                 type: field.ref,
                 accepts: field.accepts,
+                ...(ASSET_TYPE_NAMES.has(field.ref) || field.ref === "folder" ?
+                    { system: "none" }
+                :   {}),
             });
     }
     out.push(...STRUCTURED_ADDRESSES.filter((p) => !p.noteType || p.noteType === fm.type));
@@ -79,7 +88,7 @@ export function addressPositions(fm, context = {}) {
             shape: "scalar-or-map",
             type: "folder",
             accepts: ["folder"],
-            system,
+            system: "none",
         });
         out.push({
             path: [system, "items", "*", "model"],
@@ -93,7 +102,7 @@ export function addressPositions(fm, context = {}) {
                 shape: "value",
                 type: slot.type,
                 accepts: slot.accepts,
-                system,
+                system: "none",
             });
         const spec = context.systemBlocks?.[system];
         for (const [index, entry] of (Array.isArray(fm[system]?.items) ?
@@ -121,7 +130,13 @@ export function addressPositions(fm, context = {}) {
                         field.address.holds === "items" ? "list" : (field.address.holds ?? "value"),
                     type: field.address.type,
                     accepts: field.address.accepts,
-                    system,
+                    system:
+                        (
+                            ASSET_TYPE_NAMES.has(field.address.type) ||
+                            field.address.type === "folder"
+                        ) ?
+                            "none"
+                        :   system,
                 });
             }
         }
@@ -135,7 +150,10 @@ export function addressPositions(fm, context = {}) {
                 shape: field.address.holds === "items" ? "list" : (field.address.holds ?? "value"),
                 type: field.address.type,
                 accepts: field.address.accepts,
-                system,
+                system:
+                    ASSET_TYPE_NAMES.has(field.address.type) || field.address.type === "folder" ?
+                        "none"
+                    :   system,
             };
             out.push({ ...position, path: [system, "system", ...field.to.split(".")] });
             out.push({
@@ -143,7 +161,7 @@ export function addressPositions(fm, context = {}) {
                 path: [system, ...(field.legacyKey ?? field.name).split(".")],
             });
             if (field.name?.startsWith("data.") && field.topLevelMeans === undefined)
-                out.push({ ...position, system: "none", path: field.name.slice(5).split(".") });
+                out.push({ ...position, path: field.name.slice(5).split(".") });
         }
     }
     for (const position of [...out]) {
@@ -171,7 +189,7 @@ export function decodeNoteAddresses(fm, context) {
         const defaults = {
             ...context,
             types,
-            system: position.system ?? context.system ?? "none",
+            system: position.system ?? context.system ?? "note",
             type: position.type,
         };
         const fail = (value, path, description) => {
@@ -277,7 +295,7 @@ export function noteAddressContext(config) {
     }
     return {
         package: config.contentPackage,
-        system: "none",
+        system: "note",
         systemBlocks,
     };
 }
@@ -313,7 +331,7 @@ export function decodeIndexAddresses(record, context) {
             written,
             {
                 ...context,
-                system: "none",
+                system: "note",
                 types: new Set([...Object.keys(NOTE_VOCABULARY), ...ASSET_TYPE_NAMES]),
             },
             { declared: true },

package/engine/note-ids.mjs

@@ -44,6 +44,9 @@ import { documentId } from "./content-address.mjs";
 import { systemOf } from "./document-subtypes.mjs";
 import { contentPackage } from "./content-package.mjs";
 import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
+import { JOURNAL_TYPES } from "./ids.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
+import { HOMEPAGE_TYPE } from "./homepage.mjs";
 // The folder id's derivation, taken from the pass that owns it rather than
 // restated here — see the `folder` branch below. `folder-notes.mjs` reaches
 // only `content-address`, `address-charset`, `ids` and `retired-fields`, none
@@ -112,7 +115,9 @@ export function noteDocId(fm, { pkg, maps = KNOWN_DOCUMENT_SUBTYPE_MAPS } = {})
     // the two must answer alike about the same note or the divergence this
     // branch closes reopens under a capitalised `type: Folder`.
     if (type.toLowerCase() === FOLDER_TYPE) return folderDocId(owner, shortcode);
-    return documentId(owner, systemOf(type, maps), type, shortcode);
+    const system =
+        JOURNAL_TYPES.has(type) || type === HOMEPAGE_TYPE ? NOTE_SYSTEM : systemOf(type, maps);
+    return documentId(owner, system, type, shortcode);
 }
 
 /**

package/engine/place-relations.mjs

@@ -67,7 +67,7 @@ import { encodeAddresses } from "./address-values.mjs";
 
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 import { acceptsType, parseAddress, renderAddress } from "./address.mjs";
-import { NO_SYSTEM } from "./document-subtypes.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
 
 /* --------------------------------------------------------------------- */
 /*  The closed sets                                                       */
@@ -232,7 +232,7 @@ function addressDefaults(index) {
         packages: index?.packages,
         noIndexPackages: index?.noIndexPackages,
         package: index?.contentPackage,
-        system: NO_SYSTEM,
+        system: NOTE_SYSTEM,
         type: RELATION_TYPE,
     };
 }
@@ -356,7 +356,7 @@ function checkRelation(note, { field, index }) {
         here.package && self ?
             renderAddress({
                 package: here.package,
-                system: NO_SYSTEM,
+                system: NOTE_SYSTEM,
                 type: RELATION_TYPE,
                 shortcode: self,
             })
@@ -425,7 +425,7 @@ function checkRelation(note, { field, index }) {
                 "to",
                 `${label(i, "to")} must name a place — the other place's \`shortcode\`, or ` +
                     `its address as \`${RELATION_TYPE}-<shortcode>\` or ` +
-                    `\`<package>-${NO_SYSTEM}-${RELATION_TYPE}-<shortcode>\` for a place in ` +
+                    `\`<package>-${NOTE_SYSTEM}-${RELATION_TYPE}-<shortcode>\` for a place in ` +
                     `another package — but reads ${JSON.stringify(encodeAddresses(to))}`,
             );
         } else if (!acceptsType(read, [RELATION_TYPE])) {

package/engine/reference-targets.mjs

@@ -4,9 +4,10 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-import { completeAddress, renderAddress } from "./address.mjs";
-import { systemOf } from "./document-subtypes.mjs";
-import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
+import { completeAddress, ownDocumentSystem, renderAddress } from "./address.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
+import { JOURNAL_TYPES } from "./ids.mjs";
+import { hasDocEntry } from "./item-docs.mjs";
 
 /**
  * Names and published destinations for reference presentation.
@@ -21,10 +22,9 @@ export function buildReferenceTargets(records, published = new Map()) {
     for (const record of records) {
         if (!record.package || !record.type || !record.shortcode) continue;
         const value = { name: record.name?.full ?? record.name, subType: record.subType };
-        for (const system of new Set([
-            systemOf(record.type, KNOWN_DOCUMENT_SUBTYPE_MAPS),
-            "none",
-        ])) {
+        const systems = new Set([ownDocumentSystem(record.type)]);
+        if (JOURNAL_TYPES.has(record.type) || hasDocEntry(record.type)) systems.add(NOTE_SYSTEM);
+        for (const system of systems) {
             const address = completeAddress({
                 package: record.package,
                 system,

package/engine/shortcode-references.mjs

@@ -52,7 +52,7 @@ export function resolveShortcodeReference(indexes, code, hint) {
     const { address: native, value } = matches.values().next().value;
     const address = completeAddress({
         package: native.package,
-        system: "none",
+        system: "note",
         type: native.type,
         shortcode: native.shortcode,
     });

package/engine/site-index.mjs

@@ -61,12 +61,9 @@ import {
     parseAddress,
     renderAddress,
     isAddressTuple,
-    completeAddress,
+    ownDocumentSystem,
 } from "./address.mjs";
-import { NO_SYSTEM } from "./systems.mjs";
-import { systemOf } from "./document-subtypes.mjs";
-import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./note-claims.mjs";
-import { hasDocEntry } from "./item-docs.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
 import { contentPackage } from "./content-package.mjs";
 // The declared tag vocabulary, which is where `draft` is stated.
 import { isDraftNote } from "./note-vocabulary.mjs";
@@ -241,42 +238,14 @@ export function buildSiteIndex(
             // resolves it and records it as `pkg`. Never read out of
             // frontmatter: `package:` is retired.
             index.set(
-                canonicalKey(
-                    e.pkg ?? ownPackage,
-                    systemOf(type, KNOWN_DOCUMENT_SUBTYPE_MAPS),
-                    type,
-                    shortcode,
-                ),
+                canonicalKey(e.pkg ?? ownPackage, ownDocumentSystem(type), type, shortcode),
                 value,
             );
             if (e.pkg) packages.add(e.pkg);
-            // In Foundry an item and its documentation are two documents, so
-            // `skill/wpnc` and `docskill/wpnc` are two UUIDs. Here the
-            // item note renders as one page which *is* its documentation, so
-            // the two qualifiers alias one URL and an anchor on either is an
-            // ordinary in-page anchor. One authored link, correct in both
-            // builds — restricted to the types that actually have an item doc,
-            // so a qualifier the packs would reject is reported broken here too.
-            const proseAddress = completeAddress({
-                package: e.pkg ?? ownPackage,
-                system: NO_SYSTEM,
-                type,
-                shortcode,
-            });
-            if (proseAddress.type !== type || hasDocEntry(type)) {
-                contentTypes.add(`doc${type}`);
-                index.set(`doc${type}/${shortcode}`.toLowerCase(), value);
-                // The canonical documentation address too, so the page answers
-                // to the address a bare prose link expands to: body
-                // prose is under no system block, so it defaults to `none`, and
-                // a system-bearing type's `none` address is its `doc<type>`
-                // one. In Foundry that names a second document; here it names
-                // this same page, which is what makes one authored link correct
-                // in both builds.
-                index.set(
-                    canonicalKey(e.pkg ?? ownPackage, NO_SYSTEM, `doc${type}`, shortcode),
-                    value,
-                );
+            // A web page is the readable `note` target for every type.
+            if (ownDocumentSystem(type) !== NOTE_SYSTEM) {
+                // The same page answers to its readable Address.
+                index.set(canonicalKey(e.pkg ?? ownPackage, NOTE_SYSTEM, type, shortcode), value);
             }
         }
     }
@@ -375,7 +344,7 @@ export function resolveInfoboxRef(siteIndex, ref, hint) {
     }
     const context = {
         package: siteIndex.contentPackage ?? contentPackage(),
-        system: "none",
+        system: "note",
         types: siteIndex.contentTypes,
         packages: siteIndex.packages,
     };

package/engine/sql-tables.mjs

@@ -253,7 +253,7 @@ export async function openNotesDatabase(records, { dir, dependencies = [], addre
         addressContext: addressContext ?? {
             package: records.find((record) => record.package)?.package,
             types: new Set(Object.keys(NOTE_VOCABULARY)),
-            system: "none",
+            system: "note",
         },
         stubsExcluded,
         async query(sql) {

package/engine/systems.mjs

@@ -62,6 +62,9 @@ import { ADDRESS_SEGMENT_PATTERN, isAddressSegment } from "./address-charset.mjs
  */
 export const NO_SYSTEM = "none";
 
+/** The Address segment for a note's readable content. */
+export const NOTE_SYSTEM = "note";
+
 /**
  * Every game system this toolchain compiles for.
  *
@@ -86,7 +89,7 @@ export const SYSTEM_IDS = Object.freeze(new Set(["sohl", "hm3"]));
  *
  * @type {ReadonlySet<string>}
  */
-export const SYSTEM_SEGMENTS = Object.freeze(new Set([...SYSTEM_IDS, NO_SYSTEM]));
+export const SYSTEM_SEGMENTS = Object.freeze(new Set([...SYSTEM_IDS, NO_SYSTEM, NOTE_SYSTEM]));
 
 /**
  * Whether a value names a game system this toolchain knows.

package/engine/web-wikilinks.mjs

@@ -48,7 +48,7 @@ import { replaceOutsideCode } from "./code-fences.mjs";
 // address is matched the way a vendored manifest publishes it — by the
 // segments the target supplies, with the system wildcarded unless stated.
 import { canonicalKey, expandAddress, readCanonicalKey } from "./content-address.mjs";
-import { NO_SYSTEM } from "./systems.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
 // The one rule about a link's shape both builds share: it carries a label, and
 // {@link unlabelledLinkMessage} is the one place that says so.
 import { unlabelledLinkMessage } from "./wikilink-syntax.mjs";
@@ -102,7 +102,7 @@ function lookupRead(index, read, contentPackage) {
     // It replaced a system-blind short key for the unqualified form, which
     // could be silently overwritten by a second note of the same
     // `(type, shortcode)` under another system.
-    const key = expandAddress(read, { package: contentPackage, system: NO_SYSTEM });
+    const key = expandAddress(read, { package: contentPackage, system: NOTE_SYSTEM });
     const found = index.get(key);
     if (found || read.package) return found;
 
@@ -393,7 +393,7 @@ export function resolveWebWikilinks(body, ctx) {
     return replaceOutsideCode(embedded.markdown, WIKILINK, (all, rawInner) => {
         const parsed = readWikilink(rawInner, {
             package: ctx.contentPackage,
-            system: "none",
+            system: "note",
             types: ctx.contentTypes ?? new Set(),
             packages: ctx.packages,
             noIndexPackages: ctx.noIndexPackages,