@heroiclands/package-build 17.2.0 → 18.0.0

package/types/content-config.d.mts

@@ -2,7 +2,7 @@
  * Whether this package publishes the pages its content tree compiles to.
  *
  * The one question every reader of the mode actually asks — the site build, to
- * decide whether to walk the tree at all, and the link-manifest emitter, to
+ * decide whether to walk the tree at all, and the content index, to
  * decide whether an entry carries a web `path`. Written once here so the two
  * cannot come to disagree about what a mode means.
  *
@@ -39,13 +39,12 @@ export function defineConfig(config: ContentBuildConfigInput): ContentBuildConfi
 export const PACKAGE_KINDS: readonly ["systems", "modules"];
 export namespace DEFAULT_PATHS {
     let content: "assets/content";
-    let manifests: "assets/manifests";
-    let manifestOut: "build/manifests";
     let contentIndex: "build/content-index";
     let packJson: "build/packs-json";
     let stage: "build/stage/packs";
     let unpack: "build/tmp/packs";
     let foreignCache: "build/cache/foreign";
+    let metadataCache: "build/cache/metadata";
 }
 /**
  * The Foundry document types a compendium pack may hold. This is the set the
@@ -89,7 +88,7 @@ export const RETIRED_ADDRESS_KEYS: Readonly<Record<string, string>>;
  * `sohl`, whose knowledgebase is one surface among several, and empty for
  * `thalorna`, whose site is nothing but its content. It is not the package's
  * own mount point: where the package itself is served is the consuming build's
- * knowledge, held in `PACKAGE_BASE` (`engine/kb-manifest.mjs`) and prefixed at
+ * knowledge, held in `PACKAGE_BASE` (`engine/content-address.mjs`) and prefixed at
  * resolve time, so it is never recorded here (#1465).
  *
  * It is the whole scheme: `landing`, the key that named which note addressed a
@@ -110,7 +109,7 @@ export const DEFAULT_ADDRESS_SCHEME: Readonly<{
  *
  * - `homepage` — the authored homepage, and **no other page**. The content tree
  *   is not walked for pages, `site.sections` / `site.trees` / `site.landing`
- *   emit nothing, and link-manifest entries carry no web `path`.
+ *   emit nothing, and nothing serves a page for its addresses.
  * - `content` — the homepage *plus* every page the content tree publishes: the
  *   knowledgebase, the extra trees, the section landings.
  *
@@ -163,7 +162,7 @@ export const DERIVED_SYSTEM_VERSION: symbol;
  *
  * - `homepage` — the authored homepage, and **no other page**. The content tree
  *   is not walked for pages, `site.sections` / `site.trees` / `site.landing`
- *   emit nothing, and link-manifest entries carry no web `path`.
+ *   emit nothing, and nothing serves a page for its addresses.
  * - `content` — the homepage *plus* every page the content tree publishes: the
  *   knowledgebase, the extra trees, the section landings.
  *
@@ -284,19 +283,6 @@ export type PathsInput = {
      * Content tree root.
      */
     content?: string | undefined;
-    /**
-     * Vendored cross-package link manifests,
-     *         read by `links`. Inbound.
-     */
-    manifests?: string | undefined;
-    /**
-     * Where `manifest` writes this package's
-     *       own link manifest. Outbound, and a
-     *       build artifact — the published copy is
-     *       the one a consumer vendors into its
-     *       `manifests` directory.
-     */
-    manifestOut?: string | undefined;
     /**
      * Where `content-index` writes this
      *      package's note index. Outbound, and a
@@ -316,18 +302,32 @@ export type PathsInput = {
      * Where `unpack` extracts JSON back to.
      */
     unpack?: string | undefined;
