forgebook 0.1.8 → 0.2.0

package/dist/bin/forgebook/tokensRun.d.ts

@@ -0,0 +1,41 @@
+/**
+ * What `forgebook tokens` does: one of three questions, by what it was given.
+ *
+ * @module
+ */
+import type { ScriptIo } from "@ensiria/cli-kit/io.types";
+import type { Logger } from "@ensiria/cli-kit/log.types";
+import type { ResolvedConfig } from "../../src/vite/configFile.ts";
+/** Where the answers come from and go. */
+export type TokensReach = {
+    /** The catalogue. */
+    readonly config: ResolvedConfig;
+    /** Its dev server's address, when not the default. */
+    readonly url: string | undefined;
+    /** Where the answer goes. */
+    readonly context: {
+        readonly io: ScriptIo;
+        readonly log: Logger;
+        readonly isJson: boolean;
+    };
+};
+/** What was asked. */
+export type TokensQuestion = {
+    /** One token's name. */
+    readonly name: string | undefined;
+    /** A value to find the nearest tokens of. */
+    readonly nearest: string | undefined;
+    /** A type or first group, for the list. */
+    readonly category: string | undefined;
+    /** What to compare with, for the nearest. */
+    readonly type: string | undefined;
+    /** The most tokens a list gives. */
+    readonly limit: string | undefined;
+};
+/**
+ * Answers `forgebook tokens`.
+ *
+ * @param reach - where the answers come from and go.
+ * @param question - what was asked.
+ */
+export declare const runTokens: ({ config, url, context }: TokensReach, { name, nearest, category, type, limit }: TokensQuestion) => Promise<void>;

package/dist/bin/forgebook/tokensRun.js

@@ -0,0 +1,42 @@
+import { ScriptError } from "@ensiria/cli-kit/script";
+import { isNearestTokensDocument, isTokenDocument, isTokensDocument } from "../../src/vite/agentApi.js";
+import { clashText, nearestTokensText, tokensText, tokenText } from "./agentText.js";
+import { askCatalogue, printAnswer, printTokenAnswer } from "./catalogueCommands.js";
+/** The answer had a shape this version does not read. */
+const unexpected = () => new ScriptError("The catalogue's answer has an unexpected shape");
+/**
+ * Answers `forgebook tokens`.
+ *
+ * @param reach - where the answers come from and go.
+ * @param question - what was asked.
+ */
+export const runTokens = async ({ config, url, context }, { name, nearest, category, type, limit }) => {
+    const { log } = context;
+    if (nearest !== undefined && name !== undefined) {
+        throw new ScriptError("Give a token's name or --nearest, not both");
+    }
+    if (nearest !== undefined) {
+        const params = new URLSearchParams({ value: nearest, type: type ?? "" });
+        const body = await askCatalogue(config, url, "nearest-token", params, log);
+        if (!isNearestTokensDocument(body))
+            throw unexpected();
+        printTokenAnswer(nearestTokensText(body), body, context);
+        return;
+    }
+    if (name !== undefined) {
+        const body = await askCatalogue(config, url, "token", new URLSearchParams({ name }), log);
+        if (!isTokenDocument(body))
+            throw unexpected();
+        for (const clash of body.clashes)
+            log.warn(clashText(clash));
+        printTokenAnswer(tokenText(body.token), body, context);
+        return;
+    }
+    const params = new URLSearchParams({ category: category ?? "", limit: limit ?? "" });
+    const body = await askCatalogue(config, url, "tokens", params, log);
+    if (!isTokensDocument(body))
+        throw unexpected();
+    for (const clash of body.clashes)
+        log.warn(clashText(clash));
+    printAnswer(tokensText(body), body, body.problems, context);
+};

package/dist/bin/forgebook/touchWindowRun.d.ts

@@ -14,4 +14,3 @@ import type { Logger } from "@ensiria/cli-kit/log.types";
  * @throws when the testing package or the address is missing.
  */
 export declare const openTouchWindow: (dir: string, url: string | undefined, log: Logger) => Promise<void>;
-//# sourceMappingURL=touchWindowRun.d.ts.map

package/dist/bin/forgebook/touchWindowRun.js

@@ -19,4 +19,3 @@ export const openTouchWindow = async (dir, url, log) => {
     // a window that cannot open (no Chromium installed) is said, and the dev server keeps running
     open(request).then(() => log.info("Touch window closed; the dev server keeps running"), (error) => log.error(`The touch window could not open: ${error instanceof Error ? error.message : String(error)}`));
 };
