@heroiclands/package-build 22.21.0 → 22.23.0

package/engine/content-tasklists.mjs

@@ -0,0 +1,189 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * A list item opened with `[ ]` or `[x]`, reported.
+ *
+ * **The format has no checkbox.** A list is written in plain markdown, and
+ * `[ ]` or `[x]` right after the marker is read as the start of the item's own
+ * text on every surface — stating what is done belongs in the words, not in a
+ * bracket.
+ *
+ * ## What it does not look at
+ *
+ * - **Fenced blocks and code spans.** A checklist shown as a markup example is
+ *   prose *about* the two characters, not an authored list — this module's own
+ *   documentation is written out of such examples. Which runs count as code is
+ *   {@link module:engine/code-fences.codeRegions}' rule rather than a second
+ *   copy of it.
+ * - **A bracket anywhere else in a line.** Only the marker that opens a list
+ *   item is read this way; the same two characters in the middle of a sentence
+ *   are prose.
+ *
+ * ## A warning, like the checks around it
+ *
+ * Nothing here is miscompiled — every surface sets the marker as the item's
+ * own text, and all three agree. The finding is for the author: the two
+ * characters read as an interactive control only on one surface, and nowhere
+ * else, so a list reaching for that meaning should say what is done in words
+ * instead.
+ *
+ * @module
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { matchAllOutsideCode } from "./code-fences.mjs";
+import { positionInBody } from "./diagnostics.mjs";
+
+/**
+ * A list item's marker, immediately followed by `[ ]` or `[x]` and a space —
+ * bulleted (`-`, `*`, `+`) or ordered (`1.` or `1)`), at the start of a line.
+ *
+ * The leading indentation is a lookbehind rather than part of the match, so a
+ * nested item's finding points at the marker itself, not at the line's first
+ * column.
+ *
+ * @type {RegExp}
+ */
+export const TASK_LIST_MARKER = /(?<=^[ \t]*)(?:[-*+]|\d+[.)])[ \t]+\[[ xX]\][ \t]/gm;
+
+/**
+ * What a note opening a list item with `[ ]` or `[x]` is told.
+ *
+ * @param {string} marker - The matched marker, as written.
+ * @returns {string} The message, unpunctuated at the end as a finding is.
+ */
+export function taskListMessage(marker) {
+    return (
+        `\`${marker.trim()}\` opens a list item with no checkbox to become — ` +
+        "write a checklist as an ordinary list, stating what is done in the " +
+        "item's own words. Inside a fence or a code span it is an example, and " +
+        "not reported"
+    );
+}
+
+/**
+ * Every list item opened with `[ ]` or `[x]` in one note's body.
+ *
+ * @param {string} body - The note's markdown, without its frontmatter.
+ * @param {string} file - The note's path, for the finding.
+ * @param {object} [opts]
+ * @param {number} [opts.bodyLine=1] - The 1-based file line the body starts on.
+ * @param {number} [opts.bodyColumn=1] - The 1-based file column it starts at.
+ * @returns {Array<{file: string, line: number, column: number,
+ *   severity: "warning", message: string}>} One finding per item, in source
+ *   order.
+ */
+export function checkTaskLists(body, file, { bodyLine = 1, bodyColumn = 1 } = {}) {
+    const text = String(body ?? "");
+    if (!text) return [];
+
+    return matchAllOutsideCode(text, TASK_LIST_MARKER).map((match) => ({
+        file,
+        ...positionInBody(text, /** @type {number} */ (match.index), { bodyLine, bodyColumn }),
+        severity: /** @type {"warning"} */ ("warning"),
+        message: taskListMessage(match[0]),
+    }));
+}
+
+/**
+ * Walk a content tree and report every list item opened with `[ ]` or `[x]`.
+ *
+ * The frontmatter fence is taken off first, so what is scanned is the body and
+ * the positions are still the file's. A file with no frontmatter is scanned
+ * whole: it is not a note, but a stray `.md` in the tree carrying the marker is
+ * the same problem for the same reason.
+ *
+ * A finding names its file **relative to the working directory**, which is
+ * where a reader is standing and what `formatDiagnostic` emits. The content
+ * root is where the walk starts, not what a path is measured from.
+ *
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {readonly string[]} [opts.skipDirectories] - Directory names to ignore
+ *   in addition to the dot-directories always skipped.
+ * @returns {{findings: Array<{file: string, line: number, column: number,
+ *   severity: "warning", message: string}>, files: number}} The findings, and
+ *   how many files were read.
+ */
+export function lintContentTaskLists(contentBase, { skipDirectories = [] } = {}) {
+    const skip = new Set(skipDirectories);
+    /** @type {Array<{file: string, line: number, column: number, severity: "warning", message: string}>} */
+    const findings = [];
+    let files = 0;
+
+    /** @param {string} dir - Directory to descend into. */
+    const walk = (dir) => {
+        /** @type {import("node:fs").Dirent[]} */
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || skip.has(entry.name)) continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!/\.(md|markdown)$/i.test(entry.name)) continue;
+            let content;
+            try {
+                content = fs.readFileSync(full, "utf8");
+            } catch {
+                continue;
+            }
+            files += 1;
+            findings.push(
+                ...checkTaskLists(...bodyOf(content, path.relative(process.cwd(), full))),
+            );
+        }
+    };
+
+    walk(contentBase);
+    return { findings, files };
+}
+
+/**
+ * A file's body, its path, and where the body starts in the file.
+ *
+ * The same split {@link module:engine/helpers.parseMarkdownFile} makes, without
+ * parsing the YAML: this check has no use for the frontmatter's *values*, and
+ * reading them would make an unparseable note silently unscanned.
+ *
+ * @param {string} content - The whole file.
+ * @param {string} file - Its path, for the finding.
+ * @returns {[string, string, {bodyLine: number, bodyColumn: number}]} The
+ *   arguments {@link checkTaskLists} takes.
+ */
+function bodyOf(content, file) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match) return [content, file, { bodyLine: 1, bodyColumn: 1 }];
+
+    const raw = match[2];
+    const body = raw.trim();
+    const bodyStart = content.length - raw.length + (raw.length - raw.trimStart().length);
+    const before = content.slice(0, bodyStart);
+    return [
+        body,
+        file,
+        {
+            bodyLine: before.split("\n").length,
+            bodyColumn: bodyStart - before.lastIndexOf("\n"),
+        },
+    ];
+}