+    /**
+     * Where a dependency declaring
+     *      `itemCatalog: true` is unpacked.
+     *      Inbound, and fetched rather than
+     *      committed.
+     */
+    foreignCache?: string | undefined;
+    /**
+     * Where a dependency's published content
+     *     index is fetched to (#239). Inbound,
+     *     for *every* declared dependency, not
+     *     only those supplying a catalogue.
+     */
+    metadataCache?: string | undefined;
 };
 /**
  * {@link PathsInput}, resolved to absolute paths against `rootDir`.
  */
 export type ResolvedPaths = {
     content: string;
-    manifests: string;
-    manifestOut: string;
     contentIndex: string;
     packJson: string;
     stage: string;
     unpack: string;
+    foreignCache: string;
+    metadataCache: string;
 };
 /**
  * The identity every compiled document's `_stats` block carries.
@@ -371,32 +371,12 @@ export type StatsSpec = {
  * two places for one fact.
  */
 export type PackageBuildSection = Record<string, unknown>;
-/**
- * The two manifest switches. A package may publish a link manifest, consume
- * other packages' manifests, both, or neither — the four combinations are all
- * real (see #1385/#1446: `kethira` consumes but never publishes).
- */
-export type ManifestSwitches = {
-    /**
-     * Emit this package's link manifest.
-     */
-    publish: boolean;
-    /**
-     * Resolve cross-package links through vendored manifests.
-     */
-    consume: boolean;
-};
 export type PublishSwitches = {
     /**
      * How much of this package reaches the web.
      * See {@link SITE_MODES}.
      */
     site: SiteMode;
-    manifests: ManifestSwitches;
-};
-export type ManifestSwitchesInput = {
-    publish?: boolean | undefined;
-    consume?: boolean | undefined;
 };
 /**
  * The **Foundry core** version range this package supports.
@@ -512,7 +492,6 @@ export type DocsSpec = {
 };
 export type PublishSwitchesInput = {
     site?: SiteMode | undefined;
-    manifests?: ManifestSwitchesInput | undefined;
     address?: AddressSchemeInput | undefined;
 };
 export type AddressSchemeInput = {

package/types/engine/actor-compiler.d.mts

@@ -0,0 +1,204 @@
+/**
+ * Strip compendium-only fields from a predefined item before embedding it
+ * inside an actor's `items[]`. These fields belong on a top-level
+ * compendium document, not on an embedded one.
+ *
+ * @param {object} item - The catalogue entry.
+ * @returns {object} The entry, without its compendium-only fields.
+ */
+export function stripCompendiumFields(item: object): object;
+/**
+ * Whether a value is a plain object, for {@link deepMerge}.
+ *
+ * @param {unknown} v - The value.
+ * @returns {boolean} True for a plain object.
+ */
+export function isPlainObject(v: unknown): boolean;
+/**
+ * Recursively merge `overlay` onto `base`. Plain objects merge key-by-key;
+ * everything else (arrays, primitives, null) replaces. Inputs are not
+ * mutated.
+ *
+ * @param {any} base - The catalogue entry.
+ * @param {any} overlay - The note's own values.
+ * @returns {any} The merged value.
+ */
+export function deepMerge(base: any, overlay: any): any;
+/**
+ * The key one predefined item is held under, and every place that spells it.
+ *
+ * **The vocabulary is the document's, not the note's** — `subType` is the
+ * Foundry Item subtype the compiled document carries, which is the only thing a
+ * compiled pack (or an extracted dependency catalogue) records about what an
+ * item *is*. An actor's frontmatter addresses the same item in the *note*
+ * vocabulary, so a reference is translated forward through the system's map
+ * before it reaches this function; see
+ * {@link SystemActorCompiler#embeddedSubtype} for why the translation goes that
+ * way and not the other (#140).
+ *
+ * @param {string} subType - The Foundry Item subtype.
+ * @param {string} shortcode - The item's `system.shortcode`.
+ * @returns {string} The address, `subType:shortcode`.
+ */
+export function itemAddress(subType: string, shortcode: string): string;
+/**
+ * What identifies one embedded item on its actor.
+ *
+ * **Its own `system.shortcode`** — not the entry's top-level `shortcode`, which
+ * merely *selects* the catalogue template the entry is written from and is
+ * never written to the document. Two daggers may share a selector; they are two
+ * embodiments and each must declare its own.
+ *
+ * The name is a last resort, for a **stand-alone** entry that names no template
+ * and states no shortcode. It is a poor identity — presentation, and free to be
+ * localized or to diverge — so it is not a fallback the compiler is content
+ * with: two entries reducing to one identity is refused either way, and the
+ * message says to state a `system.shortcode`.
+ *
+ * @param {object} item - The merged embedded item.
+ * @returns {string} The identity, for {@link embeddedItemId}.
+ */
+export function embeddedIdentity(item: object): string;
+/**
+ * The `_id` of one item embedded on an actor.
+ *
+ * Seeded by the owning actor, because an embedded id must be unique within its
+ * **parent document** and nothing wider — so the namespace is already exactly
+ * the scope the uniqueness is required in, and the largest namespace in the
+ * four corpora holds 180 items, at which 64 bits collide with probability
+ * around 10⁻¹⁵.
+ *
+ * **It takes no index** (#268). Keying on a position meant reordering a being's
+ * item list renumbered every id after the change, so a re-import created new
+ * documents beside the old ones — while nothing about those documents had
+ * changed, only their neighbours. The identity always exists or must be stated;
+ * see {@link embeddedIdentity}.
+ *
+ * Keyed by the **document subtype**, so renaming a note type (#78) leaves every
+ * embedded id where it was.
+ *
+ * @param {string} actorId - The owning actor's id.
+ * @param {string} subType - The Foundry Item subtype.
+ * @param {string} identity - From {@link embeddedIdentity}.
+ * @returns {string} A 16-character Foundry id.
+ */
+export function embeddedItemId(actorId: string, subType: string, identity: string): string;
+/**
+ * Load every JSON file under each of `itemsSourceDirs`, returning one Map keyed
+ * by {@link itemAddress} — the compiled document's **subtype** and its
+ * `system.shortcode`. Folder docs and entries without a shortcode are skipped.
+ * The `_key` field is stripped from each entry — it is not part of the item
+ * data model.
+ *
+ * The directories are read as one address space, because an actor names an item
+ * by `(type, shortcode)` and never by the pack it happens to ship in. Two local
+ * Item packs claiming the same address is therefore ambiguous rather than a
+ * last-one-wins ordering detail, and fails here.
+ *
+ * A **foreign** directory — the extracted item catalogue of a package this
+ * repository depends on but does not contain — is a fallback rather than a
+ * peer. A repository must be able to ship its own `skill:awar` that stands in
+ * front of the system's, so a local address shadows a foreign one instead of
+ * colliding with it. Local directories are therefore read first, and anything
+ * already claimed is left alone.
+ *
+ * @param {readonly string[]} itemsSourceDirs - Every local Item pack's JSON tree.
+ * @param {readonly string[]} [foreignSourceDirs] - Extracted dependency
+ *   catalogues, consulted only for addresses no local pack defines.
+ * @returns {Map<string, object>} The predefined items, by address.
+ */
+export function loadItemsMap(itemsSourceDirs: readonly string[], foreignSourceDirs?: readonly string[]): Map<string, object>;
+/**
+ * The Actor compile pass of one game system.
+ *
+ * A subclass declares its {@link SystemActorCompiler.documentSubtypes} and
+ * implements `buildEntry`, which is where the system's own data model is: what
+ * an actor's `system` block holds, which art it defaults to, which frontmatter
+ * becomes embedded items. Nothing above that line is a system's business.
+ */
+export class SystemActorCompiler extends BasePackCompiler {
+    /**
+     * The note-type → document-subtype map this pass compiles against.
+     *
+     * Stated by the class rather than reached for through a module import, so
+     * every subtype decision the pass makes — the actor's own, and each
+     * embedded item reference's — reads one declaration that a subclass
+     * compiling for another system replaces.
+     *
+     * @type {import("./document-subtypes.mjs").DocumentSubtypeMap|undefined}
+     */
+    static documentSubtypes: import("./document-subtypes.mjs").DocumentSubtypeMap | undefined;
+    constructor({ itemsSourceDirs, foreignSourceDirs, ...options }: {
+        [x: string]: any;
+        itemsSourceDirs?: never[] | undefined;
+        foreignSourceDirs?: never[] | undefined;
+    });
+    /** @type {readonly string[]} */
+    itemsSourceDirs: readonly string[];
+    foreignSourceDirs: any;
+    /**
+     * This pass's system map, or a message naming the class that forgot it.
+     *
+     * @returns {import("./document-subtypes.mjs").DocumentSubtypeMap} The map.
+     */
+    get documentSubtypes(): import("./document-subtypes.mjs").DocumentSubtypeMap;
+    /**
+     * The frontmatter block this pass reads.
+     *
+     * @returns {string} The system's block name.
+     */
+    get system(): string;
+    itemsMap: Map<string, object> | undefined;
+    /** @inheritdoc */
+    reportDetail(stats: any): void;
+    /**
+     * The Foundry Item subtype an embedded reference's `type` addresses.
+     *
+     * **The reference is in the note vocabulary; the address is in the
+     * document's** (#140). An actor writes `(type, shortcode)` with the type an
+     * author authors, while {@link itemAddress} keys the predefined items by
+     * the subtype each compiled document carries — so exactly one of the two
+     * sides has to translate, and it is this one. The system's map is a
+     * function from note type to subtype by construction; the reverse is not,
+     * and a compiled document records nothing about the note that produced it,
+     * so there is no honest way to key the addresses the other way round.
+     *
+     * @param {string} type - The type the reference names.
+     * @returns {import("./document-subtypes.mjs").ReferencedSubtype} The
+     *   subtype, or why the reference names none.
+     */
+    embeddedSubtype(type: string): import("./document-subtypes.mjs").ReferencedSubtype;
+    /**
+     * Resolve one embedded item from a `(type, shortcode?, overlay)`
+     * descriptor. If `shortcode` is given, the predefined item is fetched
+     * from `itemsMap` and the overlay deep-merged on top. If absent, the
+     * descriptor must carry enough fields to stand alone. The embedded
+     * item's `_id` is regenerated deterministically from
+     * `(actorId, subType, shortcode, indexKey)` so re-exports are stable —
+     * from the **document subtype**, so that renaming a note type (#78) leaves
+     * every embedded id exactly where it was.
+     * Returns null if the descriptor cannot be resolved.
+     *
+     * @param {Map<string, object>} itemsMap - The predefined items, by address.
+     * @param {string} actorId - The owning actor's id, seeding embedded ids.
+     * @param {string} type - The **note** type the reference names.
+     * @param {string|null} shortcode - The referenced item's shortcode, or
+     *   `null` for a stand-alone entry.
+     * @param {object} [overlay] - The entry's remaining properties.
+     * @param {string} indexKey - Where the reference sits, for a diagnostic.
+     *   It no longer reaches the id (#268) — it names the entry in a message.
+     * @param {string} ctx - Diagnostic context (the actor's label).
+     * @param {object} [at] - Where to locate a finding.
+     * @param {string} [at.fmKey] - The frontmatter key the reference sits
+     *   under, so an unresolved one is reported at the reference rather than
+     *   at the note.
+     * @returns {object|null} The embedded item, or null when it resolved to
+     *   nothing — always with a finding emitted.
+     */
+    resolveEmbedded(itemsMap: Map<string, object>, actorId: string, type: string, shortcode: string | null, overlay?: object, indexKey: string, ctx: string, { fmKey }?: {
+        fmKey?: string | undefined;
+    }): object | null;
+    #private;
+}
+import { BasePackCompiler } from "./base-compiler.mjs";
+export { extractAnchorSection, renderSection } from "./anchored-sections.mjs";

