@heroiclands/package-build 3.2.0 → 3.4.0

package/CHANGELOG.md

@@ -1,5 +1,185 @@
 # @heroiclands/package-build
 
+## 3.4.0
+
+### Minor Changes
+
+- 19df269: Stop emitting `assocMysteryCode` on a compiled mystical ability (#35).
+  
+  The `mysticalability` declaration named a field no SoHL DataModel receives.
+  `MysticalAbilityDataModel` declares `subType`, `assocSkillCode`,
+  `assocAffiliationCode`, `masteryLevelBase`, `improveFlag`, `levelBase` and
+  `charges`, and nothing else — Foundry discards the extra key when the document
+  is constructed, so every mystical ability in every consuming pack shipped a
+  value that was thrown away at load, with nothing at compile or load time saying
+  so.
+  
+  This is the exact inverse of #3 and has the same root cause: nothing compares a
+  builder's emitted `system` block against the DataModel that receives it. #3 was a
+  declared field the builder failed to emit; this is an emitted field the DataModel
+  never declares. Both compile clean, both lose data silently, and an author cannot
+  tell either from a correct build. The general check is #60.
+  
+  **The field was retired, not renamed.**
+  Song-of-Heroic-Lands-FoundryVTT#973 deleted `assocMysteryCode` because nothing in
+  production read the mystery it resolved to; #1012 later added
+  `assocAffiliationCode` as a separate concept — the faction whose standing confers
+  the ability. They look alike and mean different things, so the declaration is
+  dropped rather than retargeted.
+  
+  **This changes emitted documents**, so a consumer wants a rebuild rather than a
+  silent upgrade — though nothing downstream can have depended on the value:
+  
+  - `sohl` — nine notes authored the key, all of them blank. Corrected in
+    Song-of-Heroic-Lands-FoundryVTT#1747.
+  - `sohl-kethira-basic` — no note authors it; all 224 mystical abilities carried
+    the builder's own `""`. Recompiling `main` with this change removes exactly
+    those 224 lines and touches nothing else.
+- dced8b2: Write the derived package into an emitted page's frontmatter (#65).
+  
+  `content-build site` copied a note's frontmatter to the page verbatim. Since
+  3.3.0 a note need not declare `package:` — it is derived from the configured
+  `contentPackage` — and `engine/site-build.mjs` resolved that value one line
+  before it built the page, carrying it for the index, the table universe and the
+  local-package set. It never reached the page's own frontmatter, so a swept tree
+  published pages that said nothing about which package they belong to.
+  
+  **The visible symptom is the breadcrumb.**
+  `@heroiclands/hugo-theme`'s `layouts/partials/breadcrumbs.html` reads
+  `{{ $pkg := .Params.package | default "" }}` and builds the middle crumb from
+  it. With no `package` the section is never resolved and the crumb degrades from
+  a linked, labelled section to a bare, unlinked type slug:
+  
+  ```text
+  before: Home > SoHL Affliction > Aconite   (linked)
+  after:  Home > affliction       > Aconite   (bare)
+  ```
+  
+  Consumer layouts reading the field directly degrade the same way — a `package`
+  column renders blank.
+  
+  The fix is where the value was already known: `pageFrontmatter` spreads
+  `package` after the note's own frontmatter, so a note that declares the field
+  keeps its authored position and value and an unswept tree emits byte-identically,
+  while a swept one regains the line it lost. The alternative — teaching every
+  theme and consumer layout to default the package from a site parameter — pushes
+  a fact the build already knows out to N consumers, and the theme deliberately
+  carries no addresses.
+  
+  **This changes emitted output**, so a consumer wants a rebuild rather than a
+  silent upgrade, which is why it is a minor rather than a patch — the same
+  reasoning as #35. Verified against the swept `sohl` tree: 1,606 emitted content
+  pages differ, none added or removed, and the only diff line class across the
+  whole tree is the restored `package: sohl`. Rendering that tree, 1,600 pages
+  differ and in exactly two ways — the breadcrumb's middle crumb, and a `package`
+  column that was blank.
+  
+  `sohl-thalorna` has the same defect independently, in its own
+  `utils/build-site-content.mjs`, and is fixed in that repository
+  (sohl-thalorna#79) — two emitters, one behaviour, which is a second argument
+  for #36.
+
+## 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 {