-//# sourceMappingURL=touchWindowRun.js.map

package/dist/bin/forgebook/visualCommands.d.mts

@@ -0,0 +1,37 @@
+import type { CommandNode, CommandScope } from "@ensiria/cli-kit/commands.types";
+import type { StoryDiffReport, StoryShotReport } from "../../src/storyCheck.ts";
+import type { ResolvedConfig } from "../../src/vite/configFile.ts";
+import type { McpTool } from "../../src/vite/mcpProtocol.ts";
+import { type ForgebookOptions } from "./catalogueCommands.ts";
+import type { StoryCheckInput } from "./storyCheckRun.ts";
+/** Where baselines are kept unless a command names a folder. */
+export declare const BASELINES_FOLDER = "forgebook-baselines";
+/**
+ * The folder baselines are kept in, the same whoever asks: the command from any folder, or an agent's tool.
+ *
+ * @param dir - the catalogue's folder.
+ */
+export declare const baselinesOf: (dir: string) => string;
+/**
+ * Stores a story's pictures as its baselines, all or none: a story that did not draw would hold a broken picture as the
+ * truth, and every later comparison would pass on it.
+ *
+ * @param config - the catalogue's configuration.
+ * @param url - where `forgebook dev` runs.
+ * @param input - the id and the views.
+ * @param out - the folder, when not the catalogue's own.
+ * @returns the pictures, or why they cannot be baselines.
+ */
+export declare const updateBaselines: (config: ResolvedConfig, url: string | undefined, input: StoryCheckInput, out: string | undefined) => Promise<StoryShotReport | string>;
+/**
+ * The command.
+ *
+ * @param forgebook - the scope of the `forgebook` command.
+ */
+export declare const visualCommands: (forgebook: CommandScope<ForgebookOptions>) => Readonly<Record<string, CommandNode>>;
+/**
+ * The MCP tool.
+ *
+ * @param diff - what compares, with the baselines' folder as the catalogue keeps it.
+ */
+export declare const visualDiffTool: (diff: (input: StoryCheckInput, outDir: string) => Promise<StoryDiffReport | string>) => McpTool;

package/dist/bin/forgebook/visualCommands.mjs