package/types/engine/address-charset.d.mts

@@ -13,19 +13,22 @@ export function isAddressSegment(value: unknown): boolean;
 /**
  * The one charset every segment of a canonical address is held to (#59).
  *
- * An address is a hyphen-joined tuple — `sohl-skill-clmb` — and it is read back
- * by **counting segments**, with a fixed meaning per position. That is sound
- * for exactly one reason: the hyphen is *purely* a separator, because no
- * segment may contain one. Take that away and reading an address needs a
- * vocabulary to match against, a longest-match rule, and an answer for every
- * name that is a prefix of another — none of which exist.
+ * An address is a hyphen-joined tuple — `package-system-type-shortcode`, so
+ * `sohl-none-doc-gear` — and it is read back by **counting segments**, with a
+ * fixed meaning per position. That is sound for exactly one reason: the hyphen
+ * is *purely* a separator, because no segment may contain one. Take that away
+ * and reading an address needs a vocabulary to match against, a longest-match
+ * rule, and an answer for every name that is a prefix of another — none of
+ * which exist.
  *
  * So the charset is not a tidiness rule. It is the premise the address grammar
  * rests on, and the issue's word for how it should be held is **enforced rather
  * than assumed**: a value that breaks it is refused where it is written, not
  * discovered later as addresses that fail to parse and report nothing about
- * why. `harn-adventures` was that case — its keys read as four segments and
- * failed as a `null` return.
+ * why. `harn-adventures` was that case — a package whose own name carries the
+ * separator emits keys one segment too long, so `harn-adventures-sohl-skill-melee`
+ * counts five where the grammar requires four, and every one of them failed as
+ * a `null` return.
  *
  * This module is a **leaf with no local imports**, so the validator a
  * consumer's `package-build.config.mjs` reaches (`content-config.mjs`) can name

package/types/engine/address-diff.d.mts

@@ -1,3 +1,18 @@
+/**
+ * The one spelling of an address in this space: `type:shortcode`.
+ *
+ * Written by both readers — the compiled packs on each side of the diff, and
+ * the declarations read out of the tree — so a predecessor a note names and an
+ * address a pack publishes cannot come apart over punctuation or case. The
+ * shortcode is used **verbatim**, not lowercased: `readItemAddresses` reads it
+ * off the compiled document, where `Tabri` is stored as authored, and folding
+ * case here would join two addresses the packs keep apart.
+ *
+ * @param {string} type - The Foundry document subtype, not the note type.
+ * @param {string} shortcode - The address's `system.shortcode`.
+ * @returns {string} The address key.
+ */
+export function itemAddressKey(type: string, shortcode: string): string;
 /**
  * The address space a set of compiled Item pack directories publishes.
  *
@@ -24,6 +39,9 @@ export function readItemAddresses(dirs: readonly string[]): Map<string, {
     shortcode: string;
     file: string;
 }>;
+export function declaredPredecessors(contentBase: any, { skipDirectories, maps, config, records, problems }?: {
+    maps?: readonly import("./document-subtypes.mjs").DocumentSubtypeMap[] | undefined;
+}): Map<any, any>;
 /**
  * Every address the baseline published that this build does not.
  *
@@ -36,12 +54,20 @@ export function readItemAddresses(dirs: readonly string[]): Map<string, {
  * @param {object} opts
  * @param {string} opts.baseline - What the baseline is, for the message —
  *   conventionally `<package>@<version>`.
+ * @param {Map<string, {to: string, file: string}>} [opts.predecessors] - The
+ *   declared renames, from {@link declaredPredecessors}. Omitted, the diff
+ *   falls back to the id join alone and reports an unpinned rename as a
+ *   withdrawal, which is what it did before #278.
  * @returns {Array<object>} One finding per departed address, in address order
- *   so two runs read the same. `kind` is `"renamed"` (with `to`) or
- *   `"withdrawn"`.
+ *   so two runs read the same. `kind` is `"renamed"` (with `to`, and `declared`
+ *   when it was the note's word rather than an id match) or `"withdrawn"`.
  */
