forgebook 0.3.2 → 0.4.0

package/dist/src/vite/gitChange.d.ts

@@ -1,6 +1,8 @@
 import { type VitePaths } from "./vitePaths.ts";
 /** A change. */
 export type GitChange = {
+    /** The commit it is measured from. */
+    readonly base: string;
     /** Its unified diff, with no context. */
     readonly diff: string;
     /** The files it deletes, relative to the repository. */
@@ -16,6 +18,15 @@ export type GitChange = {
  * @returns what it wrote.
  */
 export declare const gitOutput: (dir: string, ...args: readonly string[]) => Promise<string>;
+/**
+ * Runs git in a folder, in the environment given rather than this process's.
+ *
+ * @param dir - a folder of the repository.
+ * @param env - the environment git gets.
+ * @param args - its arguments.
+ * @returns what it wrote.
+ */
+export declare const gitOutputIn: (dir: string, env: NodeJS.ProcessEnv, ...args: readonly string[]) => Promise<string>;
 /**
  * The commit a change starts from.
  *
@@ -25,16 +36,38 @@ export declare const gitOutput: (dir: string, ...args: readonly string[]) => Pro
  */
 export declare const changeBase: (dir: string, since: string) => Promise<string | undefined>;
 /**
- * The files a change touches, tracked or new.
+ * Why a change has no start, in words that say what to do: a shallow clone, which is CI's default, knows the commit and
+ * not what it shares with this one.
  *
  * @param dir - a folder of the repository.
- * @param base - the commit it starts from.
- * @returns the repository's folder, and the files relative to it.
+ * @param since - a commit, as asked.
  */
-export declare const changedFiles: (dir: string, base: string) => Promise<{
+export declare const noBaseReason: (dir: string, since: string) => Promise<string>;
+/**
+ * Where a branch's work starts when nobody says: the default branch, or `HEAD` when there is none to start from. On the
+ * default branch itself that is what is not pushed.
+ *
+ * @param dir - a folder of the repository.
+ * @returns the name to compare with.
+ */
+export declare const branchStart: (dir: string) => Promise<string>;
+/** The files a change touches. */
+export type ChangedFiles = {
+    /** The repository's folder. */
     readonly root: string;
+    /** The files, tracked or new, relative to it. */
     readonly files: readonly string[];
-}>;
+    /** Those it deletes. */
+    readonly deleted: readonly string[];
+};
+/**
+ * The files a change touches, tracked or new.
+ *
+ * @param dir - a folder of the repository.
+ * @param base - the commit it starts from.
+ * @returns the repository's folder, the files relative to it, and which of them it deletes.
+ */
+export declare const changedFiles: (dir: string, base: string) => Promise<ChangedFiles>;
 /**
  * The changed files as the catalogue's graph names them: absolute, under the catalogue's folder as configured, in Vite's
  * form. Git names real paths (with forward slashes on Windows too), and a folder reached through a link has another.

package/dist/src/vite/gitChange.js

@@ -6,7 +6,9 @@
  * `--output=…` for an option and overwrites a file. The diff asks for one fixed form whatever the user's git settings,
  * since colours, external diff tools and other prefixes all read as an empty change, which is a check passing with
  * nothing checked. A change starts where the branch left `since`, or what `since` gained afterwards is read as this
- * change's.
+ * change's. A branch's committed work counts as its change, so a check run after a commit does not find nothing and
+ * pass: `branchStart` names the default branch to start from, and a clone with no history to find the start in is told
+ * apart from a name that means nothing.
  *
  * @module
  */
@@ -24,8 +26,23 @@ const run = promisify(execFile);
  * @returns what it wrote.
  */
 export const gitOutput = async (dir, ...args) => (await run("git", ["-c", "core.quotePath=false", ...args], { cwd: dir, maxBuffer: MAX_OUTPUT })).stdout;
-/** The lines of a list git wrote. */
-const listed = (text) => text.split("\n").filter((line) => line !== "");
+/**
+ * Runs git in a folder, in the environment given rather than this process's.
+ *
+ * @param dir - a folder of the repository.
+ * @param env - the environment git gets.
+ * @param args - its arguments.
+ * @returns what it wrote.
+ */
+export const gitOutputIn = async (dir, env, ...args) => (await run("git", ["-c", "core.quotePath=false", ...args], { cwd: dir, env, maxBuffer: MAX_OUTPUT }))
+    .stdout;
+/**
+ * The names of a list git wrote with `-z`: otherwise it quotes a name that holds a quotation mark or a tab, which then
+ * matches no file and no rule.
+ */
+const listed = (text) => text.split("\0").filter((name) => name !== "");
+/** The new files git does not track, in the whole repository: from a subfolder it would list that folder's only. */
+const untrackedFiles = async (root) => listed(await gitOutput(root, "ls-files", "-z", "--others", "--exclude-standard", "--full-name"));
 /**
  * The commit a change starts from.
  *
@@ -42,18 +59,52 @@ export const changeBase = async (dir, since) => {
         return undefined;
     }
 };
+/**
+ * Why a change has no start, in words that say what to do: a shallow clone, which is CI's default, knows the commit and
+ * not what it shares with this one.
+ *
+ * @param dir - a folder of the repository.
+ * @param since - a commit, as asked.
+ */
+export const noBaseReason = async (dir, since) => {
+    try {
+        await gitOutput(dir, "rev-parse", "--verify", "--quiet", "--end-of-options", `${since}^{commit}`);
+        return `"${since}" shares no history with this commit here: in a shallow clone, fetch the whole history (fetch-depth: 0)`;
+    }
+    catch {
+        return `"${since}" names no commit here`;
+    }
+};
+/** The branches a repository's work usually starts from, when its remote names none. */
+const USUAL_DEFAULT_BRANCHES = ["origin/main", "origin/master", "main", "master"];
+/**
+ * Where a branch's work starts when nobody says: the default branch, or `HEAD` when there is none to start from. On the
+ * default branch itself that is what is not pushed.
+ *
+ * @param dir - a folder of the repository.
+ * @returns the name to compare with.
+ */
+export const branchStart = async (dir) => {
+    const named = await gitOutput(dir, "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD").catch(() => "");
+    for (const branch of [named.trim(), ...USUAL_DEFAULT_BRANCHES]) {
+        if (branch !== "" && (await changeBase(dir, branch)) !== undefined)
+            return branch;
+    }
+    return "HEAD";
+};
 /**
  * The files a change touches, tracked or new.
  *
  * @param dir - a folder of the repository.
  * @param base - the commit it starts from.
- * @returns the repository's folder, and the files relative to it.
+ * @returns the repository's folder, the files relative to it, and which of them it deletes.
  */
 export const changedFiles = async (dir, base) => {
     const root = (await gitOutput(dir, "rev-parse", "--show-toplevel")).trim();
-    const tracked = listed(await gitOutput(dir, "diff", "--no-ext-diff", "--name-only", base, "--"));
-    const untracked = listed(await gitOutput(dir, "ls-files", "--others", "--exclude-standard", "--full-name"));
-    return { root, files: [...new Set([...tracked, ...untracked])] };
+    const names = ["--no-ext-diff", "--no-relative", "--name-only", "-z"];
+    const tracked = listed(await gitOutput(dir, "diff", ...names, base, "--"));
+    const deleted = listed(await gitOutput(dir, "diff", ...names, "--diff-filter=D", base, "--"));
+    return { root, files: [...new Set([...tracked, ...(await untrackedFiles(root))])], deleted };
 };
 /**
  * The changed files as the catalogue's graph names them: absolute, under the catalogue's folder as configured, in Vite's
@@ -76,11 +127,20 @@ export const catalogueChangedFiles = (dir, realDir, root, files, paths = VITE_PA
 export const gitChange = async (dir, since) => {
     const base = await changeBase(dir, since);
     if (base === undefined)
-        return `"${since}" names no commit here`;
-    const form = ["--no-ext-diff", "--no-textconv", "--no-color", "--src-prefix=a/", "--dst-prefix=b/"];
+        return noBaseReason(dir, since);
+    const form = [
+        "--no-ext-diff",
+        "--no-textconv",
+        "--no-color",
+        "--no-relative",
+        "--src-prefix=a/",
+        "--dst-prefix=b/"
+    ];
+    const root = (await gitOutput(dir, "rev-parse", "--show-toplevel")).trim();
     return {
+        base,
         diff: await gitOutput(dir, "diff", ...form, "--unified=0", base, "--"),
-        deleted: listed(await gitOutput(dir, "diff", ...form, "--name-only", "--diff-filter=D", base, "--")),
-        untracked: listed(await gitOutput(dir, "ls-files", "--others", "--exclude-standard", "--full-name"))
+        deleted: listed(await gitOutput(dir, "diff", ...form, "--name-only", "-z", "--diff-filter=D", base, "--")),
+        untracked: await untrackedFiles(root)
     };
 };

package/dist/src/vite/hiddenStoryFiles.d.ts

@@ -0,0 +1,23 @@
+/** A hidden folder a file sits in, and the pattern that lists that folder's story files. */
+type HiddenFolder = {
+    readonly folder: string;
+    readonly pattern: string;
+    readonly files: readonly string[];
+};
+/**
+ * The story files the patterns pass over in hidden folders, grouped by the first hidden folder each sits in, with the
+ * pattern that lists them.
+ *
+ * @param config - the catalogue's folder and its stories' patterns.
+ */
+export declare const hiddenStoryFolders: (config: {
+    readonly dir: string;
+    readonly stories: readonly string[];
+}) => HiddenFolder[];
+/**
+ * What to say of the folders of `hiddenStoryFolders`: how many files, where, and the patterns that list them.
+ *
+ * @param folders - the folders, at least one.
+ */
+export declare const hiddenStoryFoldersMessage: (folders: readonly HiddenFolder[]) => string;
+export {};

package/dist/src/vite/hiddenStoryFiles.js

@@ -0,0 +1,107 @@
+/**
+ * The story files a catalogue's patterns pass over because they sit in a hidden folder (`docs/.vitepress/…`): a glob's
+ * `**` does not enter a folder whose name starts with a dot, so such files are never listed, and nothing said why. The
+ * stories answer, the dev server and the commands that stop on an empty pattern name them, with a pattern that lists
+ * them.
+ *
+ * @remarks
+ * For each pattern with a `**`, the hidden folders under its static start are found (folders only, at most
+ * `MAX_FOLDERS`, leaving out `.git` and `node_modules`), and the pattern's file name is globbed in each by its name
+ * (`docs/.vitepress/**\/*.stories.ts`), as the catalogue's own listing globs (Node's `globSync`, which reads a hidden
+ * folder named in a pattern on every version). A file another pattern lists,
+ * or a `!` pattern leaves out (its hidden folders read as plain ones), is not named: writing `!docs/.vitepress/**` says
+ * the folder is left out on purpose and ends the notice.
+ *
+ * @module
+ */
+import { globSync, readdirSync } from "node:fs";
+import { matchesGlob } from "node:path";
+import { patternBase } from "./autoTitle.js";
+import { isNegated } from "./storyPatterns.js";
+import { VITE_PATHS } from "./vitePaths.js";
+/** Folders never entered: they hold no story, and can hold very many files. */
+const NOT_ENTERED = /(^|[\\/])(\.git|node_modules)$/;
+/** How many folders are read at most to find the hidden ones: a pattern starting at the project's root reads many. */
+const MAX_FOLDERS = 20_000;
+/** A folder's sub-folders; none when it cannot be read. */
+const foldersIn = (dir) => {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+    }
+    catch {
+        return [];
+    }
+};
+/**
+ * The topmost hidden folders under a folder, relative to the root.
+ *
+ * @param root - the catalogue's folder.
+ * @param base - the folder to look under, relative to the root.
+ */
+const hiddenFoldersUnder = (root, base) => {
+    const found = [];
+    const queue = [base];
+    let read = 0;
+    while (queue.length > 0 && read < MAX_FOLDERS) {
+        const folder = queue.pop() ?? "";
+        for (const entry of foldersIn(VITE_PATHS.resolve(root, folder))) {
+            read += 1;
+            if (NOT_ENTERED.test(entry.name))
+                continue;
+            const path = folder === "" ? entry.name : `${folder}/${entry.name}`;
+            if (entry.name.startsWith("."))
+                found.push(path);
+            else
+                queue.push(path);
+        }
+    }
+    return found;
+};
+/** A path or a pattern with each segment's leading dot taken off, so a glob reads it as an ordinary folder. */
+const undotted = (path) => path.replace(/(^|\/)\.(?=[^./])/g, "$1");
+/**
+ * The story files the patterns pass over in hidden folders, grouped by the first hidden folder each sits in, with the
+ * pattern that lists them.
+ *
+ * @param config - the catalogue's folder and its stories' patterns.
+ */
+export const hiddenStoryFolders = (config) => {
+    const plain = (pattern) => pattern.replace(/^\.\//, "");
+    const listed = config.stories.filter((each) => !isNegated(each)).map(plain);
+    const leftOut = config.stories.filter(isNegated).map((each) => undotted(plain(each.slice(1))));
+    // a file in one, as the pattern would match it with the folder's dot taken off, that nothing lists or leaves out
+    const isPassedOver = (file, pattern) => matchesGlob(undotted(file), undotted(pattern)) &&
+        !listed.some((each) => matchesGlob(file, each)) &&
+        !leftOut.some((each) => matchesGlob(undotted(file), each));
+    const folders = new Map();
+    for (const pattern of listed.filter((each) => each.includes("**"))) {
+        const last = pattern.split("/").pop() ?? "*";
+        for (const folder of hiddenFoldersUnder(config.dir, patternBase(pattern).replace(/^\.\/?/, ""))) {
+            const named = `${folder}/**/${last}`;
+            const files = globSync(named, { cwd: config.dir })
+                .map((found) => VITE_PATHS.normalize(found))
+                .filter((file) => isPassedOver(file, pattern));
+            if (files.length === 0)
+                continue;
+            const entry = folders.get(folder) ?? { pattern: named, files: [] };
+            entry.files.push(...files);
+            folders.set(folder, entry);
+        }
+    }
+    return [...folders]
+        .map(([folder, entry]) => ({ folder, pattern: entry.pattern, files: [...new Set(entry.files)].sort() }))
+        .sort((a, b) => a.folder.localeCompare(b.folder));
+};
+/** How many hidden folders a message names before it says how many more there are. */
+const NAMED_FOLDERS = 3;
+/**
+ * What to say of the folders of `hiddenStoryFolders`: how many files, where, and the patterns that list them.
+ *
+ * @param folders - the folders, at least one.
+ */
+export const hiddenStoryFoldersMessage = (folders) => {
+    const files = folders.reduce((sum, each) => sum + each.files.length, 0);
+    const named = folders.slice(0, NAMED_FOLDERS).map((each) => `\`${each.pattern}\``);
+    const more = folders.length > NAMED_FOLDERS ? `, and ${folders.length - NAMED_FOLDERS} more folders` : "";
+    return `${files === 1 ? "1 story file sits" : `${files} story files sit`} in a hidden folder the stories' patterns do not enter: list ${files === 1 ? "it" : "them"} with ${named.join(", ")}${more}, or write a \`!\` pattern for the folder to leave it out`;
+};

package/dist/src/vite/hotSnippets.d.ts

@@ -11,8 +11,10 @@
  * @module
  */
 import type { Plugin } from "vite";
+import { type StoryFileRead } from "../hotModules.ts";
 import type { CloseWatch } from "./closeWatch.ts";
-import { type IndexedStoryFile } from "./storyFilesModule.ts";
+import type { ScriptProblems } from "./scriptProblems.ts";
+import { type RefusedStoryFile, type StoryFilesRead } from "./storyFilesModule.ts";
 /**
  * What a story file runs to accept its edit: the frame that draws its stories cancels the event and draws them anew;
  * when none does, the files that import it take the edit (one that re-exports its stories draws them). The exports the
@@ -49,38 +51,60 @@ export declare const renewedModule: <TModule extends {
     readonly code: string;
 }>(id: string, module: TModule, queries: readonly string[], isServing: boolean) => TModule;
 /**
- * What a pattern's files module runs: it takes the edits its story files hand on, which change nothing it holds. An
- * edit that changes its list reloads the pages from the server, and its pages keep the module they read.
+ * What a pattern's files module runs: it takes the edits its story files hand on, which change nothing it holds, as
+ * an edit that changes its list reloads the pages from the server. What an edit says of a file that cannot be read
+ * goes on to the page, unless it is the fix of a file the page was served without: it has no story to redraw, so it
+ * reloads to list them. Those files are kept in the module's hot data, so a version served after the page's first does not count.
+ *
+ * @param refused - the story files the module was served without.
  */
-export declare const FILES_MODULE_HOT = "if (import.meta.hot) import.meta.hot.accept();";
+export declare const filesModuleHot: (refused: readonly RefusedStoryFile[]) => string;
+/** What an edit of a story file changed. */
+export type StoryFileEdit = {
+    /** The patterns' modules it changed (a story added or renamed, a title), which the open pages read once. */
+    readonly changed: readonly string[];
+    /** The patterns' modules that say the file can or cannot be read, which a page opened from now on must read anew. */
+    readonly renewed: readonly string[];
+    /** Whether the file can be read, when that changed. */
+    readonly read?: StoryFileRead;
+};
 /** The patterns' modules a dev server served, with their story files indexed as it served them. */
 export type ServedPatterns = {
     /**
      * Keeps a pattern's module as it was served.
      *
      * @param id - the module's id.
-     * @param files - its story files, indexed.
+     * @param read - its story files.
      */
-    readonly keep: (id: string, files: readonly IndexedStoryFile[]) => void;
+    readonly keep: (id: string, read: StoryFilesRead) => void;
     /**
-     * The patterns' modules an edit of a story file changed (a story added or renamed, a title), which the open pages
-     * read once: the file alone is indexed again, not the pattern's every file. One that cannot be read yet (an edit
-     * half typed) changes nothing: its module shows the error, and the next edit is read again.
+     * What an edit of a story file changed; the file alone is indexed again, not the pattern's every file. An edit that
+     * leaves it unreadable (half typed) changes no list, so the frame that draws it keeps its story and draws the fix in
+     * place, whose index is then compared with the last one that could be read.
      *
      * @param file - the edited story file.
      */
-    readonly changedBy: (file: string) => readonly string[];
+    readonly edited: (file: string) => StoryFileEdit;
+    /**
+     * The patterns' modules that list a story file.
+     *
+     * @param file - the story file.
+     */
+    readonly listing: (file: string) => readonly string[];
 };
 /** The patterns' modules a dev server serves, kept to tell an edit that changes a list. */
 export declare const servedPatterns: () => ServedPatterns;
 /**
- * The plugin's hooks for a story file's edit: the file accepts it on a dev server, and an edit that changes a pattern's
- * list (a story added, renamed, a title) reloads the pages, which read the list once. A story file a frame loads is
+ * The plugin's hooks for a story file's edit: the file accepts it on a dev server, an edit that changes a pattern's
+ * list (a story added, renamed, a title) reloads the pages, which read the list once, and one that changes whether the
+ * file can be read tells them. A story file a frame loads is
  * followed closely (`closeWatch.ts`), and the late report of an edit of any file the close watch handed on already is
  * dropped, so an edit is drawn once.
  *
  * @param isServing - whether a dev server runs whose framework draws an edited story file in place.
- * @param changedFilesModules - the patterns' modules the edit changed.
+ * @param served - what the edit changed, and the modules that list the file.
  * @param watching - the dev server's close watch.
+ * @param scripts - the project's other scripts that do not parse: an edit that breaks or fixes one renews every
+ * pattern's module, which names them, and tells the pages as a story file's does.
  */
-export declare const storyFileHotHooks: (isServing: () => boolean, changedFilesModules: (file: string) => readonly string[], watching: Pick<CloseWatch, "follow" | "isLateReport">) => Pick<Plugin, "transform" | "hotUpdate">;
+export declare const storyFileHotHooks: (isServing: () => boolean, served: Pick<ServedPatterns, "edited" | "listing">, watching: Pick<CloseWatch, "follow" | "isLateReport">, scripts?: Pick<ScriptProblems, "edited">) => Pick<Plugin, "transform" | "hotUpdate">;

package/dist/src/vite/hotSnippets.js

@@ -1,5 +1,5 @@
 import { codeLiteral } from "../codeLiteral.js";
-import { RENEWED_MODULE_EVENT, STORY_FILE_EVENT } from "../hotModules.js";
+import { RENEWED_MODULE_EVENT, STORY_FILE_EVENT, STORY_FILE_READ_EVENT } from "../hotModules.js";
 import { STORY_FILE } from "./autoTitle.js";
 import { FILES_PREFIX } from "./pluginModules.js";
 import { storyFileIndex, storyFilesGroupOf } from "./storyFilesModule.js";
@@ -84,60 +84,151 @@ export const renewedModule = (id, module, queries, isServing) => isServing && qu
     ? { ...module, code: `${module.code}\n${renewedModuleHot(id)}` }
     : module;
 /**
- * What a pattern's files module runs: it takes the edits its story files hand on, which change nothing it holds. An
- * edit that changes its list reloads the pages from the server, and its pages keep the module they read.
+ * What a pattern's files module runs: it takes the edits its story files hand on, which change nothing it holds, as
+ * an edit that changes its list reloads the pages from the server. What an edit says of a file that cannot be read
+ * goes on to the page, unless it is the fix of a file the page was served without: it has no story to redraw, so it
+ * reloads to list them. Those files are kept in the module's hot data, so a version served after the page's first does not count.
+ *
+ * @param refused - the story files the module was served without.
  */
-export const FILES_MODULE_HOT = "if (import.meta.hot) import.meta.hot.accept();";
+export const filesModuleHot = (refused) => [
+    "if (import.meta.hot) {",
+    "  import.meta.hot.accept();",
+    `  import.meta.hot.data.forgebookRefused ??= ${codeLiteral(refused.map(({ file }) => file))};`,
+    `  import.meta.hot.on(${codeLiteral(STORY_FILE_READ_EVENT)}, (read) => {`,
+    "    if (read.problem === undefined && import.meta.hot.data.forgebookRefused.includes(read.file)) window.location.reload();",
+    `    else window.dispatchEvent(new CustomEvent(${codeLiteral(STORY_FILE_READ_EVENT)}, { detail: read }));`,
+    "  });",
+    "}"
+].join("\n");
 /**
- * A story file's index as an edit left it; a message when it cannot be read (an editor writes it anew in place).
+ * A story file's index as an edit left it, or why it cannot be read; none when its text cannot be had (an editor writes
+ * it anew in place), which says nothing yet.
  *
  * @param root - the declaring module's folder.
- * @param pattern - the pattern.
- * @param key - the file's path relative to the declaring module.
+ * @param served - the file.
  */
-const readIndex = (root, pattern, key) => {
+const readIndex = (root, served) => {
     try {
-        return storyFileIndex(root, pattern, key);
+        return storyFileIndex(root, served.pattern, served.key);
     }
-    catch (error) {
-        return error instanceof Error ? error.message : String(error);
+    catch {
+        return undefined;
     }
 };
+/**
+ * What a pattern's module keeps of its story files: as read now, a problem known before staying until an edit changes it
+ * (`edited` tells the pages), and a file that cannot be read keeping the index of its last good read.
+ *
+ * @param read - the story files.
+ * @param before - the files as last known.
+ */
+const servedFiles = ({ files, refused }, before) => {
+    const served = new Map();
+    for (const { key, pattern, file, index } of files) {
+        const problem = before?.get(file)?.problem;
+        served.set(file, { key, pattern, index: JSON.stringify(index), problem });
+    }
+    for (const { key, pattern, file, problem } of refused) {
+        const known = before?.get(file);
+        served.set(file, {
+            key,
+            pattern,
+            index: known?.index,
+            problem: known === undefined ? problem : known.problem
+        });
+    }
+    return served;
+};
+/**
+ * What an edit of a story file changed in one pattern's module, noted in what the module keeps.
+ *
+ * @param id - the module's id.
+ * @param files - what it keeps.
+ * @param file - the edited file, in Vite's form.
+ */
+const editedIn = (id, files, file) => {
+    const kept = files.get(file);
+    if (kept === undefined)
+        return { isChanged: false };
+    const index = readIndex(storyFilesGroupOf(id.slice(FILES_PREFIX.length)).root, kept);
+    if (index === undefined)
+        return { isChanged: false };
+    const problem = typeof index === "string" ? index : undefined;
+    const isChanged = typeof index !== "string" && JSON.stringify(index) !== kept.index;
+    if (problem === kept.problem)
+        return { isChanged };
+    files.set(file, { ...kept, problem });
+    return { isChanged, read: { file, ...(problem === undefined ? {} : { problem }) } };
+};
 /** The patterns' modules a dev server serves, kept to tell an edit that changes a list. */
 export const servedPatterns = () => {
-    // by group, each story file as served: its key, the pattern that lists it, its index
+    // by group, each story file as last known
     const served = new Map();
     return {
-        keep: (id, files) => {
-            served.set(id, new Map(files.map((file) => [
-                file.file,
-                { key: file.key, pattern: file.pattern, index: JSON.stringify(file.index) }
-            ])));
+        keep: (id, read) => {
+            served.set(id, servedFiles(read, served.get(id)));
         },
-        changedBy: (file) => [...served]
-            .filter(([id, files]) => {
+        edited: (file) => {
             // in Vite's form, as the served files are kept: a Windows path reaches here either way
-            const kept = files.get(VITE_PATHS.normalize(file));
-            if (kept === undefined)
-                return false;
-            const { root } = storyFilesGroupOf(id.slice(FILES_PREFIX.length));
-            const index = readIndex(root, kept.pattern, kept.key);
-            return typeof index !== "string" && JSON.stringify(index) !== kept.index;
-        })
-            .map(([id]) => id)
+            const edited = VITE_PATHS.normalize(file);
+            const reads = [...served].map(([id, files]) => ({ id, ...editedIn(id, files, edited) }));
+            const read = reads.find((each) => each.read !== undefined)?.read;
+            return {
+                changed: reads.filter((each) => each.isChanged).map(({ id }) => id),
+                renewed: reads.filter((each) => each.read !== undefined).map(({ id }) => id),
+                ...(read === undefined ? {} : { read })
+            };
+        },
+        listing: (file) => {
+            const listed = VITE_PATHS.normalize(file);
+            return [...served].filter(([, files]) => files.has(listed)).map(([id]) => id);
+        }
     };
 };
 /**
- * The plugin's hooks for a story file's edit: the file accepts it on a dev server, and an edit that changes a pattern's
- * list (a story added, renamed, a title) reloads the pages, which read the list once. A story file a frame loads is
+ * Renews modules, so the next page that imports them reads them anew: Vite stops at a story file that takes its own
+ * edit, and the modules that import it stay as they were served.
+ *
+ * @param environment - the client's environment.
+ * @param ids - the modules.
+ */
+const invalidated = (environment, ids) => {
+    for (const id of ids) {
+        const module = environment.moduleGraph.getModuleById(id);
+        if (module !== undefined)
+            environment.moduleGraph.invalidateModule(module);
+    }
+};
+/**
+ * Tells the environments a script now parses or no longer does: every pattern's module, which names it among the
+ * catalogue's problems, is renewed for the next page and the next answer to a tool, and the open pages name it or stop.
+ *
+ * @param environments - the dev server's environments.
+ * @param read - whether the script parses now.
+ */
+const scriptRead = (environments, read) => {
+    for (const environment of environments) {
+        const patterns = [...environment.moduleGraph.idToModuleMap.keys()].filter((id) => id.startsWith(FILES_PREFIX));
+        invalidated(environment, patterns);
+        if (environment.name === "client")
+            environment.hot.send({ type: "custom", event: STORY_FILE_READ_EVENT, data: read });
+    }
+};
+/**
+ * The plugin's hooks for a story file's edit: the file accepts it on a dev server, an edit that changes a pattern's
+ * list (a story added, renamed, a title) reloads the pages, which read the list once, and one that changes whether the
+ * file can be read tells them. A story file a frame loads is
  * followed closely (`closeWatch.ts`), and the late report of an edit of any file the close watch handed on already is
  * dropped, so an edit is drawn once.
  *
  * @param isServing - whether a dev server runs whose framework draws an edited story file in place.
- * @param changedFilesModules - the patterns' modules the edit changed.
+ * @param served - what the edit changed, and the modules that list the file.
  * @param watching - the dev server's close watch.
+ * @param scripts - the project's other scripts that do not parse: an edit that breaks or fixes one renews every
+ * pattern's module, which names them, and tells the pages as a story file's does.
  */
-export const storyFileHotHooks = (isServing, changedFilesModules, watching) => ({
+export const storyFileHotHooks = (isServing, served, watching, scripts) => ({
     transform: {
         // a pattern's module is named after its pattern, which may end like a story file
         filter: { id: { include: STORY_FILE, exclude: VIRTUAL_ID } },
@@ -155,17 +246,24 @@ export const storyFileHotHooks = (isServing, changedFilesModules, watching) => (
         // the system's late report of an edit the close watch handed on already
         if (watching.isLateReport(this.environment.name, options.file))
             return [];
-        if (this.environment.name !== "client" || !STORY_FILE.test(options.file))
+        if (!STORY_FILE.test(options.file)) {
+            // read once for every environment: the first to hear of the edit renews them all
+            const read = scripts?.edited(options.file);
+            if (read !== undefined)
+                scriptRead(Object.values(options.server.environments), read);
             return undefined;
-        const changed = changedFilesModules(options.file);
-        if (changed.length === 0)
+        }
+        if (this.environment.name !== "client") {
+            // the server's modules answer tools and agents, each answer anew: they have no page to keep
+            invalidated(this.environment, served.listing(options.file));
             return undefined;
-        const graph = this.environment.moduleGraph;
-        for (const id of changed) {
-            const module = graph.getModuleById(id);
-            if (module !== undefined)
-                graph.invalidateModule(module);
         }
+        const { changed, renewed, read } = served.edited(options.file);
+        invalidated(this.environment, [...changed, ...renewed]);
+        if (read !== undefined)
+            this.environment.hot.send({ type: "custom", event: STORY_FILE_READ_EVENT, data: read });
+        if (changed.length === 0)
+            return undefined;
         this.environment.hot.send({ type: "full-reload" });
         return [];
     }