@heroiclands/package-build 3.2.0 → 3.3.0

package/CHANGELOG.md

@@ -1,5 +1,106 @@
 # @heroiclands/package-build
 
+## 3.3.0
+
+### Minor Changes
+
+- 1f6eb85: Compile an unopened skill's opening mastery level into the actor pack.
+  
+  A skill embedded on a being carries `masteryLevelBase: null` when neither the
+  catalogue entry nor the note states one — `null` meaning _not yet opened_. The
+  client filled that in on import, at Skill Base × `initSkillMult`
+  (`SkillLogic.initialize`), so a compiled being said nothing about what its
+  skills open at. It materialised on import instead of being visible in the
+  document, reviewable in a diff, or testable without standing up Foundry.
+  
+  The actors pass now computes it. `openUnopenedSkills` runs at the end of
+  `buildEmbeddedItems`, after the note's frontmatter has been merged onto the
+  catalogue skill and after the attribute items exist — the Skill Base formula
+  reads the actor's attributes, so it cannot run any earlier. Only nulls are
+  filled; a skill that states a `masteryLevelBase` keeps it.
+  
+  Evaluating `skillBaseFormula` needs an expression evaluator, which this package
+  had none of. `sohl/skill-base.mjs` reproduces the part of SoHL's
+  `SafeExpression` that a Skill Base uses: numeric literals, `attr.<code>` reads
+  defaulting to `0`, arithmetic, and a small helper set including `sb()` — whose
+  rounding (a pair averages up only when the primary is the greater) and whose
+  `Math.max(0, n)` clamp are copied from SoHL deliberately and must not drift. A
+  formula outside that subset is reported, never guessed at.
+  
+  Two build-side rules the client does not need, neither of which changes what a
+  client computes:
+  
+  - A zero or absent `initSkillMult` leaves `masteryLevelBase` null. The
+    multiplier is the switch for whether a skill opens at all, so writing the `0`
+    the arithmetic yields would claim the skill opened at zero rather than that it
+    never opened.
+  - A fractional product is an error, not a rounding. `masteryLevelBase` is an
+    integer field, so there is no honest value to write — the same stance
+    `resolveSkillAptitudes` takes on a fractional modifier.
+  
+  The scores used are the `scoreBase` values the pass just wrote, where the client
+  resolves `attr.<code>` to an attribute's _effective_ score. They agree for a
+  being carrying no attribute-altering effects, which is every being in content
+  today; one that did carry such an effect would bake a Skill Base its client then
+  disagrees with.
+  
+  Closes #46.
+- e37d201: A note's package is the repository's `contentPackage`, and `package:` is
+  optional.
+  
+  A note was compiled when its `package:` frontmatter matched the configured
+  `contentPackage`, and skipped when it did not — silently, and tallied as
+  `skippedOther`, the same bucket as the thousands of notes that legitimately
+  belong to another pass. So a tree whose notes named a package no configuration
+  answered to compiled **zero notes and exited 0**, which is the state the
+  un-migrated `hm-loc-*` / `hm-adv-*` repositories are in today.
+  
+  Every content tree is single-package — each is single-sourced in the repository
+  that ships it — so the field restated one constant about 6,200 times across the
+  org. This is the first of three steps that retire it, and the only one that
+  changes any code here:
+  
+  1. **Optional**, now. An absent `package:` is normal and the note compiles; a
+     present one is accepted while it agrees with `contentPackage`, and is a
+     **loud error naming the file** when it does not. Nothing a consumer authors
+     has to change, which is what makes the sweep safe to land next.
+  2. **Swept** out of every content tree, on this version.
+  3. **Rejected** outright — a later major, once the sweeps have merged.
+  
+  **What changed**
+  
+  - `engine/note-package.mjs` is the new seam: `notePackage` derives the package
+    a note belongs to, `assertNotePackage` refuses one that names another, and
+    `searchableFrontmatter` presents a note to a generated table with its package
+    present however the note spells it.
+  - The compile loop no longer filters on the field. A note declaring another
+    package is reported through the ordinary diagnostic channel
+    (`file:line:column: error: …`), counted in `errorCount` so the build fails,
+    and tallied as its own `PassStats.declined` — never folded into
+    `skippedOther`, which is what made the original defect invisible.
+  - The link manifest throws rather than skipping such a note: skipping it
+    quietly is how a manifest came to claim a package publishes nothing.
+  - **No key is derived from frontmatter any more.** The link index
+    (`content-links`), the site index (`site-index`) and the site build's
+    package grouping all take the derived value; the manifest emitter already
+    took it from configuration. A note addresses identically whether or not it
+    declares the field.
+  - A generated table that scopes itself with `WHERE … and package = "<pkg>"` —
+    the shape every collection note uses — keeps matching after the field is
+    deleted, so a sweep is a mechanical deletion rather than a silent
+    emptying of every table.
+  
+  **`contentPackage` is not becoming dead configuration.** Its selecting job is
+  what is going; the value is the **address namespace** — the first segment of
+  every canonical key, the name of the link manifest a build emits, and the
+  package a cross-package wikilink writes. Its documentation now says so.
+  
+  Verified against the real `Song-of-Heroic-Lands-FoundryVTT` tree (1,606 notes):
+  `build/packs-json` is byte-identical to `main`'s output both with the field
+  present on every note and with it deleted from every note.
+  
+  Step 1 of #56. Steps 2 (the sweep) and 3 (rejection, a major) follow.
+
 ## 3.2.0
 
 ### Minor Changes