@@ -0,0 +1,162 @@
+/**
+ * `forgebook diff`, and what `forgebook mcp` offers for it: a story's pictures against stored baselines, with an exit
+ * code for CI.
+ *
+ * @module
+ */
+import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, relative, resolve } from "node:path";
+import { EXIT } from "@ensiria/cli-kit/constants";
+import { formatJson } from "@ensiria/cli-kit/files";
+import { ScriptError } from "@ensiria/cli-kit/script";
+import { diffText } from "./agentText.js";
+import { COMMAND, configOf } from "./catalogueCommands.js";
+import { runStoryDiff, runStoryShot } from "./storyCheckRun.js";
+/** Where baselines are kept unless a command names a folder. */
+export const BASELINES_FOLDER = "forgebook-baselines";
+/**
+ * The folder baselines are kept in, the same whoever asks: the command from any folder, or an agent's tool.
+ *
+ * @param dir - the catalogue's folder.
+ */
+export const baselinesOf = (dir) => join(dir, BASELINES_FOLDER);
+/**
+ * Stores a story's pictures as its baselines, all or none: a story that did not draw would hold a broken picture as the
+ * truth, and every later comparison would pass on it.
+ *
+ * @param config - the catalogue's configuration.
+ * @param url - where `forgebook dev` runs.
+ * @param input - the id and the views.
+ * @param out - the folder, when not the catalogue's own.
+ * @returns the pictures, or why they cannot be baselines.
+ */
+export const updateBaselines = async (config, url, input, out) => {
+    const folder = out === undefined ? baselinesOf(config.dir) : resolve(out);
+    const taken = mkdtempSync(join(tmpdir(), "forgebook-baselines-"));
+    try {
+        const report = await runStoryShot(config, url, input, taken);
+        if (typeof report === "string")
+            return report;
+        const broken = report.shots.filter((shot) => shot.status !== undefined);
+        if (broken.length > 0) {
+            return `No baselines written: ${broken.map((shot) => shot.storyId).join(", ")} did not draw`;
+        }
+        mkdirSync(folder, { recursive: true });
+        const shots = report.shots.map((shot) => {
+            const file = join(folder, basename(shot.file));
+            copyFileSync(shot.file, file);
+            return { ...shot, file };
+        });
+        return { schema: 1, shots };
+    }
+    finally {
+        rmSync(taken, { recursive: true, force: true });
+    }
+};
+/** Whether a comparison found what should fail a check: a change, or a story with no baseline to hold it. */
+const hasDifference = (report) => report.results.some((each) => each.status !== "same");
+/**
+ * The command.
+ *
+ * @param forgebook - the scope of the `forgebook` command.
+ */
+export const visualCommands = (forgebook) => ({
+    diff: forgebook.command({
+        summary: "Compare a story's pictures with its baselines: which changed, where and by how much.",
+        json: true,
+        options: {
+            view: {
+                type: "string",
+                multiple: true,
+                valueName: "view",
+                description: "A view to compare it in, as forgebook shot takes it."
+            },
+            "all-variants": {
+                type: "boolean",
+                description: "Compare every variant the catalogue's browser tests check."
+            },
+            baselines: {
+                type: "string",
+                valueName: "folder",
+                description: `The folder forgebook shot --update wrote; ${BASELINES_FOLDER} beside the configuration by default.`
+            },
+            out: {
+                type: "string",
+                default: "forgebook-diff",
+                valueName: "folder",
+                description: "The folder the new pictures and the marked ones go in."
+            },
+            url: {
+                type: "string",
+                env: "FORGEBOOK_URL",
+                valueName: "address",
+                description: "Where forgebook dev runs, when not at Vite's default address (http://localhost:5173)."
+            }
+        },
+        positionals: [
+            { name: "id", description: "A story's id, or a component's for its listed stories.", required: true }
+        ],
+        examples: [
+            { command: `${COMMAND} shot kit:data-badge --update`, description: "Store its baselines." },
+            { command: `${COMMAND} diff kit:data-badge --json`, description: "Compare it after a change." }
+        ],
+        run: async ({ args, options, io, isJson, style }) => {
+            const config = await configOf(options.config);
+            const report = await runStoryDiff(config, options.url, { id: args.id, views: options.view ?? [], isAllVariants: options["all-variants"] === true }, {
+                baselines: options.baselines === undefined ? baselinesOf(config.dir) : resolve(options.baselines),
+                outDir: resolve(options.out)
+            });
+            if (typeof report === "string")
+                throw new ScriptError(report);
+            io.stdout.write(isJson ? formatJson(report) : `${diffText(report, (file) => relative(process.cwd(), file), style)}\n`);
+            if (hasDifference(report)) {
+                throw new ScriptError("The pictures differ", { exitCode: EXIT.failure, isReported: true });
+            }
+        }
+    })
+});
+/** The folder a session's pictures go in, emptied for each call, as `story_shot`'s is. */
+let toolDir;
+/** The folder for a call. */
+const toolFolder = () => {
+    toolDir ??= mkdtempSync(join(tmpdir(), "forgebook-diff-"));
+    rmSync(toolDir, { recursive: true, force: true });
+    mkdirSync(toolDir, { recursive: true });
+    return toolDir;
+};
+/**
+ * The MCP tool.
+ *
+ * @param diff - what compares, with the baselines' folder as the catalogue keeps it.
+ */
+export const visualDiffTool = (diff) => ({
+    name: "visual_diff",
+    description: "Compare a story's pictures with the baselines forgebook shot --update stored: which changed, the region, the percentage of pixels, and the marked picture to look at. new means no baseline yet.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "A story's id, or a component's for its listed stories." },
+            views: {
+                type: "array",
+                items: { type: "string" },
+                description: "The views to compare it in; the default view when none."
+            }
+        },
+        required: ["id"],
+        additionalProperties: false
+    },
+    call: async (args) => {
+        const views = Array.isArray(args["views"])
+            ? args["views"].filter((view) => typeof view === "string")
+            : [];
+        const id = typeof args["id"] === "string" ? args["id"] : "";
+        const report = await diff({ id, views, isAllVariants: false }, toolFolder());
+        if (typeof report === "string")
+            return { structured: { error: report }, isError: true };
+        const images = report.results.flatMap((each) => each.diff === undefined
+            ? []
+            : [{ data: readFileSync(each.diff).toString("base64"), mimeType: "image/png" }]);
+        return { structured: report, isError: false, images };
+    }
+});

