forgebook 0.3.2 → 0.4.0

package/dist/src/playTrace.d.ts

@@ -8,8 +8,8 @@
  *
  * @module
  */
-/** Where a play or one of its steps is. */
-export type PlayStatus = "running" | "passed" | "failed";
+/** Where a play or one of its steps is; `off`: the reader's switch kept it from running when the story opened. */
+export type PlayStatus = "running" | "passed" | "failed" | "off";
 /** One step a play named. */
 export type PlayStep = {
     /** What the step does, as the play named it. */
@@ -21,12 +21,29 @@ export type PlayStep = {
     /** Why it failed. */
     readonly error?: string;
 };
+/** One thing a play did through the tools its context hands it, in the Interactions tab's log. */
+export type PlayAction = {
+    /** What it did, as a call: `userEvent.click(<button> "Save")`. */
+    readonly label: string;
+    /** Where it is. */
+    readonly status: PlayStatus;
+    /** How long it took, in ms, once over. */
+    readonly ms?: number;
+    /** Why it failed. */
+    readonly error?: string;
+    /** The named step it ran in, its place in `steps`; none outside one. */
+    readonly step?: number;
+};
 /** A play's trace. */
 export type PlayTrace = {
     /** Where the play is. */
     readonly status: PlayStatus;
     /** Its named steps, in order. */
     readonly steps: readonly PlayStep[];
+    /** What it did through its context's tools, in order; none when it did nothing through them. */
+    readonly actions?: readonly PlayAction[];
+    /** What it waits to do next, while it is stepped through; none otherwise. */
+    readonly pausedAt?: string;
     /** How long it took, in ms, once over. */
     readonly ms?: number;
     /** Why it failed. */

package/dist/src/playTrace.js

@@ -9,10 +9,11 @@
  * @module
  */
 /** Whether a value is a status. */
-const isStatus = (value) => value === "running" || value === "passed" || value === "failed";
-/** Whether a record's optional `ms` and `error` have their types. */
+const isStatus = (value) => value === "running" || value === "passed" || value === "failed" || value === "off";
+/** Whether a record's optional `ms`, `error` and `pausedAt` have their types. */
 const hasOptionalEnd = (record) => (record["ms"] === undefined || typeof record["ms"] === "number") &&
-    (record["error"] === undefined || typeof record["error"] === "string");
+    (record["error"] === undefined || typeof record["error"] === "string") &&
+    (record["pausedAt"] === undefined || typeof record["pausedAt"] === "string");
 /** Whether a value is a step, as it arrives in a message. */
 const isStep = (value) => {
     if (typeof value !== "object" || value === null)
@@ -20,6 +21,8 @@ const isStep = (value) => {
     const record = { ...value };
     return typeof record["label"] === "string" && isStatus(record["status"]) && hasOptionalEnd(record);
 };
+/** Whether a value is a list of steps or actions, which share their shape. */
+const isStepList = (value) => Array.isArray(value) && value.every(isStep);
 /**
  * Whether a value is a play's trace, as it arrives in a message.
  *
@@ -29,6 +32,8 @@ export const isPlayTrace = (value) => {
     if (typeof value !== "object" || value === null)
         return false;
     const record = { ...value };
-    const steps = record["steps"];
-    return isStatus(record["status"]) && Array.isArray(steps) && steps.every(isStep) && hasOptionalEnd(record);
+    return (isStatus(record["status"]) &&
+        isStepList(record["steps"]) &&
+        (record["actions"] === undefined || isStepList(record["actions"])) &&
+        hasOptionalEnd(record));
 };

package/dist/src/plugin.d.ts

@@ -19,7 +19,7 @@
  */
 import type { FigmaLink } from "@forgebook/story-format/source";
 import type { LoadedBeforeEach, LoadedDecorator } from "./frame/storyModule.ts";
-import type { ViewSwitch } from "./switches.ts";
+import type { SwitchValue, ViewSwitch } from "./switches.ts";
 /**
  * A version of this contract. A plugin writes the number itself, not a constant of this package: a constant would read
  * as whichever Forgebook is installed, and no plugin could ever be refused.
@@ -62,8 +62,15 @@ export type PluginDocBlock = {
     /** The module that draws it, as a specifier the catalogue's folder resolves: it exports a `PluginView` as `view`. */
     readonly view: string;
 };
-/** A switch a plugin adds: a catalogue's, without the roles the catalogue itself reads, which stay the catalogue's. */
-export type PluginSwitch = Omit<ViewSwitch, "role">;
+/**
+ * A switch a plugin adds: a catalogue's, without the roles the catalogue itself reads, which stay the catalogue's. So do a
+ * value's `implies`, which would take another switch from the catalogue, and its `preview` and `sheet`, whose paths are read
+ * from the catalogue's folder.
+ */
+export type PluginSwitch = Omit<ViewSwitch, "role" | "values"> & {
+    /** Its values, in their order. */
+    readonly values: readonly Omit<SwitchValue, "implies" | "preview" | "sheet">[];
+};
 /** What a package gives a catalogue. */
 export type ForgebookPlugin = {
     /** The contract it is written for: the number, written out. */

package/dist/src/previewRelay.js

@@ -32,7 +32,7 @@ export const previewRelay = (frameAddress, title) => {
     const framesOrigin = new URL(frameAddress, window.location.href).origin;
     const frame = document.createElement("iframe");
     frame.title = title;
-    frame.style.cssText = "display:block;width:100%;height:100vh;border:0";
+    frame.style.cssText = "display:block;width:100%;height:100vh;border:0;color-scheme:light";
     const tell = (message) => {
         window.parent.postMessage(message, "*");
     };
@@ -46,6 +46,13 @@ export const previewRelay = (frameAddress, title) => {
             frame.src = frameAddress;
         }, reloadAfterMs);
     });
+    // the frame element takes the scheme the story's document draws in, or the browser paints an opaque canvas behind it
+    const followScheme = (data) => {
+        if (!("type" in data) || data.type !== "forgebook:scheme" || !("scheme" in data))
+            return;
+        if (data.scheme === "light" || data.scheme === "dark")
+            frame.style.colorScheme = data.scheme;
+    };
     window.addEventListener("message", (event) => {
         if (event.origin !== framesOrigin || event.source !== frame.contentWindow)
             return;
@@ -53,6 +60,7 @@ export const previewRelay = (frameAddress, title) => {
         if (typeof data !== "object" || data === null || !("type" in data))
             return;
         hasHeard = true;
+        followScheme(data);
         if (data.type === "forgebook:ready" || data.type === "forgebook:error")
             tell({ type: "forgebook:preview-ready" });
         if (data.type === "forgebook:size" &&

package/dist/src/printable.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A text from a project's files made safe to print or to hand an agent. Pure.
+ *
+ * @module
+ */
+/**
+ * A text from a project's files made safe to print: no control characters, which could rewrite a terminal's lines, and
+ * of a bounded length.
+ *
+ * @param text - the text.
+ */
+export declare const printable: (text: string) => string;

package/dist/src/printable.js

@@ -0,0 +1,22 @@
+/**
+ * A text from a project's files made safe to print or to hand an agent. Pure.
+ *
+ * @module
+ */
+/** The longest text taken from a project into a report, so a planted file cannot flood an agent's context. */
+const PRINTABLE_LENGTH = 500;
+/**
+ * A text from a project's files made safe to print: no control characters, which could rewrite a terminal's lines, and
+ * of a bounded length.
+ *
+ * @param text - the text.
+ */
+export const printable = (text) => {
+    const kept = [...text]
+        .filter((character) => {
+        const code = character.codePointAt(0) ?? 0;
+        return code >= 32 && (code < 127 || code > 159);
+    })
+        .join("");
+    return kept.length > PRINTABLE_LENGTH ? `${kept.slice(0, PRINTABLE_LENGTH)}…` : kept;
+};

package/dist/src/propsSignature.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The props a story file was written for, as a short signature `forgebook new` writes in the file and `changed` reads back:
+ * when the component's props no longer give the same signature, the file's args may pass a prop that is gone or miss one
+ * that is now required, and nothing else would say so (a framework ignores an unknown prop, and a new optional one is
+ * simply never shown).
+ *
+ * @remarks
+ * Pure, and the same on every system: the props' names, whether each is required, and their types as the docs extractor
+ * writes them, sorted by name, hashed with FNV-1a. A change of description or default leaves it alone, since the file's
+ * args do not depend on them. The type is the extractor's text: a change inside a named type a prop uses is not seen, and
+ * a version of the extractor that writes a type differently changes the signature, which `verify` then asks to confirm.
+ *
+ * @module
+ */
+import type { PropDocs } from "./componentDocs.ts";
+/** The comment's word, followed by `: ` and the signature. */
+export declare const PROPS_MARKER = "forgebook-props";
+/**
+ * The signature of a component's props.
+ *
+ * @param props - the props, as the docs extractor reads them.
+ * @returns eight hexadecimal digits.
+ */
+export declare const propsSignature: (props: readonly PropDocs[]) => string;
+/**
+ * The line `forgebook new` writes in a story file.
+ *
+ * @param signature - the props' signature.
+ */
+export declare const propsMarkerLine: (signature: string) => string;
+/**
+ * The signature a story file says it was written for.
+ *
+ * @param text - the story file's text.
+ * @returns the signature; none when the file has no marker line.
+ */
+export declare const writtenSignature: (text: string) => string | undefined;

package/dist/src/propsSignature.js

@@ -0,0 +1,40 @@
+/** The comment's word, followed by `: ` and the signature. */
+export const PROPS_MARKER = "forgebook-props";
+/** The marker line as `forgebook new` writes it, one per file, read back by its first words. */
+const MARKER_LINE = new RegExp(`^// ${PROPS_MARKER}: ([0-9a-f]{8})\\b`, "m");
+/**
+ * The FNV-1a hash of a text, as eight hexadecimal digits.
+ *
+ * @param text - the text.
+ */
+const fnv1a = (text) => {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+};
+/**
+ * The signature of a component's props.
+ *
+ * @param props - the props, as the docs extractor reads them.
+ * @returns eight hexadecimal digits.
+ */
+export const propsSignature = (props) => fnv1a(props
+    .map((prop) => `${prop.name}${prop.isRequired ? "" : "?"}:${prop.type}`)
+    .sort()
+    .join("\n"));
+/**
+ * The line `forgebook new` writes in a story file.
+ *
+ * @param signature - the props' signature.
+ */
+export const propsMarkerLine = (signature) => `// ${PROPS_MARKER}: ${signature} (the props these stories were written for; verify says when they change)`;
+/**
+ * The signature a story file says it was written for.
+ *
+ * @param text - the story file's text.
+ * @returns the signature; none when the file has no marker line.
+ */
+export const writtenSignature = (text) => MARKER_LINE.exec(text)?.[1];

package/dist/src/search.d.ts

@@ -8,12 +8,13 @@
  * half ones. A word is worth what it is worth where it counts most in the result (`searchMatch.ts`), so the ranking is
  * `findComponents`' with more places. A result that holds every word comes before one that does not, which says what it
  * missed. Everything is read from the tree and the index (`searchIndex.ts`), with no server, so the same code answers
- * in the page and on the dev server. Pure.
+ * in the page and on the dev server; the dev server also reads typos (`searchTypos.ts`), which the page leaves out to
+ * stay light. Pure.
  *
  * @module
  */
 import type { SearchIndex } from "./searchIndex.ts";
-import { type MarkedText } from "./searchMarks.ts";
+import { type MarkedQuery, type MarkedText } from "./searchMarks.ts";
 import { type SearchPlace } from "./searchMatch.ts";
 import { type StoryTree } from "./storyTree.ts";
 /** Where a result or a hit goes: a page of the catalogue, at a heading or a prop when it has one. */
@@ -110,8 +111,6 @@ type Field = {
     readonly labelWords: readonly string[];
     /** Its text's words. */
     readonly textWords: readonly string[];
-    /** Its name's and its text's words in order, each between spaces, as the words of a query are looked for in them. */
-    readonly sentences: readonly string[];
     /** Where it goes. */
     readonly target: SearchTarget;
 };
@@ -137,15 +136,52 @@ export type Searchable = {
  * @param indexes - each source's index, by its id: what it adds is found once it is there.
  */
 export declare const searchables: (tree: StoryTree, indexes: ReadonlyMap<string, SearchIndex>) => readonly Searchable[];
+/** The query, read. */
+export type Query = MarkedQuery & {
+    /** Its words as a sentence (`sentenceOf`), when there are several: copied from a page, it finds that page first. */
+    readonly sentence: string | undefined;
+};
 /** The most of a query that is read: a page pasted by mistake must not hold the tab for seconds. */
 export declare const MAX_QUERY = 200;
 /**
- * What a query finds.
+ * A query's words and phrase.
+ *
+ * @param typed - what was typed.
+ */
+export declare const queryOf: (typed: string) => Query;
+/** A found thing, before its hits are worked out. */
+export type Scored = {
+    /** The thing. */
+    readonly found: Searchable;
+    /** Its score. */
+    readonly score: number;
+    /** The words it holds. */
+    readonly matched: readonly string[];
+    /** The words it does not. */
+    readonly missed: readonly string[];
+};
+/**
+ * Everything that holds a word of the query, the result holding most of it first.
+ *
+ * @param all - everything that can be found (`searchables`).
+ * @param read - the query, read (`queryOf`).
+ */
+export declare const scoredAll: (all: readonly Searchable[], read: Query) => Scored[];
+/**
+ * The answer from what was found.
  *
  * @remarks
  * Where something holds every word, what holds much less is left out: `the` must not bring the whole catalogue along
  * with a sentence copied from a page. Nothing holding every word, the nearest are given, each saying what it missed.
  *
+ * @param found - what holds a word of the query, best first (`scoredAll`).
+ * @param read - the query, read.
+ * @param limits - how much of the answer to give.
+ */
+export declare const answerOf: (found: readonly Scored[], read: Query, limits: SearchLimits) => SearchAnswer;
+/**
+ * What a query finds, each word read as typed: `searchTypos.ts` reads a word nothing holds as a near name.
+ *
  * @param all - everything that can be found (`searchables`).
  * @param query - what was typed.
  * @param limits - how much of the answer to give.

package/dist/src/search.js

@@ -8,7 +8,8 @@
  * half ones. A word is worth what it is worth where it counts most in the result (`searchMatch.ts`), so the ranking is
  * `findComponents`' with more places. A result that holds every word comes before one that does not, which says what it
  * missed. Everything is read from the tree and the index (`searchIndex.ts`), with no server, so the same code answers
- * in the page and on the dev server. Pure.
+ * in the page and on the dev server; the dev server also reads typos (`searchTypos.ts`), which the page leaves out to
+ * stay light. Pure.
  *
  * @module
  */
@@ -51,7 +52,6 @@ const fieldOf = (kind, label, written, target) => {
         text,
         labelWords: label === undefined ? [] : labelWordsOf(label),
         textWords: [...new Set(wordsOf(text))],
-        sentences: [sentenceOf(label ?? ""), sentenceOf(text)],
         target
     };
 };
@@ -75,16 +75,52 @@ const sectionField = (section, target) => {
     const opened = section.anchor === undefined ? target : { ...target, anchor: section.anchor };
     return fieldOf(section.heading === undefined ? "text" : "heading", section.heading, section.text, opened);
 };
-/** What the search reads of a component. */
-const componentFields = (component, target, index) => [
+/**
+ * What the search reads of each component from the tree, and of each component's index, kept as long as they are: the
+ * tree is read once, and the index's groups arrive one after another, which must not read the tree again each time.
+ */
+const TREE_FIELDS = new WeakMap();
+const INDEX_FIELDS = new WeakMap();
+/** A value made once per key and owner, kept while the owner is. */
+const cachedIn = (cache, owner, key, make) => {
+    const byKey = cache.get(owner) ?? new Map();
+    cache.set(owner, byKey);
+    const known = byKey.get(key);
+    if (known !== undefined)
+        return known;
+    const made = make();
+    byKey.set(key, made);
+    return made;
+};
+/** What the search reads of a component in the tree: its name, its place, its search words and its stories. */
+const treeFields = (component, target) => cachedIn(TREE_FIELDS, component, target.id, () => [
     fieldOf("name", component.name, "", target),
     fieldOf("title", component.title.split("/").slice(0, -1).join(" "), "", target),
-    ...component.keywords.map((keyword) => fieldOf("keyword", keyword, "", target)),
-    ...(index?.lead === undefined ? [] : [fieldOf("description", undefined, index.lead, target)]),
-    ...(index?.props ?? []).map(({ name, text, part, isEvent }) => fieldOf(isEvent === true ? "event" : "prop", name, text, { ...target, anchor: propAnchor(name, part) })),
-    ...component.stories.map((story) => fieldOf("story", story.name, story.description ?? "", { kind: "story", id: story.id })),
-    ...(index?.sections ?? []).map((section) => sectionField(section, target))
-];
+    ...component.keywords.map((keyword) => fieldOf("keyword", keyword, "", target))
+]);
+/** What the search reads of a component's stories. */
+const storyFields = (component, target) => cachedIn(TREE_FIELDS, component, `${target.id}\nstories`, () => component.stories.map((story) => fieldOf("story", story.name, story.description ?? "", { kind: "story", id: story.id })));
+/** What a component's index adds: its lead and props, and the sections of its docs. */
+const indexFields = (index, target) => cachedIn(INDEX_FIELDS, index, target.id, () => ({
+    lead: [
+        ...(index.lead === undefined ? [] : [fieldOf("description", undefined, index.lead, target)]),
+        ...(index.props ?? []).map(({ name, text, part, isEvent }) => fieldOf(isEvent === true ? "event" : "prop", name, text, {
+            ...target,
+            anchor: propAnchor(name, part)
+        }))
+    ],
+    sections: (index.sections ?? []).map((section) => sectionField(section, target))
+}));
+/** What the search reads of a component. */
+const componentFields = (component, target, index) => {
+    const added = index === undefined ? undefined : indexFields(index, target);
+    return [
+        ...treeFields(component, target),
+        ...(added?.lead ?? []),
+        ...storyFields(component, target),
+        ...(added?.sections ?? [])
+    ];
+};
 /** A component, read for the search. */
 const searchableComponent = (source, familyName, groupName, component, index) => {
     const target = { kind: "component", id: componentId(source.id, component.title) };
@@ -134,8 +170,12 @@ export const searchables = (tree, indexes) => tree.sources.flatMap((source) => {
 const NEAR_SHARE = 0.75;
 /** The most of a query that is read: a page pasted by mistake must not hold the tab for seconds. */
 export const MAX_QUERY = 200;
-/** A query's words and phrase. */
-const queryOf = (typed) => {
+/**
+ * A query's words and phrase.
+ *
+ * @param typed - what was typed.
+ */
+export const queryOf = (typed) => {
     const query = typed.slice(0, MAX_QUERY);
     const words = wordsOf(query);
     const isSeveral = words.length > 1;
@@ -150,8 +190,22 @@ const isHeldIn = (words, word) => {
     const meanings = meaningsOf(word);
     return words.some((held) => wordMatch(held, word, meanings) !== undefined);
 };
+/**
+ * Each field's name and text as sentences (`sentenceOf`), made the first time a query of several words asks: most
+ * queries are one word, and making them for every field of a large catalogue is most of the first search's time.
+ */
+const SENTENCES = new WeakMap();
 /** Whether a field holds a query's sentence, in its name or its text. */
-const holdsSentence = (field, sentence) => sentence !== undefined && field.sentences.some((each) => each.includes(sentence));
+const holdsSentence = (field, sentence) => {
+    if (sentence === undefined)
+        return false;
+    let sentences = SENTENCES.get(field);
+    if (sentences === undefined) {
+        sentences = [sentenceOf(field.label ?? ""), sentenceOf(field.text)];
+        SENTENCES.set(field, sentences);
+    }
+    return sentences.some((each) => each.includes(sentence));
+};
 /** How a thing answers the query; none when it holds no word of it. */
 const scored = (found, { words, sentence }) => {
     const worths = words.map((word) => ({ word, worth: worthOf(found.parts, word) }));
@@ -239,23 +293,28 @@ const resultOf = ({ found, score, matched, missed }, query, limit) => {
     };
 };
 /**
- * What a query finds.
+ * Everything that holds a word of the query, the result holding most of it first.
+ *
+ * @param all - everything that can be found (`searchables`).
+ * @param read - the query, read (`queryOf`).
+ */
+export const scoredAll = (all, read) => all
+    .flatMap((each) => scored(each, read) ?? [])
+    .toSorted((first, second) => first.missed.length - second.missed.length ||
+    second.score - first.score ||
+    first.found.name.localeCompare(second.found.name));
+/**
+ * The answer from what was found.
  *
  * @remarks
  * Where something holds every word, what holds much less is left out: `the` must not bring the whole catalogue along
  * with a sentence copied from a page. Nothing holding every word, the nearest are given, each saying what it missed.
  *
- * @param all - everything that can be found (`searchables`).
- * @param query - what was typed.
+ * @param found - what holds a word of the query, best first (`scoredAll`).
+ * @param read - the query, read.
  * @param limits - how much of the answer to give.
  */
-export const searchCatalogue = (all, query, limits) => {
-    const read = queryOf(query);
-    const found = all
-        .flatMap((each) => scored(each, read) ?? [])
-        .toSorted((first, second) => first.missed.length - second.missed.length ||
-        second.score - first.score ||
-        first.found.name.localeCompare(second.found.name));
+export const answerOf = (found, read, limits) => {
     const hasWhole = found.some((each) => each.missed.length === 0);
     const kept = found.filter((each) => !hasWhole || each.matched.length >= read.words.length * NEAR_SHARE);
     return {
@@ -263,3 +322,14 @@ export const searchCatalogue = (all, query, limits) => {
         total: kept.length
     };
 };
+/**
+ * What a query finds, each word read as typed: `searchTypos.ts` reads a word nothing holds as a near name.
+ *
+ * @param all - everything that can be found (`searchables`).
+ * @param query - what was typed.
+ * @param limits - how much of the answer to give.
+ */
+export const searchCatalogue = (all, query, limits) => {
+    const read = queryOf(query);
+    return answerOf(scoredAll(all, read), read, limits);
+};

package/dist/src/searchMatch.d.ts

@@ -6,7 +6,8 @@
  * The one place both searches take this from, so a person and an agent asking the same words get the same answer:
  * `forgebook find` ranks components with it (`vite/findComponent.ts`), the shell's search and `forgebook search` rank
  * everything else (`search.ts`). Pure, with no model: a lexical ranking is instant, works offline and gives the same
- * answer twice. Case and accents never count. Pure apart from a cache of what a word means.
+ * answer twice. Case and accents never count. Pure apart from a cache of what a word means. Reading a word nothing
+ * holds as a near name is `searchTypos.ts`'s, which the page's search leaves out.
  *
  * @module
  */
@@ -23,6 +24,8 @@ export declare const WEIGHTS: {
 };
 /** The places a word can be found in. */
 export type SearchPlace = keyof typeof WEIGHTS;
+/** Words designers and code use for the same thing, each group read as one. */
+export declare const SYNONYMS: readonly (readonly string[])[];
 /**
  * A text as the searches compare it: lower case, without accents.
  *

package/dist/src/searchMatch.js

@@ -6,7 +6,8 @@
  * The one place both searches take this from, so a person and an agent asking the same words get the same answer:
  * `forgebook find` ranks components with it (`vite/findComponent.ts`), the shell's search and `forgebook search` rank
  * everything else (`search.ts`). Pure, with no model: a lexical ranking is instant, works offline and gives the same
- * answer twice. Case and accents never count. Pure apart from a cache of what a word means.
+ * answer twice. Case and accents never count. Pure apart from a cache of what a word means. Reading a word nothing
+ * holds as a near name is `searchTypos.ts`'s, which the page's search leaves out.
  *
  * @module
  */
@@ -37,7 +38,7 @@ const STARTING_COST = 0.5;
 /** The shortest word that matches by its start: shorter ones match too much. */
 const MIN_PREFIX = 3;
 /** Words designers and code use for the same thing, each group read as one. */
-const SYNONYMS = [
+export const SYNONYMS = [
     ["dialog", "modal", "popup", "lightbox"],
     ["select", "dropdown", "picker", "combobox"],
     ["button", "cta"],
@@ -61,14 +62,34 @@ export const foldedText = (text) => text
     .normalize("NFD")
     .replace(/\p{Diacritic}/gu, "")
     .toLowerCase();
+/**
+ * The words of short texts read so far: names, story names and search words come back many times in a catalogue
+ * (`Primary`, `Default`), and reading each is most of what the first search does. Long texts are read once anyway.
+ */
+const WORDS = new Map();
+/** The longest text whose words are kept: a name or a title, not a page. */
+const MAX_KEPT_TEXT = 80;
+/** The most texts kept: past that the cache starts again, so a long session holds a bounded amount. */
+const MAX_KEPT_TEXTS = 20_000;
 /**
  * A text's words, lower case and without accents, a camel-case name split into its words.
  *
  * @param text - any text.
  */
-export const wordsOf = (text) => foldedText(text.replace(/(\p{Ll})(\p{Lu})/gu, "$1 $2"))
-    .split(/[^\p{L}\p{N}]+/u)
-    .filter((word) => word !== "");
+export const wordsOf = (text) => {
+    const known = WORDS.get(text);
+    if (known !== undefined)
+        return [...known];
+    const words = foldedText(text.replace(/(\p{Ll})(\p{Lu})/gu, "$1 $2"))
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter((word) => word !== "");
+    if (text.length <= MAX_KEPT_TEXT) {
+        if (WORDS.size >= MAX_KEPT_TEXTS)
+            WORDS.clear();
+        WORDS.set(text, words);
+    }
+    return [...words];
+};
 /** A word without its plural. */
 const singularOf = (word) => word.length > MIN_PREFIX && word.endsWith("s") ? word.slice(0, -1) : word;
 /** The meanings worked out so far: a search asks for them for every word of every text it marks. */