package/engine/docs-checks.mjs

@@ -5,6 +5,8 @@
 import fs from "node:fs";
 import path from "node:path";
 
+import { splitHeadingAttributes } from "./heading-attributes.mjs";
+
 /** @param {string} root */
 function* markdownFiles(root) {
     for (const entry of fs
@@ -40,11 +42,9 @@ export function docAnchors(source) {
     const body = maskMarkdownCode(source, false);
     const anchors = new Set();
     for (const [, heading] of body.matchAll(/^#{1,6}\s+(.+?)\s*#*$/gm)) {
-        const explicit = heading.match(/\{#([^}]+)\}\s*$/);
+        const explicit = splitHeadingAttributes(heading);
         anchors.add(
-            explicit ?
-                explicit[1].trim()
-            :   docHeadingSlug(heading.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")),
+            explicit.id || docHeadingSlug(explicit.text.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")),
         );
     }
     for (const [, anchor] of body.matchAll(/<a\s[^>]*(?:id|name)="([^"]+)"/g)) {

package/engine/extension-attributes.mjs

@@ -1,12 +1,24 @@
 /* SPDX-License-Identifier: GPL-3.0-or-later */
 
+/**
+ * A name an id, a class or an attribute key may carry.
+ *
+ * One letter first, then letters, digits, `_` and `-`: a CSS class and an
+ * attribute key are written this way wherever they appear.
+ */
+const NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
 /**
  * Read the shared braced attribute grammar used by body extensions.
  * Callers validate which names and classes their extension understands.
  * @param {string} source - Text inside the braces.
+ * @param {object} [options={}]
+ * @param {RegExp} [options.idPattern=NAME] - What an `#id` may be named. A
+ *   construct whose id is published as an HTML `id` admits a digit first and
+ *   passes a looser pattern; the default is the pattern every other name takes.
  * @returns {{id: string, classes: string[], values: Record<string, string>, problems: string[]}}
  */
-export function parseExtensionAttributes(source) {
+export function parseExtensionAttributes(source, { idPattern = NAME } = {}) {
     const text = String(source ?? "");
     const result = { id: "", classes: [], values: {}, problems: [] };
     let at = 0;
@@ -18,7 +30,7 @@ export function parseExtensionAttributes(source) {
             const kind = text[at++];
             while (at < text.length && !/\s/.test(text[at])) at++;
             const name = text.slice(start + 1, at);
-            if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(name)) {
+            if (!(kind === "#" ? idPattern : NAME).test(name)) {
                 result.problems.push(
                     `invalid ${kind === "#" ? "id" : "class"} attribute ${text.slice(start, at)}`,
                 );
@@ -72,3 +84,37 @@ export function booleanAttribute(value, key) {
     if (value === "false") return false;
     throw new TypeError(`${key} needs the literal value true or false`);
 }
+
+/**
+ * Attributes a construct's own markup owns, so an author sets them through
+ * `#id` and `.class` rather than through a key.
+ */
+const OWNED = Object.freeze(["id", "class"]);
+
+/**
+ * The attribute keys no construct writes onto an element.
+ *
+ * `id=` and `class=` are refused in favour of `#id` and `.class`, which the
+ * grammar already states; a key beginning `on` is an event handler, and nothing
+ * authored in a note becomes code on a published page.
+ *
+ * Shared by every construct that writes an author's attributes onto an element,
+ * because a refusal that held on one and not the next would be the hole the
+ * other construct is checked for.
+ *
+ * @param {Record<string, string>} values - The `key=value` attributes parsed.
+ * @returns {string[]} One message per refused key, in the order written.
+ */
+export function refusedAttributes(values) {
+    const problems = [];
+    for (const key of Object.keys(values ?? {})) {
+        if (OWNED.includes(key.toLowerCase())) {
+            problems.push(
+                `set ${key} with ${key.toLowerCase() === "id" ? "#id" : ".class"} rather than ${key}=`,
+            );
+        } else if (/^on/i.test(key)) {
+            problems.push(`${key} is an event handler and is not written`);
+        }
+    }
+    return problems;
+}

package/engine/field-reference.mjs

@@ -123,16 +123,41 @@ function fieldTable(fields) {
     return padTable(rows);
 }
 
+/**
+ * The one line explaining why a single field's shared top-level fallback is
+ * off.
+ *
+ * **The field's reason stands on its own** — a complete sentence, or more
+ * than one — rather than completing a clause the frame starts. A field that
+ * collides with a top-level spelling meaning something else can say so
+ * ("`weight` is the item's own, independent of the note's."); a field whose
+ * top-level spelling is refused outright by the closed vocabulary can say
+ * that instead, honestly, which "there it means …" cannot: a refused key
+ * carries no meaning to report.
+ *
+ * Exported so a guard can walk every field declaring `topLevelMeans` across
+ * every registry and check that each one composes into a grammatical
+ * sentence, without reimplementing the frame it is checking.
+ *
+ * @param {import("./field-spec.mjs").FieldSpec} field - A field declaring
+ *   `topLevelMeans`.
+ * @returns {string} The composed markdown line.
+ */
+export function topLevelExemptionLine(field) {
+    return `**\`${field.name}\` is not read from the note's top level.** ${field.topLevelMeans}`;
+}
+
 /**
  * The fields of one type that are **not** filled from the note's top level.
  *
  * A field ordinarily falls back to the top-level property spelled like its
  * name, so an author who writes `weight: 3` at the top of a note reasonably
- * expects it to reach the document. Where that spelling means something else at
- * the note level the fallback is off, and an author has no way to tell from the
- * table — the field is there, the value is written, and the document ships the
- * default. So the reason each such field declares is rendered beside its table
- * rather than left in the source.
+ * expects it to reach the document. Where that spelling is wrong at the note
+ * level — it means something else there, or the closed top-level vocabulary
+ * refuses it outright — the fallback is off, and an author has no way to tell
+ * from the table — the field is there, the value is written, and the document
+ * ships the default. So the reason each such field declares is rendered
+ * beside its table rather than left in the source.
  *
  * Below the table, not inside it: the reason is a sentence or two, and
  * {@link padTable} pads every column to its widest cell, so a cell holding it
@@ -144,11 +169,7 @@ function fieldTable(fields) {
 function sharedExemptions(fields) {
     const exempt = authoredFields(fields).filter((field) => field.topLevelMeans);
     if (!exempt.length) return [];
-    return exempt.flatMap((field) => [
-        `**\`${field.name}\` is not read from the note's top level.** There it means ` +
-            `${field.topLevelMeans}`,
-        "",
-    ]);
+    return exempt.flatMap((field) => [topLevelExemptionLine(field), ""]);
 }
 
 /**

package/engine/field-spec.mjs

@@ -84,19 +84,21 @@ export { legacyKeyOf, retiredTopLevelKey, setPath };
  *   retiring one — so a field can move into `data:` while the corpus catches
  *   up, instead of on a flag day across four repositories. A declaration that
  *   names one is mid-sweep by construction; see {@link readsLegacyKey}.
- * @property {string} [topLevelMeans] - **What the note's top-level key of this
- *   name means instead** — declared only where it means something else, and
- *   stating it removes the shared top-level position from this field's
- *   resolution order.
+ * @property {string} [topLevelMeans] - **Why the note's top-level key of this
+ *   name is not this field's source** — declared wherever that key's spelling
+ *   means something else at the note level, or the closed top-level
+ *   vocabulary refuses it outright, and stating either removes the shared
+ *   top-level position from this field's resolution order.
  *
  *   A field's `name` doubles as its identity and as the shared property it
  *   draws from, which is right wherever the two levels state the same quantity
  *   — `data.weight` is the weight, whoever reads it. It is wrong wherever a
- *   spelling collides across the two vocabularies. An `affiliation` item's
+ *   spelling collides across the two vocabularies, or names a key the closed
+ *   top-level vocabulary does not admit at all. An `affiliation` item's
  *   `system.title` is the style of address an office carries; a note's
- *   top-level `title` is the note's own heading. Nothing relates them, and
- *   before this key one silently fed the other, stringifying an authored
- *   `title: null` into fifteen documents.
+ *   top-level `title` is refused outright. Nothing relates them, and before
+ *   this key one silently fed the other, stringifying an authored `title:
+ *   null` into fifteen documents.
  *
  *   **The value is the reason**, not a flag with a comment beside it. A boolean
  *   would record the decision and lose the case for it, and the next person

package/engine/foreign-catalog.mjs

@@ -38,6 +38,12 @@
  * local pack's output — the resolution logic needs no knowledge of where an
  * item came from.
  *
+ * `assetArchive: true` is the sibling flag, for a dependency whose bytes are
+ * wanted and whose items are not: an asset-replacement source such as
+ * `thalornaaltart` ships no Item packs at all. It unpacks the same release
+ * archive without extracting anything from it, so a relationship declaring
+ * both flags on one entry is fetched once rather than twice.
+ *
  * **The network is never touched by a compile.** Fetching is its own command
  * (`package-build deps fetch`), and a compile whose cache is cold fails saying
  * so. A build that silently downloads is not reproducible, fails strangely
@@ -73,17 +79,22 @@ import {
 const STAMP = ".complete";
 
 /**
- * Every declared relationship that opted into supplying an item catalogue.
+ * Every declared relationship carrying a given flag, in declaration order.
+ *
+ * Shared by {@link itemCatalogRelationships} and
+ * {@link assetArchiveRelationships}: both read the same shape out of the same
+ * walk, filtered on a different key.
  *
  * @param {object} config - The resolved build configuration.
+ * @param {"itemCatalog"|"assetArchive"} flag - Which boolean to filter on.
  * @returns {Array<{id: string, manifest: string, kind: string, verified: string|undefined}>}
- *   The opted-in relationships, in declaration order.
+ *   The opted-in relationships.
  */
-export function itemCatalogRelationships(config) {
+function flaggedRelationships(config, flag) {
     const out = [];
     for (const [kind, entries] of Object.entries(config.relationships ?? {})) {
         for (const rel of entries ?? []) {
-            if (rel.itemCatalog) {
+            if (rel[flag]) {
                 out.push({
                     id: rel.id,
                     manifest: rel.manifest,
@@ -96,6 +107,29 @@ export function itemCatalogRelationships(config) {
     return out;
 }
 
+/**
+ * Every declared relationship that opted into supplying an item catalogue.
+ *
+ * @param {object} config - The resolved build configuration.
+ * @returns {Array<{id: string, manifest: string, kind: string, verified: string|undefined}>}
+ *   The opted-in relationships, in declaration order.
+ */
+export function itemCatalogRelationships(config) {
+    return flaggedRelationships(config, "itemCatalog");
+}
+
+/**
+ * Every declared relationship that opted into supplying its release archive
+ * for asset bytes alone, with no item catalogue built from it.
+ *
+ * @param {object} config - The resolved build configuration.
+ * @returns {Array<{id: string, manifest: string, kind: string, verified: string|undefined}>}
+ *   The opted-in relationships, in declaration order.
+ */
+export function assetArchiveRelationships(config) {
+    return flaggedRelationships(config, "assetArchive");
+}
+
 /**
  * The cache directory for one dependency at one version.
  *
@@ -366,15 +400,21 @@ export function pinnedManifestUrl(url, verified) {
 }
 
 /**
- * Fetch one dependency and extract its Item packs.
- *
- * Idempotent: a complete cache for the resolved version is left alone.
- *
- * @param {object} config - The resolved build configuration.
- * @param {{id: string, manifest: string}} rel - The declared relationship.
- * @returns {Promise<string>} The dependency's cache directory.
+ * Resolve a dependency's manifest, pinned to `compatibility.verified` the way
+ * both fetch paths require.
+ *
+ * Shared by {@link fetchCatalog} and {@link fetchAssetArchive}: both read the
+ * same manifest before deciding what to unpack from it.
+ *
+ * @param {{id: string, manifest: string, verified?: string}} rel - The
+ *   declared relationship.
+ * @param {string} subject - What floats when no version is verified —
+ *   "catalogue" or "archive" — named in the warning a reader would otherwise
+ *   get no word for.
+ * @returns {Promise<{manifest: object, version: string}>} The manifest and
+ *   its resolved version.
  */
-export async function fetchCatalog(config, rel) {
+async function resolveManifest(rel, subject) {
     const { url, pinned } = pinnedManifestUrl(rel.manifest, rel.verified);
     const manifest = await fetchManifest(url);
     const version = manifest.version;
@@ -391,10 +431,24 @@ export async function fetchCatalog(config, rel) {
     }
     if (!rel.verified) {
         log.warn(
-            `${rel.id}: no \`compatibility.verified\`, so its catalogue floats ` +
+            `${rel.id}: no \`compatibility.verified\`, so its ${subject} floats ` +
                 `with whatever ${url} currently serves`,
         );
     }
+    return { manifest, version };
+}
+
+/**
+ * Fetch one dependency and extract its Item packs.
+ *
+ * Idempotent: a complete cache for the resolved version is left alone.
+ *
+ * @param {object} config - The resolved build configuration.
+ * @param {{id: string, manifest: string}} rel - The declared relationship.
+ * @returns {Promise<string>} The dependency's cache directory.
+ */
+export async function fetchCatalog(config, rel) {
+    const { manifest, version } = await resolveManifest(rel, "catalogue");
     const dir = catalogDir(config, rel.id, version);
     if (isComplete(dir)) {
         log.info(`${rel.id}@${version}: already cached`);
@@ -420,6 +474,61 @@ export async function fetchCatalog(config, rel) {
     return dir;
 }
 
+/**
+ * Whether an asset-archive-only cache is present and complete.
+ *
+ * No item catalogue is built on this path, so completeness never asks for
+ * `item-packs.json` — an asset-only dependency, such as `thalornaaltart`,
+ * ships none.
+ *
+ * @param {string} dir - The dependency's cache directory.
+ * @returns {boolean} True when the archive was fetched to completion.
+ */
+const isArchiveComplete = (dir) => fs.existsSync(path.join(dir, STAMP));
+
+/**
+ * Fetch one dependency's release archive for its asset bytes alone, building
+ * no item catalogue from it.
+ *
+ * Idempotent: a complete cache for the resolved version is left alone. Where a
+ * relationship also declares `itemCatalog: true`, {@link fetchCatalog} already
+ * unpacked this same archive into this same cache directory, and
+ * {@link fetchAllCatalogs} does not call this function for it — the two never
+ * download the same bytes twice.
+ *
+ * @param {object} config - The resolved build configuration.
+ * @param {{id: string, manifest: string, verified?: string}} rel - The
+ *   declared relationship.
+ * @returns {Promise<string>} The dependency's cache directory.
+ */
+export async function fetchAssetArchive(config, rel) {
+    const { manifest, version } = await resolveManifest(rel, "archive");
+    const dir = catalogDir(config, rel.id, version);
+    if (isArchiveComplete(dir)) {
+        log.info(`${rel.id}@${version}: already cached`);
+        return dir;
+    }
+
+    const download = manifest.download;
+    if (!download) {
+        throw new Error(`${rel.id}@${version}: its manifest declares no \`download\``);
+    }
+
+    // Rebuild from empty: a previous run may have died partway, and a stale
+    // half-tree is worse than no tree.
+    fs.rmSync(dir, { recursive: true, force: true });
+    const raw = path.join(dir, "package");
+    fs.mkdirSync(raw, { recursive: true });
+
+    log.info(`${rel.id}@${version}: downloading ${download}`);
+    await downloadAndUnzip(download, raw);
+
+    cacheSchemaArtifact(raw, dir);
+    // Last, so a fetch that died partway is never mistaken for a complete one.
+    fs.writeFileSync(path.join(dir, STAMP), `${version}\n`);
+    return dir;
+}
+
 /**
  * Locate a declared pack inside an unpacked archive.
  *
@@ -700,17 +809,33 @@ export async function fetchAllMetadata(config) {
 /**
  * Fetch every opted-in dependency. The `deps fetch` command.
  *
+ * A relationship declaring both `itemCatalog: true` and `assetArchive: true`
+ * is fetched once: {@link fetchCatalog} already unpacks the archive on its
+ * way to extracting the item catalogue, so this skips the archive-only fetch
+ * for any id {@link fetchCatalog} already handled.
+ *
  * @param {object} config - The resolved build configuration.
  * @returns {Promise<number>} How many dependencies were fetched.
  */
 export async function fetchAllCatalogs(config) {
-    const rels = itemCatalogRelationships(config);
-    if (!rels.length) {
-        log.info("No relationship declares `itemCatalog: true`; nothing to fetch.");
+    const itemRels = itemCatalogRelationships(config);
+    const archiveRels = assetArchiveRelationships(config);
+    if (!itemRels.length && !archiveRels.length) {
+        log.info(
+            "No relationship declares `itemCatalog: true` or `assetArchive: true`; " +
+                "nothing to fetch.",
+        );
         return 0;
     }
-    for (const rel of rels) await fetchCatalog(config, rel);
-    return rels.length;
+    for (const rel of itemRels) await fetchCatalog(config, rel);
+    const alreadyFetched = new Set(itemRels.map((rel) => rel.id));
+    let archiveFetched = 0;
+    for (const rel of archiveRels) {
+        if (alreadyFetched.has(rel.id)) continue;
+        await fetchAssetArchive(config, rel);
+        archiveFetched++;
+    }
+    return itemRels.length + archiveFetched;
 }
 
 /**