@heroiclands/package-build 18.1.1 → 19.0.0

package/content-config.mjs

@@ -27,7 +27,7 @@
  * itemBuilders: sohl
  * skipDirectories: [Templates]
  * packs:
- *     - { name: items, type: Item, folders: item-folders.yaml }
+ *     - { name: items, type: Item }
  *     - { name: journals, type: JournalEntry, label: Journals }
  * packageBuild:
  *     assets:
@@ -258,9 +258,6 @@ export function publishesContentPages(config) {
  * @property {PackDocumentType} type    Foundry document type the pack holds.
  * @property {string} [label]           Human-readable label. Defaults to `name`.
  * @property {boolean} [private]        Whether the pack is GM-only. Default `false`.
- * @property {string|null} [folders]    The pack's folder-hierarchy file, relative
- *                                      to `paths.content`. Default `null` — no
- *                                      folder documents are emitted.
  * @property {string} [prebuilt]        Directory holding this pack's per-document
  *                                     JSON, already built. Declaring it skips
  *                                     generation for the pack and compiles from
@@ -295,7 +292,6 @@ export function publishesContentPages(config) {
  * @property {PackDocumentType} type
  * @property {string} label
  * @property {boolean} private
- * @property {string|null} folders
  * @property {string|null} prebuilt
  * @property {string|null} system
  * @property {readonly Readonly<ResolvedPackSpec>[]} companions
@@ -658,7 +654,6 @@ const PACK_KEYS = [
     "type",
     "label",
     "private",
-    "folders",
     "companions",
     "mayBeEmpty",
     "default",
@@ -854,6 +849,19 @@ function optionalString(value, field) {
 function normalizePack(value, where, nested = false) {
     if (!isPlainObject(value)) fail(where, "must be an object");
     const pack = /** @type {Record<string, unknown>} */ (value);
+    // Retired with the YAML it named (#260). Refused explicitly rather than
+    // left to the unknown-key check, because the useful thing to say is not
+    // "no such key" but where the folders went: they are notes, and a pack
+    // materialises the ones its documents reference.
+    if (pack.folders !== undefined) {
+        fail(
+            `${where}.folders`,
+            "is retired — delete it. A folder is a note (`type: folder`) now, " +
+                "and a pack materialises the folders its documents reference " +
+                "through `packFolder`, so there is no per-pack hierarchy file " +
+                "to name",
+        );
+    }
     rejectUnknownKeys(pack, PACK_KEYS, `${where}.`);
 
     const name = requireNonEmptyString(pack.name, `${where}.name`);
@@ -865,10 +873,6 @@ function normalizePack(value, where, nested = false) {
         fail(`${where}.type`, `must be one of: ${PACK_DOCUMENT_TYPES.join(", ")}`);
     }
 
-    if (pack.folders !== undefined && pack.folders !== null) {
-        requireNonEmptyString(pack.folders, `${where}.folders`);
-    }
-
     const companionsInput = pack.companions;
     if (companionsInput !== undefined && !Array.isArray(companionsInput)) {
         fail(`${where}.companions`, "must be an array");
@@ -893,8 +897,8 @@ function normalizePack(value, where, nested = false) {
 
     // A prebuilt pack's per-document JSON already exists, so it has no
     // generation pass. Every key below describes one, which is why none of them
-    // may accompany it: silently ignoring a `folders` file that can never be
-    // read is worse than refusing the configuration that declares it.
+    // may accompany it: silently ignoring a key that can never be read is
+    // worse than refusing the configuration that declares it.
     const prebuilt =
         pack.prebuilt === undefined || pack.prebuilt === null ?
             null
@@ -907,13 +911,6 @@ function normalizePack(value, where, nested = false) {
                     "another pack's pass, and a prebuilt pack has no pass",
             );
         }
-        if (pack.folders !== undefined && pack.folders !== null) {
-            fail(
-                `${where}.folders`,
-                "may not accompany `prebuilt`: the folder hierarchy is built " +
-                    "during generation, which a prebuilt pack skips",
-            );
-        }
         if (Array.isArray(companionsInput) && companionsInput.length) {
             fail(
                 `${where}.companions`,
@@ -946,10 +943,6 @@ function normalizePack(value, where, nested = false) {
         label:
             pack.label === undefined ? name : requireNonEmptyString(pack.label, `${where}.label`),
         private: optionalBoolean(pack.private, `${where}.private`, false),
-        folders:
-            pack.folders === undefined || pack.folders === null ?
-                null
-            :   /** @type {string} */ (pack.folders),
         companions: Object.freeze(companions),
         mayBeEmpty: optionalBoolean(pack.mayBeEmpty, `${where}.mayBeEmpty`, false),
         // Which pack of a type receives a note that declares none. Validated

package/docs/content-format.md

@@ -507,12 +507,10 @@ of the same entry is a warning; the declaration still works.
 
 #### The compendium folder
 
-A note says which folder of its pack it lands in. Two spellings are read, and
-`packFolder` wins where both are present:
+A note says which folder of its pack it lands in:
 
 ```yaml
 packFolder: poisonsandtoxins # a folder note's address
-folder: ONXsqZAIZr2qzxTb # a Foundry id
 ```
 
 **`packFolder` is a folder note's address** — an ordinary address, resolved the
@@ -522,13 +520,6 @@ complete address here; `folder-poisonsandtoxins` and the fully qualified
 `sohl-none-folder-poisonsandtoxins` name the same folder. An address no folder
 note answers to is a build error naming the folders the package does declare.
 
-**`folder` is a Foundry id**, and is unchanged: a note that names one is read,
-resolved and emitted exactly as before.
-
-**Which one a value is comes from the field it was written in, never from the
-string.** Both are alphanumeric, so there is nothing in the value to tell them
-apart.
-
 Note this is the _pack_ folder, not the note's directory. The directory is
 `file.path` / `file.folder`, which a content table reads separately.
 
@@ -552,6 +543,14 @@ the first.
 > path form is **removed**, not deprecated: nothing authored it yet, which is
 > the whole reason the change was cheap enough to make.
 
+> **`folder:` was a Foundry id**, resolved against a per-pack
+> `*-folders.yaml` — five files per tree. Both halves are **retired** together
+> (#260): the id spelling has nothing left to resolve against once the YAML is
+> gone, and the YAML has no reader once the spelling is refused. A note that
+> still writes `folder:` fails the build, naming `packFolder` and the line to
+> rewrite, rather than being ignored — a retired field left ignored reads to
+> its author as though it still works.
+
 #### The knowledgebase category
 
 `kbcat` names the group a note is listed under on the knowledgebase and the
@@ -962,8 +961,9 @@ relational operations:
 `_section` is why one query replaces the forty near-identical blocks a grouped
 table used to need: the authored `ORDER BY` decides the section order too.
 
-**Beware `folder`.** It is a note's _pack_ folder, not its directory — the
-directory is `file.folder`.
+**Beware `packFolder`.** It is a note's _pack_ folder, not its directory — the
+directory is `file.folder`. (The `folder` field it replaced is retired; a query
+naming it matches nothing.)
 
 ###### Reading another package's notes
 
@@ -2125,7 +2125,8 @@ an Adventure pack declared first still compiles last.
 
 Foundry's `Folder` — the grouping documents are filed in, and the last document
 this package compiled from bespoke configuration (`*-folders.yaml`, five files
-per tree) rather than from a note.
+per tree) rather than from a note. Those files are retired (#260); a pack that
+still names one is refused.
 
 ```yaml
 ---

package/engine/base-compiler.mjs

@@ -78,6 +78,7 @@ import {
 import { isNoteRecord, noteFile } from "./index-records.mjs";
 import { emitDiagnostic } from "./diagnostics.mjs";
 import { assertNoDeclaredPackage } from "./note-package.mjs";
+import { assertNoDeclaredFolder } from "./folder-notes.mjs";
 import {
     assertNoAliasesField,
     assertNoDraftField,
@@ -895,6 +896,7 @@ export class BasePackCompiler {
             // neither message may repeat it.
             try {
                 assertNoDeclaredPackage(fm, { absPath });
+                assertNoDeclaredFolder(fm, { absPath });
                 assertNoDraftField(fm, { absPath });
                 assertNoAliasesField(fm, { absPath });
                 assertNoSectionField(fm, { absPath });

package/engine/folder-notes.mjs

@@ -56,6 +56,7 @@ import log from "loglevel";
 import { NO_SYSTEM, canonicalKey } from "./content-address.mjs";
 import { isAddressSegment } from "./address-charset.mjs";
 import { makeId } from "./ids.mjs";
+import { locateFrontmatterKey } from "./retired-fields.mjs";
 
 /**
  * The note type a folder is authored as.
@@ -468,3 +469,66 @@ export function folderDocument(folder, parent, documentType, stats) {
         _key: `!folders!${folder.id}`,
     };
 }
+
+/**
+ * Refuse a note that declares the retired `folder:` spelling.
+ *
+ * `folder:` named a compendium folder by the raw Foundry id declared in a
+ * per-pack `*-folders.yaml`. Both halves are retired together (#260): the id
+ * spelling has nothing left to resolve against once the YAML is gone, and the
+ * YAML has no reader once the spelling is refused.
+ *
+ * **Presence is the whole test.** An empty `folder:` — which parses as `null`
+ * — is still the field, and a value that happens to match a folder note's id
+ * is still the retired spelling. There is no value that makes writing it
+ * correct, so the message says what to write instead rather than which value
+ * to change.
+ *
+ * **Both positions**, because notes wrote it both ways: top-level, and inside
+ * the `sohl:` block. Checking only the more common one is how a sweep leaves
+ * a tail behind.
+ *
+ * Refused rather than ignored, on the pattern `package:` set: a retired field
+ * left ignored reads to its author as though it still works — the note says
+ * one thing and the build does another, and nothing says so.
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter, or nothing when it
+ *   could not be parsed.
+ * @param {object} [options] - Options.
+ * @param {string} [options.file] - The note's path, named in the message. Omit
+ *   it where the caller emits through a diagnostic, which puts the locator at
+ *   the start of the line already — repeating it prints the path twice.
+ * @param {string} [options.absPath] - The note's file on disk, read only on
+ *   the failing path to locate the offending line and column. The position
+ *   rides on the thrown error as `position`, for a caller that emits a
+ *   diagnostic.
+ * @returns {void}
+ * @throws {Error} When the note declares the field.
+ */
+export function assertNoDeclaredFolder(fm, { file, absPath } = {}) {
+    if (!fm || typeof fm !== "object") return;
+    const sohl = fm.sohl;
+    const inBlock = !!sohl && typeof sohl === "object" && Object.hasOwn(sohl, "folder");
+    if (!Object.hasOwn(fm, "folder") && !inBlock) return;
+
+    const declared = inBlock ? sohl.folder : fm.folder;
+    const wrote =
+        declared === null || declared === undefined || declared === "" ?
+            "`folder:`"
+        :   `\`folder: ${declared}\``;
+
+    const err = new Error(
+        `${wrote} is a retired frontmatter field — write \`packFolder\` ` +
+            `instead` +
+            (file ? ` — ${file}` : "") +
+            `. A folder is a note now, and \`packFolder\` names it by its ` +
+            `address (\`packFolder: miscgear\`), not by the Foundry id a ` +
+            `retired \`*-folders.yaml\` used to declare.`,
+    );
+    // Where the field is, so the caller's diagnostic opens on the line that
+    // has to be rewritten. Read here rather than carried through every walk:
+    // this is the failing path, and the build stops on it.
+    const position = locateFrontmatterKey(absPath, "folder");
+    if (position) err.position = position;
+    throw err;
+}

package/engine/foundry-entries.mjs

@@ -71,6 +71,7 @@ import { compendiumUuid, currentType, packForType, pageUuid } from "./ids.mjs";
 import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
 import { isHomepage } from "./homepage.mjs";
 import { assertNoDeclaredPackage } from "./note-package.mjs";
+import { assertNoDeclaredFolder } from "./folder-notes.mjs";
 import {
     assertNoAliasesField,
     assertNoDraftField,
@@ -273,6 +274,7 @@ export function collectFoundryEntries(contentBase, ctx) {
             absPath,
             configured: ctx.contentPackage,
         });
+        assertNoDeclaredFolder(fm, { file: rel, absPath });
         assertNoDraftField(fm, { file: rel, absPath });
         assertNoAliasesField(fm, { file: rel, absPath });
         assertNoSectionField(fm, { file: rel, absPath });

package/engine/frontmatter-lint.mjs

@@ -114,7 +114,7 @@ import {
  * @type {ReadonlySet<string>}
  */
 export const UNIVERSAL_KEYS = Object.freeze(
-    new Set(["folder", "packFolder", "pack", "archetype", "templatePriority", "kbcat"]),
+    new Set(["packFolder", "pack", "archetype", "templatePriority", "kbcat"]),
 );
 
 /**
@@ -744,6 +744,34 @@ export function lintNote(
                 "note in the tree belongs to it",
         });
     }
+    // `folder:` named a compendium folder by the raw Foundry id declared in a
+    // per-pack `*-folders.yaml`. Both halves are retired together (#260): the
+    // id spelling has nothing left to resolve against once the YAML is gone.
+    //
+    // Checked here as well as refused at compile because this is where an
+    // author meets every one of them in the tree at once — which is what a
+    // tree still to sweep needs, the whole corpus rather than the first note
+    // the compile happens to reach.
+    //
+    // **Both positions**, because notes wrote it both ways: top-level, and
+    // inside the `sohl:` block. The block spelling is no longer a universal
+    // key, so it would otherwise be reported as merely unrecognized, which
+    // says nothing about what to write instead.
+    const sohlBlock = fm.sohl;
+    const folderInBlock =
+        !!sohlBlock && typeof sohlBlock === "object" && Object.hasOwn(sohlBlock, "folder");
+    if (Object.hasOwn(fm, "folder") || folderInBlock) {
+        findings.push({
+            file: note.file,
+            ...at("folder"),
+            severity: "error",
+            message:
+                "`folder:` is a retired frontmatter field — write `packFolder` " +
+                "instead. A folder is a note (`type: folder`) now, and " +
+                "`packFolder` names it by its address, not by the Foundry id a " +
+                "retired `*-folders.yaml` used to declare",
+        });
+    }
     // `img: ""` was how a note said "I name no art" while `resolveImg`
     // conflated the two empties and every caller defaulted with `||`. It now
     // says the opposite — "ship no art, and do not default me" (#218) — so a

package/engine/frontmatter.mjs

@@ -329,5 +329,5 @@ export function parseValueDesc(raw) {
 export function folderField(fm) {
     const asAddress = sohlField(fm, "packFolder", null);
     if (asAddress != null && asAddress !== "") return { value: asAddress, isAddress: true };
-    return { value: sohlField(fm, "folder", null), isAddress: false };
+    return { value: null, isAddress: true };
 }

package/engine/generate.mjs

@@ -51,14 +51,7 @@ import { Hm3Actors } from "../hm3/actors.mjs";
 import { Macros } from "./macros.mjs";
 import { Scenes } from "./scenes.mjs";
 import { Bundles } from "./bundles.mjs";
-import {
-    statsForPack,
-    loadFolders,
-    buildFolderResolver,
-    writeFolderDocs,
-    parseMarkdownFile,
-    folderFilename,
-} from "./helpers.mjs";
+import { statsForPack, parseMarkdownFile, folderFilename } from "./helpers.mjs";
 import {
     buildFolderNoteIndex,
     collectFolderNotes,
@@ -359,7 +352,7 @@ export function unsatisfiedPassDependencies(running, config) {
  *     count (0 on success) and the number of entries it wrote.
  */
 async function generatePack(
-    { name, type, folders, companions, system },
+    { name, type, companions, system },
     config,
     router,
     routingReporter,
@@ -380,41 +373,27 @@ async function generatePack(
 
     log.info(`Pack ${name}: ${contentBase} → ${dest}`);
 
-    let folderList;
-    let yamlResolver;
-    try {
-        folderList = folders ? loadFolders(path.join(contentBase, folders)) : [];
-        ({ resolver: yamlResolver } = buildFolderResolver(folderList));
-    } catch (err) {
-        log.error(`${name} ${folders} validation failed: ${err.message}`);
-        return { errors: 1, compiled: 0 };
-    }
-
     // Which folder notes this pack turned out to hold something for. A folder
     // materialises in every pack holding a document that references it, so the
-    // set is not knowable until the pass has compiled — which is why these
-    // documents are written after `compile()` and the YAML ones before it
-    // (#257).
+    // set is not knowable until the pass has compiled, which is why these
+    // documents are written after `compile()` (#257).
     /** @type {Set<import("./folder-notes.mjs").FolderNote>} */
     const referencedFolders = new Set();
 
     /**
-     * The Foundry folder id a note names, by address or by id.
+     * The Foundry folder id a note names, by its folder note's address.
      *
-     * The two spellings resolve against two different sources and always did:
-     * `packFolder` names a folder **note**, resolved through the address index
-     * shared by the whole build, and `folder` names a Foundry **id** declared
-     * in this pack's own YAML. Which one applies is the field the value was
-     * written in, never the string (#251).
+     * There is one spelling. `packFolder` names a folder **note**, resolved
+     * through the address index shared by the whole build; the `folder:`
+     * Foundry-id spelling and the per-pack `*-folders.yaml` it resolved
+     * against are retired together (#260), so there is no second source left
+     * for a value to come from.
      *
      * @param {string|null|undefined} value - As authored.
-     * @param {object} [opts]
-     * @param {boolean} [opts.isAddress] - Whether `value` is a folder address.
      * @returns {string|null} The folder id, or `null` for an absent value.
      */
-    const resolver = (value, { isAddress = false } = {}) => {
+    const resolver = (value) => {
         if (value == null || value === "") return null;
-        if (!isAddress) return yamlResolver(value);
         const folder = folderNotes.resolve(value);
         // Its ancestors with it: a `Folder` whose parent is absent from the
         // pack is an orphan Foundry renders at the root, so materialising a
@@ -444,10 +423,6 @@ async function generatePack(
         companionDests[companion.name] = companionDest;
     }
 
-    // A folder document belongs to the pack it is written into, so it carries
-    // that pack's system rather than the package-wide one (#48).
-    writeFolderDocs(folderList, statsForPack(system, config), dest, type);
-
     const pack = new packClass({
         contentBase,
         dest,

package/engine/helpers.mjs

@@ -913,102 +913,9 @@ export function expandNoteTables(body, { docs, name, fm, bodyLine, sqlTables })
 }
 
 /* ------------------------------------------------------------------------ */
-/*  Folder hierarchy: loading, resolution, emission                         */
+/*  Folder document filenames                                               */
 /* ------------------------------------------------------------------------ */
 
-/**
- * Loads a folders.yaml file as an array of folder entries. Returns []
- * when the file is missing (logging a warning) so packs without folders
- * can opt out simply by not committing the file.
- */
-export function loadFolders(foldersFile) {
-    if (!fs.existsSync(foldersFile)) {
-        log.warn(`No folders.yaml at ${foldersFile}; no folders will be emitted`);
-        return [];
-    }
-    const raw = fs.readFileSync(foldersFile, "utf8");
-    const parsed = yaml.parse(raw);
-    if (parsed == null) return [];
-    if (!Array.isArray(parsed)) {
-        throw new Error(`folders.yaml must contain a YAML list; got ${typeof parsed}`);
-    }
-    return parsed;
-}
-
-/**
- * Validates folder invariants and returns a resolver function that maps a
- * folder id to the same id (after verifying it exists). Returns `null` for
- * a null/empty input; throws for an unknown id.
- *
- * Invariants:
- *   - Every folder must have a non-empty id
- *   - Every folder must have a name
- *   - Sibling folders (same parentFolderId) must have unique names
- *   - Every parentFolderId must match an existing folder id (or be "")
- *
- * Returns { resolver, folders } where folders is the validated list.
- */
-export function buildFolderResolver(folders) {
-    const byId = new Map();
-    for (const f of folders) {
-        if (!f.id) {
-            throw new Error(`Folder missing id: ${JSON.stringify(f)}`);
-        }
-        if (!f.name) {
-            throw new Error(`Folder ${f.id} missing name`);
-        }
-        if (byId.has(f.id)) {
-            throw new Error(`Duplicate folder id ${f.id}`);
-        }
-        byId.set(f.id, f);
-    }
-
-    const siblingsByParent = new Map();
-    for (const f of folders) {
-        const parentId = f.parentFolderId || "";
-        if (parentId && !byId.has(parentId)) {
-            throw new Error(
-                `Folder ${f.id} (${f.name}) references unknown parentFolderId ${parentId}`,
-            );
-        }
-        if (!siblingsByParent.has(parentId)) {
-            siblingsByParent.set(parentId, new Set());
-        }
-        const siblings = siblingsByParent.get(parentId);
-        if (siblings.has(f.name)) {
-            throw new Error(
-                `Sibling folders share name "${f.name}" under parent ${parentId || "(root)"} — names must be unique among siblings`,
-            );
-        }
-        siblings.add(f.name);
-    }
-
-    /**
-     * The folder id a note names, by id.
-     *
-     * **Only by id.** This resolver answers for `folder:` alone; `packFolder:`
-     * names a folder *note* and is resolved through the address index instead
-     * (#255). The path lookup that briefly lived here is gone with the path
-     * spelling it served — it was never released, so there is nothing to
-     * deprecate.
-     *
-     * @param {string|null|undefined} value - As authored.
-     * @returns {string|null} The id, or `null` for an absent value.
-     * @throws {Error} When the id is not one this pack declares.
-     */
-    function resolver(value) {
-        if (value == null || value === "") return null;
-        const authored = String(value).trim();
-        if (!authored) return null;
-        if (!byId.has(authored)) {
-            throw new Error(`Unknown folder id "${authored}"`);
-        }
-        return authored;
-    }
-
-    return { resolver, folders };
-}
-
 /**
  * Builds a compendium-source filename for a folder JSON document:
  * `folder_Name_id.json` with non-alphanumeric runs replaced by
@@ -1017,28 +924,3 @@ export function buildFolderResolver(folders) {
 export function folderFilename(name, id) {
     return `folder_${unidecode(name)}_${id}`.replace(/[^0-9a-zA-Z]+/g, "_") + ".json";
 }
-
-/**
- * Writes one JSON document per folder into `destDir`. `documentType`
- * determines the folder's Foundry `type` field — `"Item"` for the items
- * pack, `"JournalEntry"` for the journals pack.
- */
-export function writeFolderDocs(folders, stats, destDir, documentType) {
-    for (const folder of folders) {
-        const doc = {
-            name: folder.name,
-            sorting: "a",
-            folder: folder.parentFolderId || null,
-            type: documentType,
-            _id: folder.id,
-            sort: 0,
-            color: folder.color,
-            flags: folder.flags || {},
-            _stats: stats,
-            _key: `!folders!${folder.id}`,
-        };
-        const outPath = path.join(destDir, folderFilename(folder.name, folder.id));
-        fs.writeFileSync(outPath, JSON.stringify(doc, null, 2), "utf8");
-    }
-    log.info(`Emitted ${folders.length} folder document(s) to ${destDir}`);
-}

package/engine/item-compiler.mjs

@@ -296,15 +296,13 @@ export class SystemItemCompiler extends BasePackCompiler {
         });
 
         const effects = blockProperty(fm, system, "effects");
-        // Read through the system block like every other item field, so both
-        // spellings work wherever a note already writes one. `packFolder` is a
-        // folder note's address and `folder` an id; which it is comes from the
-        // field, never from the string (#251, #255).
-        const packFolderAddress = blockField(fm, system, "packFolder", null);
-        const folder =
-            packFolderAddress ?
-                this.folderResolver(packFolderAddress, { isAddress: true })
-            :   this.folderResolver(blockField(fm, system, "folder", null));
+        // Read through the system block like every other item field. There is
+        // one spelling: `packFolder` names a folder note by its address, the
+        // `folder:` id spelling having been retired with the per-pack YAML it
+        // resolved against (#251, #255, #260).
+        const folder = this.folderResolver(blockField(fm, system, "packFolder", null), {
+            isAddress: true,
+        });
 
         return {
             name,

package/engine/journals.mjs

@@ -381,12 +381,8 @@ export class Journals extends BasePackCompiler {
 
         // A documentation entry is filed exactly where the document it
         // describes is, so the journals pack mirrors the items pack and a doc
-        // sits under the same heading a reader found the item under. The id is
-        // taken verbatim rather than through `folderResolver`, which validates
-        // against this pack's own folders.yaml — an item folder is declared in
-        // the items one, a macro folder in the macros one, and a map's in the
-        // scenes one.
-        const { value: authoredFolder, isAddress } = folderField(fm);
+        // sits under the same heading a reader found the item under.
+        //
         // An address is resolved wherever it is written, including here — and
         // resolving it *here* is what cures the defect this comment used to
         // describe. A folder note has one definition and one address, so the
@@ -395,12 +391,10 @@ export class Journals extends BasePackCompiler {
         // with the first, and so no arrangement to assume: the mirroring
         // failure is unrepresentable rather than merely reported.
         //
-        // `folder:` is unchanged, and still crosses packs verbatim on the
-        // assumption both declare it — the arrangement #260 retires.
-        const folder =
-            isAddress ? this.folderResolver(authoredFolder, { isAddress: true })
-            : ownsDoc ? authoredFolder
-            : this.folderResolver(authoredFolder);
+        // The id spelling used to cross packs verbatim here, on the assumption
+        // both declared it — the arrangement #260 retires with the YAML.
+        const { value: authoredFolder } = folderField(fm);
+        const folder = this.folderResolver(authoredFolder, { isAddress: true });
 
         return buildJournalEntry({
             id,

package/engine/scenes.mjs

@@ -408,8 +408,8 @@ export class Scenes extends BasePackCompiler {
         // shared `docEntryTypes` arrangement (#1514) — so neither
         // pass has to read the other's output.
         const entryId = hasBody ? itemDocEntryId(fm.id) : undefined;
-        const { value: authoredFolder, isAddress: folderIsAddress } = folderField(fm);
-        const folder = this.folderResolver(authoredFolder, { isAddress: folderIsAddress });
+        const { value: authoredFolder } = folderField(fm);
+        const folder = this.folderResolver(authoredFolder, { isAddress: true });
         // The retired spelling of the background art, reported where an author
         // meets it soonest — every consumer runs the compile, and not every
         // one runs the lint (#142). Located by reading the note back, which is
@@ -457,13 +457,11 @@ export class Scenes extends BasePackCompiler {
                     name,
                     markdown,
                     leadName: name,
-                    // As in the journals pass: an id crosses packs verbatim,
-                    // an address resolves in the pack that emits it — which is
-                    // what makes the folder materialise there too (#257).
-                    folder:
-                        folderIsAddress ?
-                            this.folderResolver(authoredFolder, { isAddress: true })
-                        :   authoredFolder,
+                    // As in the journals pass: an address resolves in the
+                    // pack that emits it, which is what makes the folder
+                    // materialise there too (#257). The id spelling that used
+                    // to cross packs verbatim is retired (#260).
+                    folder: this.folderResolver(authoredFolder, { isAddress: true }),
                     flags: fm.flags,
                 })
             :   null;