package/dist/bin/forgebook/viteCache.d.ts

@@ -0,0 +1,48 @@
+/** The parts of a Vite configuration that place its cache folder. */
+export type CachePlacing = {
+    /** The root; the working folder when none. */
+    readonly root?: string;
+    /** The cache folder set, relative to the root; Vite's default when none. */
+    readonly cacheDir?: string;
+    /** Whether links are kept as they are, which keeps the root unresolved too. */
+    readonly resolve?: {
+        readonly preserveSymlinks?: boolean;
+    };
+};
+/**
+ * The cache folder Vite would use for a configuration: the one set, else Vite's default (`node_modules/.vite` of the
+ * nearest package, else of the root, else `.vite` in the root).
+ *
+ * @param current - the configuration so far, with what every other plugin set.
+ */
+export declare const viteCacheDir: (current: CachePlacing) => string;
+/**
+ * The file a first start's pre-bundling writes the imports it could not resolve in, which every later server of the
+ * catalogue leaves out as the pre-bundling did (`prebundleRun.ts`).
+ *
+ * @param root - the catalogue's folder.
+ */
+export declare const unresolvedFile: (root: string) => string;
+/**
+ * The stamp of the installed packages: the nearest lock file's name, change time and size; empty without one. An
+ * install changes it, as it changes Vite's pre-bundle hash.
+ *
+ * @param root - the catalogue's folder.
+ */
+export declare const installStamp: (root: string) => string;
+/**
+ * The imports a first start's pre-bundling could not resolve, while the installed packages are those it found them
+ * missing from: after an install Vite pre-bundles again, and an import that resolves now is pre-bundled like any
+ * other, since Vite serves one left out as it is and a CommonJS package would not load. None when it resolved them
+ * all, or wrote nothing.
+ *
+ * @param root - the catalogue's folder.
+ */
+export declare const unresolvedImports: (root: string) => readonly string[];
+/**
+ * Keeps the imports the pre-bundling left out, with the installed packages' stamp.
+ *
+ * @param root - the catalogue's folder.
+ * @param imports - the imports.
+ */
+export declare const keepUnresolved: (root: string, imports: readonly string[]) => void;

package/dist/bin/forgebook/viteCache.js