package/CONTENT.md

@@ -21,7 +21,9 @@ npm install -D @heroiclands/package-build
 A consuming repository declares one `package-build.config.yaml` at its root:
 
 ```yaml
-# The value each content note carries in its `package:` frontmatter.
+# The package this repository's content is published as: the first segment of
+# every canonical address, the name of the link manifest it emits, and the
+# package a cross-package wikilink writes to reach one of its notes.
 contentPackage: thalorna
 # Where Foundry installs it: "systems" or "modules". Also decides the served
 # asset root a note's `img:` resolves to — `modules/sohl-thalorna/assets/…`.
@@ -173,6 +175,31 @@ never existed. A module declaring no usable system relationship fails the build
 rather than guessing — a wrong `_stats.systemVersion` is invisible until
 something migrates on it.
 
+### A note's package is the repository's, not the note's
+
+`contentPackage` is the **address namespace** every note in the tree is
+published under. It is not a filter, and a note does not restate it.
+
+A note may still carry `package:` — every note written before this did — and it
+is accepted while it **agrees** with `contentPackage`. One that disagrees is an
+error naming the file, in the compile, in the link manifest, and anywhere else
+a note is read. The field is redundant, and it is being retired in three steps:
+optional now, swept out of every content tree on this version, and rejected
+outright in a later major.
+
+A generated table that scopes itself with `WHERE … and package = "<pkg>"` keeps
+working either way: a note's package is supplied to the table search whether or
+not the note declares it, so deleting the field never turns a table into an
+empty one.
+
+It used to **select**: a note compiled when its `package:` matched and was
+skipped when it did not. Every content tree is single-package — each is
+single-sourced in the repository that ships it — so the field restated one
+constant thousands of times, while a tree whose notes named a package no
+configuration answered to compiled **zero notes and exited 0**. Deleting the
+field from a note is safe on this version and is the fix; deleting the
+_configured_ value is not, since every address derives from it.
+
 ### A registry of your own
 
 `itemBuilders` is the one part of the contract that is code — a table of
@@ -240,7 +267,6 @@ packs:
 name:
   full: Climbing
 type: skill
-package: kethira
 id: ...
 ---
 # A note that names one lands there instead.
@@ -248,7 +274,6 @@ id: ...
 name:
   full: Second Sight
 type: skill
-package: kethira
 id: ...
 pack: mysteries
 ---
@@ -543,7 +568,7 @@ It reads its whole input from configuration and takes nothing else:
 
 | Setting                     | What it decides                                               |
 | --------------------------- | ------------------------------------------------------------- |
-| `contentPackage`            | The package emitted, and which notes belong to it.            |
+| `contentPackage`            | The package emitted, which every note belongs to.             |
 | `foundryPackage`            | The package every emitted `uuid` names.                       |
 | `paths.content`             | The tree walked.                                              |
 | `paths.manifestOut`         | Where the file lands (`build/manifests` by default).          |

package/content-config.mjs

@@ -414,9 +414,9 @@ export const DEFAULT_ADDRESS_SCHEME = Object.freeze({
  *                                          repository — every configured path is
  *                                          resolved against it, so the build never
  *                                          depends on the working directory.
- * @property {string} contentPackage        Content package name — the value each
- *                                          content note carries in its `package:`
- *                                          frontmatter.
+ * @property {string} contentPackage        Content package name — the address
+ *                                          namespace every note in this
+ *                                          repository is published under.
  * @property {string} foundryPackage        Foundry package id, as it appears in
  *                                          `system.json` / `module.json`.
  * @property {PackageKind} packageKind      Whether the package is a system or a module.

package/engine/base-compiler.mjs

@@ -74,16 +74,25 @@ import {
 } from "./helpers.mjs";
 import { emitDiagnostic } from "./diagnostics.mjs";
 import { contentPackage } from "./content-package.mjs";
+import { assertNotePackage } from "./note-package.mjs";
 import { assertTypeNotRetired, packForType } from "./ids.mjs";
 
 /**
  * The tallies one pass accumulates while walking the tree.
  *
+ * `declined` and `skippedOther` are deliberately separate numbers. A declined
+ * note is one this build **refused** — it names a package this repository does
+ * not compile — and it is an error; a skipped one legitimately belongs to
+ * another pass, and there are thousands of those. Folding the first into the
+ * second is what let a whole tree be filtered out in silence (#56).
+ *
  * @typedef {object} PassStats
  * @property {number} compiled - Notes that became a document.
  * @property {number} skippedDraft - Notes marked `draft: true`.
  * @property {number} skippedNoId - Notes with no `id`, where that is tolerated.
  * @property {number} skippedOther - Notes this pass does not claim.
+ * @property {number} declined - Notes refused because they declare another
+ *   package. Counted as errors, never as skips.
  */
 
 /**
@@ -250,8 +259,9 @@ export class BasePackCompiler {
     /**
      * Whether this pass claims a note. **Required.**
      *
-     * Called only for a note of the configured content package, so a subclass
-     * decides on `type` alone.
+     * Called only for a note this build compiles — every note in the tree
+     * belongs to the configured content package (#56) — so a subclass decides
+     * on `type` alone.
      *
      * @param {object} fm - The note's frontmatter.
      * @returns {boolean} True to compile it.
@@ -326,7 +336,9 @@ export class BasePackCompiler {
         const { markdown: tabulated, lineMap } = expandNoteTables(body, {
             docs: this.contentDocs,
             name,
-            pkg: fm.package,
+            // The repository's package, not the note's: every note in the tree
+            // is this package's note, whether or not it says so (#56).
+            pkg: contentPackage(),
             fm,
             bodyLine,
         });
@@ -503,6 +515,14 @@ export class BasePackCompiler {
         if (stats.skippedDraft) {
             log.info(`Skipped ${stats.skippedDraft} draft(s)`);
         }
+        if (stats.declined) {
+            // Its own line, at error level: these are not skips, and burying
+            // them in the skipped tally is the defect (#56). Each one has
+            // already been named individually as a diagnostic.
+            log.error(
+                `Declined ${stats.declined} note(s) declaring another package`,
+            );
+        }
         this.reportDetail(stats);
     }
 
@@ -518,6 +538,7 @@ export class BasePackCompiler {
             skippedDraft: 0,
             skippedNoId: 0,
             skippedOther: 0,
+            declined: 0,
         };
         await this.prepare();
 
@@ -534,10 +555,25 @@ export class BasePackCompiler {
             // Which note this pass is on, so anything it calls can report a
             // position without every method having to be handed one (#17).
             this.currentNote = { absPath, bodyLine, bodyColumn };
-            if (!fm || fm.package !== contentPackage()) {
+            // A file carrying no frontmatter at all is not a note.
+            if (!fm) {
                 stats.skippedOther++;
                 continue;
             }
+            // The package a note belongs to is this repository's configured
+            // one; `package:` is optional and merely has to agree (#56). A
+            // disagreement is reported and counted as an error — never skipped,
+            // which is how a tree naming a package nothing answers to used to
+            // compile zero notes and exit 0. The file comes from the diagnostic
+            // locator, so the message must not repeat it.
+            try {
+                assertNotePackage(fm);
+            } catch (err) {
+                stats.declined++;
+                this.errorCount++;
+                this.noteError(err.message);
+                continue;
+            }
             // Checked before `selects`, and therefore for every note this
             // package owns rather than only the ones some pass claims. A
             // retired type is claimed by no pass, so the alternative is not a

package/engine/content-links.mjs

@@ -52,6 +52,7 @@ import { matchAllOutsideCode } from "./code-fences.mjs";
 import { expandContentTables } from "./content-tables.mjs";
 import { walkMarkdownTree } from "./helpers.mjs";
 import { hasDocEntry } from "./item-docs.mjs";
+import { notePackage, searchableFrontmatter } from "./note-package.mjs";
 import {
     canonicalKey,
     loadForeignManifests,
@@ -131,21 +132,18 @@ export function buildLinkIndex(
 
     for (const note of notes) {
         const { fm, type } = note;
+        // Derived, never read out of frontmatter: `package:` is optional, and a
+        // note that declares nothing addresses exactly as one that declares the
+        // configured package (#56).
+        const pkg = notePackage(fm);
         if (typeof fm.shortcode === "string" && fm.shortcode) {
             byKey.set(`${type}/${fm.shortcode}`.toLowerCase(), note);
             // The canonical, fully qualified address alongside the short one,
             // so a package-qualified link checks the same way a bare one does.
-            if (fm.package) {
-                byKey.set(canonicalKey(fm.package, type, fm.shortcode), note);
-            }
+            byKey.set(canonicalKey(pkg, type, fm.shortcode), note);
             if (hasDocEntry(type)) {
                 byKey.set(`doc${type}/${fm.shortcode}`.toLowerCase(), note);
-                if (fm.package) {
-                    byKey.set(
-                        canonicalKey(fm.package, `doc${type}`, fm.shortcode),
-                        note,
-                    );
-                }
+                byKey.set(canonicalKey(pkg, `doc${type}`, fm.shortcode), note);
             }
         }
         const aliases = [
@@ -172,9 +170,7 @@ export function buildLinkIndex(
     // A foreign package may use a type this tree has never seen, so its types
     // join `types` — otherwise `readQualifier` reads the link as prose and it
     // is never checked at all.
-    const localPackages = new Set(
-        notes.map((n) => n.fm?.package).filter(Boolean),
-    );
+    const localPackages = new Set(notes.map((n) => notePackage(n.fm)));
     const foreign =
         manifestDir ?
             loadForeignManifests(manifestDir, localPackages)
@@ -182,13 +178,15 @@ export function buildLinkIndex(
     for (const v of foreign.index.values()) if (v.type) types.add(v.type);
 
     const packages = new Set([
-        ...[...byKey.values()].map((n) => n.fm?.package).filter(Boolean),
+        ...[...byKey.values()].map((n) => notePackage(n.fm)),
         ...foreign.packages,
     ]);
 
     /** The searchable universe a `dataview` table draws its rows from. */
     const tableDocs = notes.map((n) => ({
-        fm: n.fm,
+        // Package present however the note spells it — see
+        // {@link searchableFrontmatter} (#56).
+        fm: searchableFrontmatter(n.fm),
         path: n.rel,
         tld: n.rel.split("/")[0],
         folder: path.dirname(n.rel).split("/").pop(),
@@ -207,7 +205,9 @@ export function buildLinkIndex(
         let body = note.body;
         if (/^[ \t]*(?:`{3,}|~{3,})[ \t]*dataview\b/im.test(body)) {
             body = expandContentTables(body, {
-                docs: tableDocs.filter((d) => d.fm.package === note.fm.package),
+                docs: tableDocs.filter(
+                    (d) => notePackage(d.fm) === notePackage(note.fm),
+                ),
                 linkable: (d) => Boolean(d.fm.shortcode),
                 source: note.file,
             }).markdown;

package/engine/content-package.mjs

@@ -25,12 +25,25 @@
 import { loadPackConfig } from "./pack-config.mjs";
 
 /**
- * The **content** package: the distribution unit a note declares in its
- * `package:` frontmatter. The pack compilers select their entries by it.
+ * The **content** package: the distribution unit this repository's notes belong
+ * to, and the **address namespace** every one of them is published under.
+ *
+ * It is the first segment of every canonical key (`sohl-skill-clmb`), the name
+ * of the link manifest this build emits (`sohl.json`), and the package a
+ * cross-package wikilink writes to reach one of these notes. So it is the
+ * repository's identity in the address space, not a switch — and never dead
+ * configuration, whatever else changes.
+ *
+ * It was also, until #56, a **selector**: a note declared the same value in its
+ * `package:` frontmatter and the compilers kept the ones that matched. Every
+ * content tree is single-package — each is single-sourced in the repository that
+ * ships it — so the field restated this constant once per note while a value
+ * that matched nothing filtered the whole tree out in silence. The field is
+ * being retired; the value stays, here, where it is declared once.
  *
  * Stable across compilation targets. If this content were ever compiled for a
- * second game system, its notes would still declare `package: sohl` — only the
- * Foundry package below would differ.
+ * second game system, it would still be published as `sohl` — only the Foundry
+ * package below would differ.
  *
  * An accessor rather than a hoisted constant, so that importing this module
  * needs no configuration (#2).
@@ -47,7 +60,7 @@ export function contentPackage() {
  * compendium UUID the compilers emit.
  *
  * Distinct from {@link contentPackage}, and equal to it only by coincidence
- * here: a note says `package: sohl` and its documents are addressed as
+ * here: a note is published under `sohl` and its documents are addressed as
  * `Compendium.sohl.<pack>.<Type>.<id>`. In `sohl-thalorna` the two differ
  * (`thalorna` vs `sohl-thalorna`), which is why they are separate values rather
  * than one — treating them as interchangeable is what #1498 was.

package/engine/field-reference.mjs

@@ -146,7 +146,9 @@ function workedExample(type, fields) {
         `  full: An Example ${type}`,
         `type: ${type}`,
         "shortcode: xmpl",
-        "package: <your content package>",
+        // No `package:`. A note's package is the repository's configured
+        // `contentPackage`, so the field is redundant and is being retired
+        // (#56) — and this example is the smallest note that compiles.
         "id: <16-character id>",
         "sohl:",
         "  archetype: null",

package/engine/generate.mjs

@@ -21,9 +21,9 @@
  * into the shipped LevelDB packs) — it is never committed.
  *
  * Each `*` compiler walks the whole content tree and selects its own entries by
- * frontmatter (a `package:` matching the configured `contentPackage` + `type`),
- * so routing is directory-agnostic: a file lands in a pack because of its
- * `type`, not its location. Which packs exist, in what order, and which folder
+ * the note's `type` — every note in the tree belongs to this repository's
+ * `contentPackage` (#56) — so routing is directory-agnostic: a file lands in a
+ * pack because of its `type`, not its location. Which packs exist, in what order, and which folder
  * hierarchy each one loads are all declared in `package-build.config.yaml`;
  * folder files live under the content root and are referenced from entry
  * frontmatter via `sohl.folder: <id>`.
@@ -196,9 +196,9 @@ async function generatePack(
  * The passes that compiled nothing when they were expected to compile
  * something — a build failure, not a quiet no-op.
  *
- * A pack compiler selects its entries by the configured content package, so a
- * single wrong package id rejects every note in a perfectly good tree and every
- * pack ships blank while the build exits 0 (#1502). The empty-tree guard in
+ * A pack ships blank whenever every note in a full tree was rejected — by a
+ * `selects` that claims nothing, or a `pack:` that routes everything elsewhere
+ * — and the build then exits 0 (#1502). The empty-tree guard in
  * {@link generatePacksJson} cannot see that: the tree is full, it is the
  * *output* that is empty.
  *
@@ -212,10 +212,10 @@ export function emptyPassErrors(passes) {
         .map(
             (pass) =>
                 `Pack "${pass.name}" compiled 0 entries from a non-empty ` +
-                `content tree. Every note was rejected — check that the notes ` +
-                `declare the package this build compiles (\`contentPackage\` in ` +
-                `package-build.config.yaml), or declare the pack ` +
-                `\`mayBeEmpty\` if it genuinely ships nothing.`,
+                `content tree. Every note was rejected — check that the tree ` +
+                `holds notes of the type this pack claims, and that their ` +
+                `\`pack:\` routes here, or declare the pack \`mayBeEmpty\` if it ` +
+                `genuinely ships nothing.`,
         );
 }
 

package/engine/helpers.mjs

@@ -36,6 +36,7 @@ import log from "loglevel";
 import { loadPackConfig } from "./pack-config.mjs";
 import { packRouter } from "./pack-router.mjs";
 import { contentPackage, foundryPackageId } from "./content-package.mjs";
+import { notePackage, searchableFrontmatter } from "./note-package.mjs";
 import { loadForeignManifests, PACKAGE_BASE } from "./kb-manifest.mjs";
 import { buildWikilinkIndex, convertWikilinks } from "./wikilinks.mjs";
 import { expandContentTables } from "./content-tables.mjs";
@@ -601,7 +602,9 @@ export function collectContentDocs(contentBase) {
         if (!fm) continue;
         const segments = path.relative(contentBase, absPath).split(path.sep);
         docs.push({
-            fm,
+            // With its package present whether the note declares one or not, so
+            // a `WHERE … package = "…"` query reads the same either way (#56).
+            fm: searchableFrontmatter(fm),
             // POSIX-separated and relative to the content root — what a
             // `path:` search term globs, on every platform.
             path: segments.join("/"),
@@ -633,14 +636,17 @@ const packLinkable = (doc) =>
  * Expand the fenced `dataview` tables in one note's markdown, before wikilinks
  * are resolved — so a generated cell may itself be a wikilink.
  *
- * A table searches only notes of the source note's own `package`, so a SoHL
- * page never tabulates setting-package content (and vice versa).
+ * A table searches only notes of the source note's own package, so a SoHL page
+ * never tabulates setting-package content (and vice versa). Each candidate's
+ * package is **derived** rather than read out of its frontmatter: `package:` is
+ * optional, and comparing a declared value with an absent one would drop every
+ * unswept — or every swept — note from the table (#56).
  *
  * @param {string} body - The note's markdown body.
  * @param {object} ctx
  * @param {Array<object>} ctx.docs - From {@link collectContentDocs}.
  * @param {string} ctx.name - The note, for the error message.
- * @param {string} [ctx.pkg] - The source note's `package`.
+ * @param {string} [ctx.pkg] - The source note's package.
  * @param {object} [ctx.fm] - The source note's frontmatter, which is what a
  *   query's `this` reads. Its entry in `docs` supplies the path as well.
  * @param {number} [ctx.bodyLine] - 1-based file line of the body's first line,
@@ -654,10 +660,12 @@ const packLinkable = (doc) =>
  *   `position`, the directive's own line.
  */
 export function expandNoteTables(body, { docs, name, pkg, fm, bodyLine }) {
-    const scoped = pkg ? docs.filter((d) => d.fm?.package === pkg) : docs;
+    const scoped = pkg ? docs.filter((d) => notePackage(d.fm) === pkg) : docs;
     const self =
         fm ?
-            (docs.find((d) => d.fm?.id && d.fm.id === fm.id) ?? { fm })
+            (docs.find((d) => d.fm?.id && d.fm.id === fm.id) ?? {
+                fm: searchableFrontmatter(fm),
+            })
         :   undefined;
     const { markdown, errors, lineMap } = expandContentTables(body ?? "", {
         docs: scoped,

package/engine/index.mjs

@@ -54,6 +54,9 @@ export * as packRouter from "./pack-router.mjs";
 /** The content package a build compiles, and the Foundry package it ships in. */
 export * as contentPackage from "./content-package.mjs";
 
+/** Which content package a note belongs to, and refusing one that disagrees. */
+export * as notePackage from "./note-package.mjs";
+
 /** The shipped Foundry manifest: locating it, reading it, guarding its id. */
 
 /** The URL a content note is published at — the one web-address rule. */

package/engine/journals.mjs

@@ -16,7 +16,7 @@
  * Foundry compendium from markdown notes in the `assets/content/` tree.
  *
  * The content root (`contentBase`) is walked recursively; any `.md` file
- * whose frontmatter declares `package: sohl` and either `type: doc` or a
+ * whose frontmatter declares either `type: doc` or a
  * **doc-carrying type** ({@link sohl.utils.packs.docEntryTypes} — every item
  * type, plus `macro`) is compiled into one JournalEntry document. Each note's
  * body is split on top-level H1 headings; the optional content before the
@@ -54,7 +54,6 @@ import {
     md,
 } from "./helpers.mjs";
 import { BasePackCompiler } from "./base-compiler.mjs";
-import { contentPackage } from "./content-package.mjs";
 import { anchorPageId } from "./wikilinks.mjs";
 import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
 
@@ -367,8 +366,7 @@ export class Journals extends BasePackCompiler {
     /** @inheritdoc */
     reportDetail(stats) {
         log.debug(
-            `Skipped ${stats.skippedOther} non-doc file(s) ` +
-                `(not type:doc package:${contentPackage()})`,
+            `Skipped ${stats.skippedOther} non-doc file(s) (not type:doc)`,
         );
     }
 }

package/engine/macros.mjs

@@ -286,8 +286,8 @@ export function buildMacroEntry(
 /**
  * Macros pack compiler.
  *
- * Walks the content tree and compiles every `package: sohl`, `type: macro`
- * note into one Macro document. The same note's documentation is compiled by
+ * Walks the content tree and compiles every `type: macro` note into one Macro
+ * document. The same note's documentation is compiled by
  * the journals pass; neither pass reads the other's output.
  */
 export class Macros extends BasePackCompiler {

package/engine/manifest-emit.mjs

@@ -54,6 +54,7 @@ import { canonicalKey, writeManifests } from "./kb-manifest.mjs";
 import { walkMarkdownTree } from "./helpers.mjs";
 import { compendiumUuid, packForType, pageUuid } from "./ids.mjs";
 import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
+import { assertNotePackage } from "./note-package.mjs";
 import { journalPageId, splitPages } from "./journals.mjs";
 import { routerFor } from "./pack-router.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
@@ -194,9 +195,12 @@ export function entriesForNote(fm, name, address, body, ctx) {
  *
  * Drafts are excluded because the site does not publish them, and an entry for
  * an unpublished page is exactly the dead link the manifest exists to prevent.
- * A note belonging to another content package is skipped for the same reason in
- * reverse: this build is not authoritative for it, and its own build says where
- * it lives.
+ *
+ * Every note in the tree is this package's note, whether or not it says so:
+ * `package:` is optional and merely has to agree (#56). A note naming a
+ * different package **throws** rather than being skipped — this build is not
+ * authoritative for it, and skipping it silently is how a whole tree came to be
+ * filtered out of a manifest that then claimed the package published nothing.
  *
  * A note that has no address is **reported, not guessed** — the finding carries
  * the file and the reason, so a caller can print it or fail on it. Inventing an
@@ -220,11 +224,12 @@ export function collectManifestEntries(contentBase, ctx) {
         contentBase,
         { skipDirectories: ctx.skipDirectories },
     )) {
-        if (!fm || fm.package !== ctx.contentPackage) continue;
+        if (!fm) continue;
+        const rel = path.relative(contentBase, absPath);
+        assertNotePackage(fm, { file: rel, configured: ctx.contentPackage });
         if (fm.draft === true) continue;
         if (!fm.type || !fm.shortcode) continue;
 
-        const rel = path.relative(contentBase, absPath);
         const base = path.basename(absPath);
         const name = fm.name?.full ?? path.basename(absPath, ".md");