@heroiclands/package-build 17.1.0 → 18.0.0

package/types/engine/note-claims.d.mts

@@ -7,7 +7,10 @@
  * pack from appearing to answer for any note.
  *
  * @param {string} docType - The Foundry document type a pack holds.
- * @param {ClaimSources} [sources] - What to answer from. Defaults to the
+ * @param {ClaimSources} [sources] - What to answer from.
+ * @param {object} [opts] - Options.
+ * @param {readonly object[]} [opts.records] - The corpus, derived once by the
+ *   compile and handed in — required, for the reason above (#243). Defaults to the
  *   configured registries and the systems this toolchain ships.
  * @returns {ReadonlySet<string>} The note types such a pass would claim.
  */
@@ -19,9 +22,21 @@ export function noteTypesClaimedBy(docType: string, sources?: ClaimSources): Rea
  * is claimed — which is what keeps a type deliberately unmapped for one system,
  * and claimed for another, silent (#79).
  *
+ * **A prebuilt pack claims nothing.** Its per-document JSON is checked in
+ * rather than compiled, so it has no pass and no note is routed into one —
+ * which `content-config.mjs` already states by refusing `default: true`
+ * alongside `prebuilt`. Counting it would tell an author their note is claimed
+ * by a pack that will never look at it. Before #259 the point could not arise:
+ * the only prebuilt pack in the wild is `harn-adventures`'s Adventure pack, and
+ * no compiler was registered for that document type, so the row answered for
+ * nothing whatever it was asked. Now one is.
+ *
  * @param {object} [config] - The resolved build configuration. Defaults to this
  *   repository's.
  * @param {ClaimSources} [sources] - What to answer from.
+ * @param {object} [opts] - Options.
+ * @param {readonly object[]} [opts.records] - The corpus, derived once by the
+ *   compile and handed in — required, for the reason above (#243).
  * @returns {ReadonlySet<string>} The claimed note types.
  */
 export function claimedNoteTypes(config?: object, sources?: ClaimSources): ReadonlySet<string>;
@@ -35,6 +50,9 @@ export function claimedNoteTypes(config?: object, sources?: ClaimSources): Reado
  * declare on top.
  *
  * @param {ClaimSources} [sources] - What to answer from.
+ * @param {object} [opts] - Options.
+ * @param {readonly object[]} [opts.records] - The corpus, derived once by the
+ *   compile and handed in — required, for the reason above (#243).
  * @returns {ReadonlySet<string>} The vocabulary.
  */
 export function noteTypeVocabulary(sources?: ClaimSources): ReadonlySet<string>;
@@ -51,10 +69,15 @@ export function noteTypeVocabulary(sources?: ClaimSources): ReadonlySet<string>;
  * @param {object} [config] - The resolved build configuration. Defaults to this
  *   repository's.
  * @param {ClaimSources} [sources] - What to answer from.
+ * @param {object} [opts] - Options.
+ * @param {readonly object[]} [opts.records] - The corpus, derived once by the
+ *   compile and handed in — required, for the reason above (#243).
  * @returns {Array<{file: string, line?: number, column?: number,
  *   severity: "error", message: string, type: string}>} One finding per note.
  */
-export function unclaimedNoteFindings(config?: object, sources?: ClaimSources): Array<{
+export function unclaimedNoteFindings(config?: object, sources?: ClaimSources, { records }?: {
+    records?: readonly object[] | undefined;
+}): Array<{
     file: string;
     line?: number;
     column?: number;
@@ -74,19 +97,42 @@ export function unclaimedNoteFindings(config?: object, sources?: ClaimSources):
  */
 export const NEVER_PACKED_TYPES: ReadonlySet<string>;
 /**
- * The note-type → document-subtype maps this toolchain ships.
+ * Content types the specification states and this toolchain does not yet
+ * compile.
+ *
+ * **Stated, never inferred, and that distinction is the whole point.** An
+ * unimplemented type and a type somebody forgot to route look identical from
+ * the outside: both are documented, both validate, and neither reaches a pass.
+ * The only thing separating them is intent, so intent is written down here.
  *
- * One today. `hm3/` is #139, and when it lands its map joins this list rather
- * than the claim table below growing a second copy of the same fact.
+ * Inferring it — "declared, but absent from the configured vocabulary" — reads
+ * correctly and is worthless, because the configured vocabulary is *derived
+ * from the routing*. Take a type's route away and it leaves the vocabulary too,
+ * so the inference excuses precisely the mistake it was meant to catch. That is
+ * not hypothetical: it is #241, where `place`, `lore` and `scenario` were
+ * declared, validated and unrouted, and every gate reported success until a
+ * downstream repository failed on 450 notes.
  *
- * `engine/` importing from `sohl/` is the arrangement `generate.mjs` already
- * has — its `COMPILERS` table names the SoHL compilers by class — and for the
- * same reason: the engine owns the *mechanism* that asks each system what it
- * compiles, and the systems own the answers.
+ * A type leaves this set when it is implemented, the way `bundle` did in #259.
+ * The membership is asserted, so it cannot be forgotten in either direction.
  *
- * @type {readonly import("./document-subtypes.mjs").DocumentSubtypeMap[]}
+ * @type {ReadonlySet<string>}
+ */
+export const UNIMPLEMENTED_TYPES: ReadonlySet<string>;
+/**
+ * Note types that reach a pack by a route **other than the pack router**.
+ *
+ * A folder is the only one, and it is not unclaimed: it compiles to a real
+ * `Folder` document. What it has no answer to is *which* pack claims it, because
+ * that is not a property of the note — a folder materialises in every pack
+ * holding a document that references it, and its ancestors with it (#257). So
+ * it is exempt from the claim check for the opposite reason a homepage is:
+ * a homepage is in no pack, and a folder may be in several.
+ *
+ * @type {ReadonlySet<string>}
  */
-export const KNOWN_DOCUMENT_SUBTYPE_MAPS: readonly import("./document-subtypes.mjs").DocumentSubtypeMap[];
+export const DERIVED_PACKED_TYPES: ReadonlySet<string>;
+export { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
 /**
  * What a claim question is asked against.
  *

package/types/engine/note-ids.d.mts

@@ -0,0 +1,38 @@
+/**
+ * The document id a note compiles under: its pin, or its address.
+ *
+ * Returns `undefined` for a file with **no address** — no `type`, or no
+ * `shortcode`. Such a file is not an addressable note, so it has no document
+ * and inventing an id for one would file it under nothing. Every caller already
+ * had to handle an absent id (that is what the authored field's absence meant),
+ * so this reports the same thing rather than throwing where a walk used to
+ * skip; whether an id is *required* stays each pass's own decision
+ * (`BasePackCompiler.requiresId`).
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter.
+ * @param {object} [opts]
+ * @param {string} [opts.pkg] - The owning content package. Defaults to the
+ *   configured one, which is the only package a tree's notes belong to (#56).
+ * @param {readonly object[]} [opts.maps] - The document-subtype maps, which
+ *   decide the address's `<system>` segment.
+ * @returns {string|undefined} The document's `_id`, or `undefined` when the
+ *   note has no address to derive one from.
+ */
+export function noteDocId(fm: object | null | undefined, { pkg, maps }?: {
+    pkg?: string | undefined;
+    maps?: readonly object[] | undefined;
+}): string | undefined;
+/**
+ * Fill a note's `id` in place, so everything downstream reads one value.
+ *
+ * The corpus readers each hold their own parsed frontmatter and each ask for
+ * `fm.id` in several places; normalising the field once, where the note is
+ * read, is what makes "the id is derived" true for all of them rather than for
+ * whichever ones remembered to derive it. Idempotent, and a no-op for a note
+ * that authored an id or has no address.
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter, mutated in place.
+ * @param {object} [opts] - As {@link noteDocId}.
+ * @returns {object|null|undefined} `fm`, for chaining.
+ */
+export function resolveNoteId(fm: object | null | undefined, opts?: object): object | null | undefined;

package/types/engine/note-renames.d.mts

@@ -0,0 +1,102 @@
+/**
+ * The shortcodes a note declares it used to be published under (#278).
+ *
+ * A package's `(type, shortcode)` addresses are a published interface, and
+ * `addresses diff` reports what a build stopped publishing — telling a
+ * **rename** from a **withdrawal** by matching document ids across two
+ * releases. #270 removed the property that rested on. An id is now derived from
+ * the canonical address, which carries the shortcode, so renaming a shortcode
+ * moves the id too: both sides of the join move together, the match finds
+ * nothing, and a rename is reported as a withdrawal with no successor named.
+ *
+ * **The remaining lever needed foresight, which is the wrong thing to ask for.**
+ * An authored `id:` still wins, and pinning one does keep a document's identity
+ * across a rename — but it has to be written *before* the rename, by an author
+ * who does not yet know they will make one. An author who has just renamed a
+ * shortcode knows exactly what the old one was, and that is the only moment
+ * anyone does.
+ *
+ * So a note states it:
+ *
+ * ```yaml
+ * type: weapongear
+ * shortcode: Taburi
+ * renamedFrom: Tabri
+ * ```
+ *
+ * **A declaration is an assertion, not a match, and the diagnostic says which
+ * it had.** That distinction is the whole ethos of `address-diff.mjs`: it
+ * refuses to guess a successor from a similar-looking string, because a wrong
+ * one sends the reader to the wrong fix. An author's declaration is neither a
+ * guess nor an identity match — it is testimony from the one party that knows —
+ * so it is used, attributed, and never silently blended with an id match.
+ *
+ * **It is a list, because renames chain.** The diff is release-to-release and a
+ * shortcode may be renamed more than once between two releases; a baseline
+ * several releases back published a name two renames ago. A single value would
+ * report that as a withdrawal again, which is the bug this closes.
+ *
+ * **It is transient.** Once every baseline a build is compared against post-dates
+ * the rename, the declaration has nothing left to say and may be deleted. That
+ * is the difference from an `id:` pin, which is permanent, opaque, and a second
+ * identity for a thing that already has one (#270).
+ *
+ * **It is one key per note, at the top level, however many systems the note
+ * compiles into.** A shortcode is the note's, not a system block's: a note
+ * carrying `sohl:` and `hm3:` blocks compiles into two documents that share one
+ * shortcode, so a rename moves both and one declaration covers both.
+ *
+ * This module reads the key and says nothing about whether the values are
+ * *sound* — that a value is a well-formed shortcode, is not the note's own, and
+ * does not name an address some live note still publishes are cross-note
+ * questions, and `engine/content-lint.mjs` owns them. Composing a value into an
+ * address key is likewise not here: the diff defines that space and spells the
+ * key once, in `engine/address-diff.mjs`.
+ *
+ * @module
+ */
+/**
+ * The `renamedFrom:` entries a note authors, exactly as authored.
+ *
+ * Scalar or list, because one predecessor is the overwhelmingly common case and
+ * requiring `- ` on it would be friction with nothing behind it; both normalize
+ * here so no reader has to ask which form it got.
+ *
+ * Entries are returned **unvalidated** — a number, a nested list, a blank
+ * string all come back as they were written. The lint needs to see them to
+ * report them, and a reader that quietly dropped them would report a correct
+ * tree clean while a typo silently did nothing.
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter.
+ * @returns {readonly unknown[]} The authored entries, in authored order; empty
+ *   when the note declares none.
+ */
+export function renamedFromEntries(fm: object | null | undefined): readonly unknown[];
+/**
+ * The well-formed shortcodes among a note's `renamedFrom:` entries.
+ *
+ * Trimmed, de-duplicated, and in authored order. Anything that is not a
+ * non-blank string is skipped rather than coerced: it is reported by the lint,
+ * and a diff that guessed at what a number meant would claim a rename nobody
+ * declared.
+ *
+ * De-duplicating here rather than leaving it to callers is not tidiness — the
+ * predecessor index is a map, so a repeated entry would otherwise be indexed
+ * twice and the second write would look like a conflicting claim.
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter.
+ * @returns {string[]} The declared predecessor shortcodes.
+ */
+export function renamedFrom(fm: object | null | undefined): string[];
+/**
+ * Whether a note declares the key at all, however malformed its value.
+ *
+ * Separate from {@link renamedFrom} returning nothing, because the two mean
+ * opposite things to a lint: a note declaring no key is silent and correct,
+ * while one declaring `renamedFrom: []` — or a single blank string — has said
+ * something that does nothing, which is worth a word.
+ *
+ * @param {object|null|undefined} fm - Parsed frontmatter.
+ * @returns {boolean} `true` when the key is present and not null.
+ */
+export function declaresRenamedFrom(fm: object | null | undefined): boolean;

package/types/engine/note-vocabulary.d.mts

@@ -199,7 +199,7 @@ export const NOTE_VOCABULARY: Readonly<{
         subTypes: readonly string[];
         data: readonly DataFieldSpec[];
     }>;
-    armorgear: Readonly<{
+    armor: Readonly<{
         data: readonly DataFieldSpec[];
     }>;
     armorlocation: Readonly<{
@@ -209,7 +209,7 @@ export const NOTE_VOCABULARY: Readonly<{
     attribute: Readonly<{
         data: readonly DataFieldSpec[];
     }>;
-    concoctiongear: Readonly<{
+    concoction: Readonly<{
         subTypes: readonly string[];
         data: readonly (DataFieldSpec | Readonly<{
             describe: "How many of the thing there are; one when unstated.";
@@ -237,7 +237,7 @@ export const NOTE_VOCABULARY: Readonly<{
         subTypes: readonly string[];
         data: readonly DataFieldSpec[];
     }>;
-    projectilegear: Readonly<{
+    projectile: Readonly<{
         subTypes: readonly string[];
         data: readonly (DataFieldSpec | Readonly<{
             describe: "How many of the thing there are; one when unstated.";
@@ -264,6 +264,29 @@ export const NOTE_VOCABULARY: Readonly<{
     macro: Readonly<{
         data: readonly never[];
     }>;
+    folder: Readonly<{
+        data: readonly ({
+            describe: string;
+            shape: "a wikilink, or a map of wikilinks keyed by pack";
+            kind: "scalar-or-map";
+            entryShape: "a wikilink";
+            keys: "pack";
+            name: string;
+        } | {
+            describe: string;
+            shape: "string";
+            kind: "string";
+            name: string;
+        })[];
+    }>;
+    bundle: Readonly<{
+        data: readonly {
+            describe: string;
+            shape: "list of wikilinks";
+            kind: "list";
+            name: string;
+        }[];
+    }>;
     lore: Readonly<{
         subTypes: readonly string[];
         data: readonly never[];
@@ -349,17 +372,30 @@ export type DataFieldSpec = {
      */
     name: string;
     /**
-     * - The value's
-     * shape, for the lint. Absent means no claim is made about the value — which
-     * is the honest answer wherever the specification's stated shape and the
-     * shape notes are authored in today disagree.
+     * -
+     * The value's shape, for the lint. Absent means no claim is made about the
+     * value — which is the honest answer wherever the specification's stated
+     * shape and the shape notes are authored in today disagree.
      */
-    kind?: "string" | "number" | "boolean" | "map" | "list" | undefined;
+    kind?: "string" | "number" | "boolean" | "map" | "list" | "scalar-or-map" | undefined;
     /**
      * - Human-readable shape, for a finding and for
      * documentation.
      */
     shape?: string | undefined;
+    /**
+     * - For a `scalar-or-map` field, what one
+     * entry of the map is. A finding names the entry at fault rather than
+     * quoting the whole map back, so the string an author has to correct is the
+     * one the message holds.
+     */
+    entryShape?: string | undefined;
+    /**
+     * - For a `scalar-or-map` field, what its keys name.
+     * `"pack"` means each is a pack this package declares, so a key naming none
+     * is a finding of its own: it addresses a hierarchy nothing will ever read.
+     */
+    keys?: "pack" | undefined;
     /**
      * - One line, for the author-facing reference.
      */

package/types/engine/retired-fields.d.mts

@@ -153,6 +153,43 @@ export function assertNoSectionField(fm: object | null | undefined, { file, absP
     file?: string | undefined;
     absPath?: string | undefined;
 }): void;
+/**
+ * What a note writing a top-level `traits:` block is told.
+ *
+ * The message states the **mapping**, not just the destination, because three
+ * of the keys reshaped as well as moved: the block nested its measurements
+ * where the format flattens them. A bare "write `data:` instead" would send an
+ * author to author `data.height: {m: 1.78}`, which is a declared key holding an
+ * undeclared shape.
+ *
+ * @param {string} [file] - The note's path, named in the message. Omit it where
+ *   the caller emits through a diagnostic, whose locator already starts the
+ *   line — repeating it prints the path twice.
+ * @returns {string} The message, unpunctuated at the end as a finding is.
+ */
+export function traitsRetiredMessage(file?: string): string;
+/**
+ * Refuse a note that declares a top-level `traits:` block at all.
+ *
+ * Presence is the whole test, as it is for `draft:` and `aliases:`: an empty
+ * `traits:` is still a note claiming a block that no longer exists.
+ *
+ * @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.
+ * @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 block.
+ */
+export function assertNoTraitsField(fm: object | null | undefined, { file, absPath }?: {
+    file?: string | undefined;
+    absPath?: string | undefined;
+}): void;
 /**
  * A frontmatter key's position in a note's file, or nothing.
  *
@@ -196,6 +233,31 @@ export function locateFrontmatterKey(absPath: string | undefined, key: string, v
  * @returns {string} The message, unpunctuated at the end as a finding is.
  */
 export function retiredAliasMessage(retired: string, current: string, file?: string): string;
+/**
+ * What a note writing a field at its **legacy in-block position** is told.
+ *
+ * The same three-step retirement `retiredAliasMessage` announces, applied to a
+ * *position* rather than a spelling (#305). A field whose shared source moved
+ * under `data:` keeps reading the key its block still carries, that read wins,
+ * and it is reported here so a sweep has something to count down — without it,
+ * moving a field into `data:` would be a flag day across every repository that
+ * authors it.
+ *
+ * It names the block, because the key is `hm3.species` and not `species`: an
+ * author told to move "`species`" has two regions to guess between.
+ *
+ * @param {string} block - The system block the key was written in.
+ * @param {{name?: string, legacyKey?: string}} field - The declaration, which
+ *   names both positions.
+ * @param {string} [file] - The note's path, named in the message. Omit it where
+ *   the caller emits through a diagnostic, whose locator already starts the
+ *   line — repeating it prints the path twice.
+ * @returns {string} The message, unpunctuated at the end as a finding is.
+ */
+export function legacyKeyMessage(block: string, field: {
+    name?: string;
+    legacyKey?: string;
+}, file?: string): string;
 /**
  * Whether a note writes the retired spelling of a field, wherever it put it.
  *
@@ -236,6 +298,19 @@ export function readAliasedField(fm: object | null | undefined, current: string)
  * `image` is retired on a map — which declares `img` — and remains an unknown
  * key anywhere else.
  *
+ * **`templatePriority` (#266).** The number that decides which of several
+ * competing templates the Create dialog offers was called `archetype`, and
+ * `archetypes` — one letter apart — is a list of what *sort* a character is.
+ * A priority and a taxonomy cannot be told apart by a plural `s`, so the
+ * priority takes the name that says what it is. The specification already
+ * called it `templatePriority` on two of its three sides.
+ *
+ * **`relations` (SoHL#1781).** The field holds a *map* of standings, one per
+ * affiliation — its own description says so, and `resolveRelation` has always
+ * read it that way. `relation` named the many as one, which every author had to
+ * read past. Only `affiliation` declares the field, so the alias is reported
+ * there and the old spelling stays an ordinary unknown key everywhere else.
+ *
  * **`img` (#142).** Every note type names its artwork `img`, at the note's top
  * level, and resolves it the same way. A map alone named its background art
  * `image` and read it out of the `sohl:` block — two spellings for one idea,

package/types/engine/scenes.d.mts

@@ -14,9 +14,10 @@
  */
 export function collectKnownActionNames(repoRoot: string): Set<string>;
 export class Scenes extends BasePackCompiler {
-    constructor({ contentBase, dest, companionDests, folderResolver, repoRoot, }: {
+    constructor({ contentBase, dest, skipDirectories, companionDests, folderResolver, repoRoot, }: {
         contentBase: any;
         dest: any;
+        skipDirectories: any;
         companionDests?: {} | undefined;
         folderResolver?: (() => null) | undefined;
         repoRoot?: string | undefined;
@@ -30,7 +31,7 @@ export class Scenes extends BasePackCompiler {
      */
     adventureCount: number;
     index: Map<string, object> | undefined;
-    effectsByAddress: Map<string, object> | undefined;
+    effectsByAddress: Map<any, any> | undefined;
     knownActions: Set<string> | undefined;
     /** place key → `{name, img, scenes: [], journal: []}` */
     places: Map<any, any> | undefined;

package/types/engine/schema-check.d.mts

@@ -93,7 +93,7 @@ export function compareFields({ builders, artifact, documentType, subtypeOf, }:
  * *observed*. {@link compareFields} reads the `itemBuilders` declarations and
  * {@link checkAuthoredSystemData} reads a note's `<system>.system`; between them
  * they miss every key a compiler writes on its own initiative, which is not a
- * residue — it is `shortcode`, `actionDefs`, `notes`, `docHtml` and `archetype`.
+ * residue — it is `shortcode`, `actionDefs`, `notes`, `docHtml` and `templatePriority`.
  *
  * **The keys come from the object the compiler built, after a JSON round trip.**
  * That is exactly what the pack file receives, so a key whose value is
@@ -159,11 +159,24 @@ export function compareEmittedSystem({ system, artifact, documentType, subtype,
  * stamps no system at all, and a system that has not adopted the artifact yet
  * is simply unchecked. Neither is an error, and the caller says which it was.
  *
+ * **A build may have more than one system, and then the caller names it (#139).**
+ * `stats.systemId` is the package-wide answer, and a repository shipping content
+ * for two systems has no package-wide answer — it is deliberately `null` there,
+ * because a module feeding both `sohl` and `hm3` targets neither. Left at that,
+ * every schema check in such a build would be skipped in silence, which is the
+ * state #60 exists to remove: the five type names the two systems *share* are
+ * exactly the ones a wrong-system emission hides in. So a pass supplies the
+ * system its pack declares, and the version comes from that system's own
+ * `systems:` entry rather than from a package-wide stamp.
+ *
  * @param {object} config - The resolved build configuration.
+ * @param {string|null} [system] - The system whose schema is wanted. Defaults
+ *   to the package-wide `stats.systemId`, which is every single-system build
+ *   and the behaviour this always had.
  * @returns {{artifact: SchemaArtifact, source: string}|null} The schema and
  *   where it was read from.
  */
-export function resolveSchemaArtifact(config: object): {
+export function resolveSchemaArtifact(config: object, system?: string | null): {
     artifact: SchemaArtifact;
     source: string;
 } | null;
@@ -238,14 +251,18 @@ export function emittedUndeclaredMessage(finding: EmissionFinding): string;
  * @param {string} opts.block - The system block to read, e.g. `"sohl"`.
  * @param {string} opts.documentType - `Item`, `Actor`, …
  * @param {string} opts.subType - The document subtype the note compiles into.
+ * @param {string} [opts.system] - The system whose published schema to read,
+ *   where a build has more than one (#139). Defaults to the package-wide
+ *   `stats.systemId`.
  * @param {object} [opts.config] - The resolved build configuration.
  * @returns {{path: string, message: string}[]} One finding per undeclared path,
  *   shallowest-first.
  */
-export function checkAuthoredSystemData(fm: object, { block, documentType, subType, config }: {
+export function checkAuthoredSystemData(fm: object, { block, documentType, subType, system, config }: {
     block: string;
     documentType: string;
     subType: string;
+    system?: string | undefined;
     config?: object | undefined;
 }): {
     path: string;
@@ -275,10 +292,13 @@ export function checkAuthoredSystemData(fm: object, { block, documentType, subTy
  * @param {string} opts.type - The note's content type, for the message.
  * @param {readonly {to?: string}[]} [opts.fields] - The type's field
  *   declaration, which decides each finding's origin.
+ * @param {string} [opts.system] - The system whose published schema to read,
+ *   where a build has more than one (#139). Defaults to the package-wide
+ *   `stats.systemId`.
  * @param {object} [opts.config] - The resolved build configuration.
  * @returns {(EmissionFinding & {message: string})[]} One per undeclared path.
  */
-export function checkEmittedSystemData(system: object, { fm, block, documentType, subType, type, fields, config }: {
+export function checkEmittedSystemData(emitted: any, { fm, block, documentType, subType, type, fields, system, config, }: {
     fm: object;
     block: string;
     documentType: string;
@@ -287,6 +307,7 @@ export function checkEmittedSystemData(system: object, { fm, block, documentType
     fields?: readonly {
         to?: string;
     }[] | undefined;
+    system?: string | undefined;
     config?: object | undefined;
 }): (EmissionFinding & {
     message: string;

package/types/engine/site-build.d.mts

@@ -127,10 +127,10 @@ export function writeHomepages(outRoot: string, pages: readonly object[], config
  * @param {object[]} pages - Every page, from both walks.
  * @param {object} findings - `{ addressFindings, fmLinkFindings }` from
  *   collection.
- * @param {object} options - `{ manifestDir }`.
+ * @param {object} options - `{ config }`.
  * @returns {object} The gate results and, when they pass, the built index.
  */
-export function siteGates(pages: object[], findings: object, { manifestDir }: object): object;
+export function siteGates(pages: object[], findings: object, { config }: object): object;
 /**
  * The gate result of a build that ran none of them.
  *
@@ -374,7 +374,7 @@ export function resolveOutputRoot(rootDir: string, out: string): string;
  * @returns {{gates: object, stats: object|null, tableErrors: object[],
  *   wikiErrors: object[], manifests: object|null}}
  */
-export function buildSite({ config, outRoot }?: {
+export function buildSite({ config, outRoot, sqlTables }?: {
     config?: object | undefined;
     outRoot?: string | undefined;
 }): {
@@ -385,4 +385,4 @@ export function buildSite({ config, outRoot }?: {
     manifests: object | null;
 };
 export { formatUnaddressableFinding };
-import { formatUnaddressableFinding } from "./foreign-manifests.mjs";
+import { formatUnaddressableFinding } from "./metadata-index.mjs";

package/types/engine/site-index.d.mts

@@ -5,7 +5,7 @@
  *   each already knowing its own `url`.
  * @param {object} [options] - Cross-package inputs.
  * @param {Map<string, {package: string, type?: string}>} [options.foreignIndex]
- *   The merged index from `loadForeignManifests`. Omit when the build publishes
+ *   The merged index from `loadForeignIndexes`. Omit when the build publishes
  *   no cross-package links.
  * @returns {SiteIndex} The index, and what could not be addressed unambiguously.
  */