@@ -0,0 +1,112 @@
+/**
+ * Where Vite keeps a catalogue's cache, found without loading Vite: the command's servers keep theirs inside it
+ * (`commandServer.ts`), and a first start's pre-bundling looks there for what it already did (`prebundleStart.ts`).
+ *
+ * @module
+ */
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+/** The nearest folder at or above `dir` holding a `package.json`, as Vite looks for the project's package. */
+const nearestPackageDir = (dir) => {
+    for (let at = dir;; at = dirname(at)) {
+        if (existsSync(join(at, "package.json")))
+            return at;
+        if (dirname(at) === at)
+            return undefined;
+    }
+};
+/** The root as Vite resolves it: through links unless the configuration keeps them, as the cache folder is found. */
+const viteRoot = (current) => {
+    const root = resolve(current.root ?? process.cwd());
+    if (current.resolve?.preserveSymlinks === true || !existsSync(root))
+        return root;
+    return realpathSync(root);
+};
+/**
+ * The cache folder Vite would use for a configuration: the one set, else Vite's default (`node_modules/.vite` of the
+ * nearest package, else of the root, else `.vite` in the root).
+ *
+ * @param current - the configuration so far, with what every other plugin set.
+ */
+export const viteCacheDir = (current) => {
+    const root = viteRoot(current);
+    if (current.cacheDir !== undefined)
+        return resolve(root, current.cacheDir);
+    const packageDir = nearestPackageDir(root);
+    if (packageDir !== undefined)
+        return join(packageDir, "node_modules", ".vite");
+    const modules = join(root, "node_modules");
+    return existsSync(modules) ? join(modules, ".vite") : join(root, ".vite");
+};
+/**
+ * The file a first start's pre-bundling writes the imports it could not resolve in, which every later server of the
+ * catalogue leaves out as the pre-bundling did (`prebundleRun.ts`).
+ *
+ * @param root - the catalogue's folder.
+ */
+export const unresolvedFile = (root) => join(viteCacheDir({ root }), "forgebook", "unresolved.json");
+/** The lock files Vite reads to tell whether the installed packages changed, the first found from the root up. */
+const LOCK_FILES = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lock", "bun.lockb", "deno.lock"];
+/**
+ * The stamp of the installed packages: the nearest lock file's name, change time and size; empty without one. An
+ * install changes it, as it changes Vite's pre-bundle hash.
+ *
+ * @param root - the catalogue's folder.
+ */
+export const installStamp = (root) => {
+    for (let at = resolve(root);; at = dirname(at)) {
+        for (const name of LOCK_FILES) {
+            const stats = statSync(join(at, name), { throwIfNoEntry: false });
+            if (stats !== undefined)
+                return `${join(at, name)}:${stats.mtimeMs}:${stats.size}`;
+        }
+        if (dirname(at) === at)
+            return "";
+    }
+};
+/**
+ * Whether a value read from the file is what the pre-bundling writes.
+ *
+ * @param value - the file's JSON.
+ */
+const isUnresolvedRecord = (value) => typeof value === "object" &&
+    value !== null &&
+    "installed" in value &&
+    typeof value.installed === "string" &&
+    "imports" in value &&
+    Array.isArray(value.imports) &&
+    value.imports.every((name) => typeof name === "string");
+/**
+ * The imports a first start's pre-bundling could not resolve, while the installed packages are those it found them
+ * missing from: after an install Vite pre-bundles again, and an import that resolves now is pre-bundled like any
+ * other, since Vite serves one left out as it is and a CommonJS package would not load. None when it resolved them
+ * all, or wrote nothing.
+ *
+ * @param root - the catalogue's folder.
+ */
+export const unresolvedImports = (root) => {
+    const file = unresolvedFile(root);
+    if (!existsSync(file))
+        return [];
+    let value;
+    try {
+        value = JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        // a file written halfway, or by hand: as if none were left out
+        return [];
+    }
+    return isUnresolvedRecord(value) && value.installed === installStamp(root) ? value.imports : [];
+};
+/**
+ * Keeps the imports the pre-bundling left out, with the installed packages' stamp.
+ *
+ * @param root - the catalogue's folder.
+ * @param imports - the imports.
+ */
+export const keepUnresolved = (root, imports) => {
+    const file = unresolvedFile(root);
+    mkdirSync(dirname(file), { recursive: true });
+    const record = { installed: installStamp(root), imports };
+    writeFileSync(file, JSON.stringify(record));
+};

package/dist/bin/forgebook-docs/catalogueDocs.d.ts