-export function diffItemAddresses(baseline: Map<string, object>, current: Map<string, object>, { baseline: label }: {
+export function diffItemAddresses(baseline: Map<string, object>, current: Map<string, object>, { baseline: label, predecessors }: {
     baseline: string;
+    predecessors?: Map<string, {
+        to: string;
+        file: string;
+    }> | undefined;
 }): Array<object>;
 /**
  * Every content note in a tree, indexed by the document id it authors.
@@ -53,11 +79,18 @@ export function diffItemAddresses(baseline: Map<string, object>, current: Map<st
  *
  * @param {string} contentBase - Root of the content tree.
  * @param {object} [opts]
- * @param {readonly string[]} [opts.skipDirectories] - Passed to the walk.
+ * @param {readonly string[]} [opts.skipDirectories] - The corpus scope, stated
+ *   by the caller — see {@link addressCorpus}.
+ * @param {object} [opts.config] - The resolved build configuration, which the
+ *   id is derived against. See {@link addressCorpus} for why that matters.
+ * @param {readonly object[]} [opts.records] - Index records the caller already
+ *   derived, shared with {@link declaredPredecessors}.
  * @returns {Map<string, string>} Document id → the note's absolute path.
  */
-export function noteFilesById(contentBase: string, { skipDirectories }?: {
+export function noteFilesById(contentBase: string, { skipDirectories, config, records, problems }?: {
     skipDirectories?: readonly string[] | undefined;
+    config?: object | undefined;
+    records?: readonly object[] | undefined;
 }): Map<string, string>;
 /**
  * Where to send the reader for one finding.
@@ -69,6 +102,11 @@ export function noteFilesById(contentBase: string, { skipDirectories }?: {
  * address existing. When neither is readable the position is **dropped**, never
  * defaulted to `1:1`.
  *
+ * A **declared** rename knows its note without any lookup — the declaration is
+ * how it was found — and is reported at the `renamedFrom:` line rather than the
+ * `shortcode:` line, because that is the line the finding is about and the one
+ * the author deletes once the declaration has done its work (#278).
+ *
  * @param {object} finding - One finding from {@link diffItemAddresses}.
  * @param {Map<string, string>} noteFiles - From {@link noteFilesById}.
  * @returns {{file?: string, line?: number, column?: number}} Spreadable
@@ -88,6 +126,16 @@ export function locateAddressFinding(finding: object, noteFiles: Map<string, str
  * known — and says so, rather than leaving the reader to wonder whether one was
  * looked for.
  *
+ * **A declared rename says it is declared** (#278). The two claims are not
+ * equally checkable: an id match is a fact in the artefacts, while a
+ * declaration is an author's word, and a reader deciding whether to trust the
+ * successor needs to know which one they have. Saying "the same document" of a
+ * declared rename would spend the id match's credibility on it.
+ *
+ * The consequence sentence is the same for both, because it is the same
+ * consequence: the old address stops resolving either way, and that is what
+ * the reader has to act on.
+ *
  * @param {object} finding - One finding from {@link diffItemAddresses}.
  * @returns {string} The message.
  */

package/types/engine/anchored-sections.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Extract the body of an H1 section whose heading carries the explicit
+ * anchor decorator `{#<anchorId>}`. Captures every line after the H1 up
+ * to (but not including) the next H1 — nested H2/H3 etc. and their bodies
+ * are included. The H1 line itself is discarded. Returns "" if no such
+ * heading exists. Fenced code blocks are respected so `# foo` inside
+ * ``` blocks does not trigger a match.
+ *
+ * @param {string} body - The note body.
+ * @param {string} anchorId - The anchor to find.
+ * @returns {string} The section's markdown, or "".
+ */
+export function extractAnchorSection(body: string, anchorId: string): string;
+/**
+ * Render an extracted markdown section to HTML, or "" if empty.
+ *
+ * @param {string} body - The note body.
+ * @param {string} anchorId - The anchor to find.
+ * @returns {string} The rendered HTML, or "".
+ */
+export function renderSection(body: string, anchorId: string): string;

package/types/engine/anchors.d.mts

@@ -0,0 +1,20 @@
+/**
+ * The `{#slug}` anchors a note's body declares, with where each one sits.
+ *
+ * Only headings carrying an explicit anchor are collected. A bare `#` heading
+ * also starts a journal page, but it declares no slug, so nothing can address
+ * it with `#…` — listing it would offer a link that cannot be written.
+ *
+ * @param {string} body - The note's markdown body, frontmatter already removed.
+ * @param {number} [bodyLine] - The 1-based file line the body starts on, from
+ *   `parseMarkdownFile`. Anchors are reported at their position in the **file**,
+ *   so an editor can jump straight to one; passing nothing numbers from the body.
+ * @returns {Array<{slug: string, name: string, level: number, line: number}>}
+ *   In document order.
+ */
+export function collectAnchors(body: string, bodyLine?: number): Array<{
+    slug: string;
+    name: string;
+    level: number;
+    line: number;
+}>;

package/types/engine/base-compiler.d.mts

@@ -103,6 +103,8 @@ export class BasePackCompiler {
      * @param {object} options
      * @param {string} options.contentBase - Root of the content tree.
      * @param {string} options.dest - Where this pass writes its JSON.
+     * @param {readonly string[]} options.skipDirectories - Directories the walk
+     *   never descends into. Required: see {@link assertStatedScope}.
      * @param {(path: string|null) => string|null} [options.folderResolver] -
      *   Resolves a `sohl.folder` id against this pack's folder hierarchy.
      * @param {string} [options.packName] - The pack this pass writes.
@@ -112,9 +114,10 @@ export class BasePackCompiler {
      * @param {boolean} [options.routingReporter] - Whether this pass reports a
      *   note of its type that routes nowhere.
      */
-    constructor({ contentBase, dest, folderResolver, packName, packSystem, docType, router, routingReporter, }?: {
+    constructor({ contentBase, dest, skipDirectories, folderResolver, packName, packSystem, docType, router, routingReporter, corpus, }?: {
         contentBase: string;
         dest: string;
+        skipDirectories: readonly string[];
         folderResolver?: ((path: string | null) => string | null) | undefined;
         packName?: string | undefined;
         docType?: string | undefined;
@@ -189,6 +192,7 @@ export class BasePackCompiler {
      */
     unresolvedLinks: number;
     packSystem: any;
+    corpus: any;
     /**
      * The `_stats` block every entry this pass emits is stamped with (#48).
      *
@@ -224,9 +228,12 @@ export class BasePackCompiler {
      * instances of.
      *
      * @param {object} fm - The note's frontmatter.
-     * @returns {boolean} True when the note may be compiled here.
-     * @throws {Error} When this pack's system is absent from the note. The
-     *   error carries a `position` where the note's own file can be read.
+     * @returns {boolean} True when the note may be compiled here; `false` when
+     *   it belongs to another system's pass of the same document type, which is
+     *   skipped as quietly as any other note this pack does not own.
+     * @throws {Error} When this pack's system is absent from the note and no
+     *   other configured system claims it. The error carries a `position` where
+     *   the note's own file can be read.
      */
     eligibleFor(fm: object): boolean;
     /**
@@ -267,17 +274,10 @@ export class BasePackCompiler {
      * @returns {Promise<void>}
      */
     prepare(): Promise<void>;
-    linkIndex: {
-        byShortcode: Map<any, any>;
-        types: Set<any>;
-    } | undefined;
-    contentDocs: {
-        fm: object;
-        path: string;
-        tld: string;
-        folder: string;
-        absPath: string;
-    }[] | undefined;
+    reportsCorpusProblems: boolean | undefined;
+    linkIndex: any;
+    contentDocs: any;
+    sqlTables: any;
     /**
      * The body {@link BasePackCompiler#buildEntry} receives.
      *
@@ -344,7 +344,7 @@ export class BasePackCompiler {
      * The sibling of {@link BasePackCompiler#reportUndeclaredSystemData}, and
      * the half that sees what no declaration states. A compiler writes keys of
      * its own alongside the declared fields — `shortcode`, `actionDefs`,
-     * `notes`, `docHtml`, `archetype` — and neither the field-declaration check
+     * `notes`, `docHtml`, `templatePriority` — and neither the field-declaration check
      * nor the authored-`system` check can see them, so until this nothing
      * compared them at all. Foundry's discard is the same silent one either
      * way.
@@ -369,7 +369,7 @@ export class BasePackCompiler {
      * @param {object} [opts.config] - The resolved build configuration.
      * @returns {number} How many findings were new to this pass.
      */
-    reportEmittedSystemData(system: object, { fm, block, documentType, subType, type, fields, config }: {
+    reportEmittedSystemData(emitted: any, { fm, block, documentType, subType, type, fields, config }: {
         fm: object;
         block: string;
         documentType: string;