@@ -17,8 +17,7 @@ export type CatalogueDocsRequest = {
  * @param request - the package, its framework, whether to check, and the command that fixes them.
  * @param log - where to report.
  * @returns the report, for `--json`.
- * @throws a `ScriptError` in a check when a file is stale or a file could not be read, or when the package's options
+ * @throws a `ScriptError` in a check when a file is stale or something could not be read, or when the package's options
  *   are wrong.
  */
 export declare const catalogueDocs: (request: CatalogueDocsRequest, log: Logger) => Promise<CatalogueDocsReport>;
-//# sourceMappingURL=catalogueDocs.d.ts.map

package/dist/bin/forgebook-docs/catalogueDocs.js

@@ -21,7 +21,7 @@ const LLMS_FILE = "llms.txt";
  * @param request - the package, its framework, whether to check, and the command that fixes them.
  * @param log - where to report.
  * @returns the report, for `--json`.
- * @throws a `ScriptError` in a check when a file is stale or a file could not be read, or when the package's options
+ * @throws a `ScriptError` in a check when a file is stale or something could not be read, or when the package's options
  *   are wrong.
  */
 export const catalogueDocs = async (request, log) => {
@@ -41,18 +41,22 @@ export const catalogueDocs = async (request, log) => {
     const llms = llmsText({
         packageName: data.packageName,
         description: data.description,
-        catalogueFile: options.file
+        catalogueFile: options.file,
+        pages: data.pages ?? [],
+        hasTokens: options.sections.includes("tokens") && data.tokens.length > 0
     });
     const counts = {
         components: data.components.length,
+        pages: data.pages?.length ?? 0,
         modules: data.modules.length,
         sassModules: data.sassModules.length,
-        styleSheets: data.styleSheets.length
+        styleSheets: data.styleSheets.length,
+        tokens: data.tokens.length
     };
     const report = { file: shown(file), llmsFile: shown(llmsFile), counts, problems };
     if (request.isCheck) {
         if (problems.length > 0)
-            throw new ScriptError(`${plural(problems.length, "file")} could not be read`);
+            throw new ScriptError(`${plural(problems.length, "problem")} reading the package`);
         const written = [
             [file, text],
             [llmsFile, llms]
@@ -68,4 +72,3 @@ export const catalogueDocs = async (request, log) => {
     log.success(`${shown(file)} and ${LLMS_FILE} ${isWritten ? "written" : "already up to date"}`);
     return { status: isWritten ? "written" : "up-to-date", ...report };
 };
-//# sourceMappingURL=catalogueDocs.js.map

package/dist/bin/forgebook-docs/catalogueDocs.types.d.ts

@@ -4,6 +4,7 @@
  * @module
  */
 import type { ComponentDocs } from "../../src/componentDocs.ts";
+import type { DesignToken } from "../../src/vite/designTokens.ts";
 /** One exported function, value or type of a module. */
 export type ExportDocs = {
     /** The export's name. */
@@ -59,8 +60,21 @@ export type CatalogueComponent = {
     readonly stories: readonly string[];
     /** The export name of its main story (`parameters.main`, else its first); none without stories. */
     readonly mainStory: string | undefined;
+    /** Its main story's id without the source's, as Storybook's (its own id, else the meta's and the export's). */
+    readonly mainStoryId: string | undefined;
     /** Whether every story of its file is about logic (`parameters.logic`): a hook or a function, listed by its call. */
     readonly isLogic: boolean;
+    /** The link to its design in Figma (the meta's `parameters.design.figma`), when it has a valid one. */
+    readonly design: string | undefined;
+};
+/** One docs page of the package. */
+export type CataloguePage = {
+    /** Its title (`Guides/Theming`). */
+    readonly title: string;
+    /** Its file, relative to the package's folder. */
+    readonly file: string;
+    /** What it is about, in a sentence; none when it does not say. */
+    readonly description: string | undefined;
 };
 /** Everything `CATALOG.md` lists. */
 export type CatalogueData = {
@@ -72,12 +86,16 @@ export type CatalogueData = {
     readonly sourceId: string | undefined;
     /** The components with stories, by title. */
     readonly components: readonly CatalogueComponent[];
+    /** The docs pages its source declares, in reading order; none by default. */
+    readonly pages?: readonly CataloguePage[];
     /** The other exported modules. */
     readonly modules: readonly ModuleDocs[];
     /** The public Sass modules. */
     readonly sassModules: readonly SassModuleDocs[];
     /** The published style sheets. */
     readonly styleSheets: readonly StyleSheetDocs[];
+    /** The design tokens its source gives, in the files' order. */
+    readonly tokens: readonly DesignToken[];
 };
 /** The `--json` document. */
 export type CatalogueDocsReport = {
@@ -87,14 +105,15 @@ export type CatalogueDocsReport = {
     readonly file: string;
     /** `llms.txt`, beside it, relative to the folder the command runs in. */
     readonly llmsFile: string;
-    /** How many components, modules, Sass modules and style sheets it lists. */
+    /** How many components, modules, Sass modules, style sheets and design tokens it lists. */
     readonly counts: {
         readonly components: number;
+        readonly pages: number;
         readonly modules: number;
         readonly sassModules: number;
         readonly styleSheets: number;
+        readonly tokens: number;
     };
-    /** Story files that could not be read, with why. */
+    /** What could not be read, with why: a story file, a tokens file, a token. */
     readonly problems: readonly string[];
 };
-//# sourceMappingURL=catalogueDocs.types.d.ts.map

package/dist/bin/forgebook-docs/catalogueDocs.types.js

@@ -1 +0,0 @@
-//# sourceMappingURL=catalogueDocs.types.js.map

package/dist/bin/forgebook-docs/catalogueMarkdown.d.ts

@@ -8,4 +8,3 @@ import type { CatalogueSection } from "./catalogueOptions.ts";
  * @returns the Markdown, ending with a newline.
  */
 export declare const catalogueMarkdown: (data: CatalogueData, sections: readonly CatalogueSection[]) => string;
-//# sourceMappingURL=catalogueMarkdown.d.ts.map