@stateward/plugin-errors 1.0.1 → 1.1.0

package/dist/plugin.d.ts

@@ -6,33 +6,6 @@ export declare function errors(): import("@stateward/core").PluginOf<"errors", {
             readonly description: "The branch for the other errors must use the error (rethrow it, wrap it, report it); a generic message alone does not count.";
         };
     }, "catch">;
-    readonly "catch-without-intent": import("@stateward/core").LazyRule<{
-        readonly loggers: {
-            readonly kind: "strings";
-            readonly default: readonly ["console", "logger", "log"];
-            readonly description: "Objects whose every method only logs (globs like *Logger): a catch that only calls them swallows the error.";
-        };
-        readonly logMethods: {
-            readonly kind: "strings";
-            readonly default: readonly ["error", "warn", "info", "debug"];
-            readonly description: "Method names that only log, on any object (`Sentry.captureException` is not one).";
-        };
-        readonly logFunctions: {
-            readonly kind: "strings";
-            readonly default: readonly [];
-            readonly description: "Plain functions of your own that only log, like logError (globs allowed).";
-        };
-        readonly edgeHelpers: {
-            readonly kind: "strings";
-            readonly default: readonly [];
-            readonly description: "Your functions that report an error where it ends (to a service, to the user): a catch that calls one is handled, like reportAndShow (globs allowed). Sentry, Bugsnag and Datadog are known without it.";
-        };
-        readonly swallowHelpers: {
-            readonly kind: "strings";
-            readonly default: readonly [];
-            readonly description: "Functions that mark an error as ignored on purpose, like ignoreError (globs allowed): a catch that calls one is not reported.";
-        };
-    }, "catch">;
     readonly "finally-can-throw": import("@stateward/core").LazyRule<{
         readonly severities: {
             readonly kind: "severities";

package/dist/plugin.js

@@ -7,7 +7,6 @@ import { RULES } from "./rules.meta.js";
 /** Each rule's module, imported the first time the rule is on. */
 const load = {
     catchHidesUnexpected: moduleLoader(() => import("./catch-hides-unexpected.js")),
-    catchWithoutIntent: moduleLoader(() => import("./catch-without-intent.js")),
     finallyCanThrow: moduleLoader(() => import("./finally-can-throw.js")),
     catchMissesError: moduleLoader(() => import("./catch-misses-error.js")),
     throwsDocMismatch: moduleLoader(() => import("./throws-doc-mismatch.js")),
@@ -20,10 +19,9 @@ const load = {
 export function errors() {
     return definePlugin({
         name: "errors",
-        description: "Errors are handled where they can happen: nothing swallowed, nothing lost in finally, no Result dropped.",
+        description: "Errors are handled where they can happen: none ignored, none replaced in `finally`, no `Result` dropped.",
         rules: {
             "catch-hides-unexpected": lazyRule(RULES["catch-hides-unexpected"], load.catchHidesUnexpected, (module) => module.catchHidesUnexpected),
-            "catch-without-intent": lazyRule(RULES["catch-without-intent"], load.catchWithoutIntent, (module) => module.catchWithoutIntent),
             "finally-can-throw": lazyRule(RULES["finally-can-throw"], load.finallyCanThrow, (module) => module.finallyCanThrow),
             "catch-misses-error": lazyRule(RULES["catch-misses-error"], load.catchMissesError, (module) => module.catchMissesError),
             "throws-doc-mismatch": lazyRule(RULES["throws-doc-mismatch"], load.throwsDocMismatch, (module) => module.throwsDocMismatch),

package/dist/react/boundaries.d.ts

@@ -74,10 +74,10 @@ export declare function throwsOf(summaries: ReadonlyMap<string, Json>): Readonly
 /** The pack's view of the app's render tree, built once per summaries map. */
 export declare function modelOf(summaries: ReadonlyMap<string, Json>): Model;
 /** The line every boundary hover ends with: what no boundary ever catches. */
-export declare const NOT_CAUGHT = "not caught here: errors in event handlers and async code";
+export declare const NOT_CAUGHT = "not caught by a boundary: errors in event handlers and async code";
 /**
- * On a boundary's tag: `catches: NotFoundError (via <UserPage> → useUser) | others stateward
- * cannot see (from …)`, then `NOT_CAUGHT`. Undefined when `offset` is on no boundary's tag.
+ * On a boundary's tag: `catches: NotFoundError (via <UserPage> → useUser) | others not known
+ * (from …)`, then `NOT_CAUGHT`. Undefined when `offset` is on no boundary's tag.
  */
 export declare function boundaryLines(model: Model, file: string, offset: number): string[] | undefined;
 //# sourceMappingURL=boundaries.d.ts.map

package/dist/react/boundaries.js

@@ -226,7 +226,7 @@ export function modelOf(summaries) {
                     location,
                     what: info.via === null
                         ? inEffect
-                            ? "this effect throws"
+                            ? "an effect throws"
                             : `\`${name}\` throws`
                         : `\`${info.via.text}\` can throw`,
                 });
@@ -343,10 +343,10 @@ export function modelOf(summaries) {
     return model;
 }
 /** The line every boundary hover ends with: what no boundary ever catches. */
-export const NOT_CAUGHT = "not caught here: errors in event handlers and async code";
+export const NOT_CAUGHT = "not caught by a boundary: errors in event handlers and async code";
 /**
- * On a boundary's tag: `catches: NotFoundError (via <UserPage> → useUser) | others stateward
- * cannot see (from …)`, then `NOT_CAUGHT`. Undefined when `offset` is on no boundary's tag.
+ * On a boundary's tag: `catches: NotFoundError (via <UserPage> → useUser) | others not known
+ * (from …)`, then `NOT_CAUGHT`. Undefined when `offset` is on no boundary's tag.
  */
 export function boundaryLines(model, file, offset) {
     const element = model.byFile.get(file)?.find((one) => offset >= one.at[0] && offset < one.at[1]);
@@ -364,7 +364,7 @@ export function boundaryLines(model, file, offset) {
         ? [...names, unknownText(caught.unknowns, caught.more)]
         : names;
     return [
-        parts.length === 0 ? "catches nothing stateward can see" : `catches: ${parts.join(" | ")}`,
+        parts.length === 0 ? "catches nothing known" : `catches: ${parts.join(" | ")}`,
         NOT_CAUGHT,
     ];
 }

package/dist/react/fallbacks.js

@@ -69,10 +69,10 @@ export function checkFallbacks(model, ignored, report) {
             }));
             related.push({
                 location: { file: chain.file, start: chain.at[0], end: chain.at[1] },
-                message: `\`${fallback.name}\` branches on the error here`,
+                message: `\`${fallback.name}\` branches on the error`,
             });
             report({
-                message: fitted((cut) => `\`${cut(fallback.name)}\` does not handle ${codeList(missing.map((one) => one.name), cut)}, which this boundary can catch`),
+                message: fitted((cut) => `\`${cut(fallback.name)}\` does not handle ${codeList(missing.map((one) => one.name), cut)}, which its boundary can catch`),
                 hint: hint(fallback, chain, catchName(first.id, classes), missing.length),
                 location: { file, start: fallback.at[0], end: fallback.at[1] },
                 related,

package/dist/refactors.d.ts

@@ -1,7 +1,7 @@
 import type { EditorContributions } from "@stateward/core";
 type CodeActions = NonNullable<EditorContributions["codeActions"]>;
 /** The title of the refactoring that wraps a catch-all for the errors its `try` can throw. */
-export declare const HANDLE_KNOWN_TITLE = "Handle the known errors here, rethrow the rest";
+export declare const HANDLE_KNOWN_TITLE = "Handle the known errors, rethrow the rest";
 /**
  * On a `catch (e)` with no `instanceof` branches, whose `try` can throw at least one error class
  * stateward can name and whose body does not already throw: wraps the body as

package/dist/refactors.js

@@ -4,7 +4,7 @@ import { catchName } from "./inference/format.js";
 import { analyse } from "./inference/solve.js";
 import { factSummaries } from "./inlay.js";
 /** The title of the refactoring that wraps a catch-all for the errors its `try` can throw. */
-export const HANDLE_KNOWN_TITLE = "Handle the known errors here, rethrow the rest";
+export const HANDLE_KNOWN_TITLE = "Handle the known errors, rethrow the rest";
 /**
  * On a `catch (e)` with no `instanceof` branches, whose `try` can throw at least one error class
  * stateward can name and whose body does not already throw: wraps the body as

package/dist/render-throw-without-boundary.js

@@ -7,73 +7,88 @@ import { codeList, fitted, withExample } from "./text.js";
 export const GROUP = "render";
 const EXPLAIN = `# errors/render-throw-without-boundary
 
-A component that can throw a known error while rendering has an error boundary above it.
+An error thrown while rendering, with no error boundary above the component, unmounts the whole React tree and leaves a blank page.
 
-## Why
+\`\`\`tsx example-bad
+import { createRoot } from "react-dom/client";
 
-When a component throws while React renders it, or in one of its effects, React unmounts everything up to the nearest error boundary. With no boundary above, the whole app goes blank. A \`<UserPage>\` whose \`useUser\` throws \`NotFoundError\` for a wrong id takes the menu, the header and every other route down with it, where a boundary could have shown "this user does not exist".
+class NotFoundError extends Error {}
 
-## When to use it
+function UserPage({ id }: { id: string }) {
+  if (id === "") throw new NotFoundError("no such user");
+  return <h1>User {id}</h1>;
+}
 
-Use it in React apps whose code throws its own error classes. It is a core rule, a warning in every preset: whether a page should handle an error itself or let a boundary do it is your call. If every throw in render is a bug you want to see crash in development, turn it off.
+function App() {
+  return (
+    <main>
+      <nav>Menu</nav>
+      <UserPage id={location.hash.slice(1)} />
+    </main>
+  );
+}
 
-## What it catches
+createRoot(document.body).render(<App />);
+\`\`\`
 
-A place that renders a component which can throw a known error while rendering, with no error boundary above it on the way from your entry point (\`createRoot(…).render(…)\` or \`hydrateRoot\`). The component counts what its body and its hooks throw, what its \`useEffect\` and \`useLayoutEffect\` callbacks throw, and what the components it renders outside a boundary throw. A boundary is react-error-boundary's \`<ErrorBoundary>\` (the \`boundaries\` option adds other packages' boundaries), or a class of yours with \`getDerivedStateFromError\` or \`componentDidCatch\`.
+Put an error boundary around the part that can fail, so the rest of the app stays:
 
-It is reported once, at the highest place where the boundary is missing, with the path down to the call that throws.
+\`\`\`tsx example-good
+import { createRoot } from "react-dom/client";
+import { ErrorBoundary } from "react-error-boundary";
 
-A boundary around the whole app (the one that wraps the tree at \`createRoot(…).render(…)\`) does not count: it catches the error, but the whole app is replaced by its fallback, which is rarely what you want for one page. The finding is then at the highest place below it that renders the component that throws. If an app-wide fallback is what you want, set \`rootBoundaryCounts\` to \`true\`: the rule then says nothing for an app with a boundary at its root, and \`stateward plan\` says so (\`silent: your app's root has an error boundary\`).
+class NotFoundError extends Error {}
 
-Two kinds of throw are left out, since they name a programming mistake of the caller rather than a failure to show: the usual check in a context hook (\`if (!ctx) throw new Error("useAuth must be used within AuthProvider")\` on a value from \`useContext\`, or a comparison with a "missing" constant declared at the top of the file), and a check on what the caller passed when its type already rules the value out (\`props.title === undefined\` with \`title: string\`, a missing value from a context hook). A check on an optional prop or a parameter that can be \`undefined\` (\`title?: string\`, \`useLabel(label: string | undefined)\`) counts: any caller can leave it out, so it is a failure to show. A throw on a truthy value (\`if (error) throw error\`) or on a comparison (\`id === ""\`) still counts. Set \`skipContextGuards\` or \`skipInputGuards\` to \`false\` to count those too.
+function UserPage({ id }: { id: string }) {
+  if (id === "") throw new NotFoundError("no such user");
+  return <h1>User {id}</h1>;
+}
 
-### Bad
+function App() {
+  return (
+    <main>
+      <nav>Menu</nav>
+      <ErrorBoundary fallback={<p>This user does not exist.</p>}>
+        <UserPage id={location.hash.slice(1)} />
+      </ErrorBoundary>
+    </main>
+  );
+}
 
-\`\`\`tsx
-// useUser throws NotFoundError for an id it does not know.
-createRoot(root).render(<App />); // App renders <UserPage /> for /users/:id
+createRoot(document.body).render(<App />);
 \`\`\`
 
-### Good
+There is no quick fix: where the boundary goes, and what it shows, is your call.
 
-\`\`\`tsx
-createRoot(root).render(
-  <ErrorBoundary FallbackComponent={ErrorPage}>
-    <App />
-  </ErrorBoundary>,
-);
-\`\`\`
-
-### Fix
+## Why it matters
 
-Put an error boundary above the place the message names, or nearer to the component that throws (around one route). There is no quick fix: where the boundary goes, and what it shows, is your call.
+When a component throws while React renders it, or in one of its effects, React unmounts everything up to the nearest error boundary. With no boundary above, the whole app goes blank: a \`<UserPage>\` that throws \`NotFoundError\` for a wrong id takes the menu and every other route down with it, where a boundary could have shown "this user does not exist".
 
 ## What it does not catch
 
-- Errors in event handlers, timers and async code: a boundary never catches them, so they are not counted. \`async/handler-rejection-lost\` checks async handlers.
-- Errors stateward cannot see (a package it cannot read, a callback, a dynamic call): it is about known error classes, so these never make a finding. The hover on a boundary lists them.
-- An app with no \`createRoot(…).render(…)\` or \`hydrateRoot\` it can find: nothing is checked.
-- Routes in \`createBrowserRouter([...])\` route objects: React Router catches their errors itself (\`errorElement\`). \`memo\`, \`forwardRef\` and \`lazy\` components, and boundaries from other packages you have not listed in \`boundaries\`, are not followed.
-- An element passed to a function or stored in an object or array (\`showToast(<UserPage />)\`): where it renders cannot be followed, so it never makes a finding. An element held in a local \`const\` or \`let\` is checked where the variable is rendered.
-- A class that a \`try\` in the component may catch (with a test other than \`instanceof\`): it is not counted.
-- A throw that is not of a known error class (\`throw "no cart"\`), and a thrown promise (Suspense).
+It starts from your entry point (\`createRoot(…).render(…)\` or \`hydrateRoot\`) and reports, once, the highest place that renders a component which can throw a known error while rendering, with no boundary above; the related places show the path down to the throw. A component counts what its body and its hooks throw, what its \`useEffect\` and \`useLayoutEffect\` callbacks throw, and what the components it renders outside a boundary throw. A boundary is react-error-boundary's \`<ErrorBoundary>\` (the \`boundaries\` option adds other packages'), or a class of yours with \`getDerivedStateFromError\` or \`componentDidCatch\`. It is silent on:
+
+- errors in event handlers, timers and async code: a boundary never catches them (\`async/handler-rejection-lost\` checks async handlers);
+- errors stateward cannot see (a package it cannot read, a callback, a dynamic call): the hover on a boundary lists them;
+- an app with no \`createRoot(…).render(…)\` or \`hydrateRoot\` it can find: nothing is checked;
+- routes in \`createBrowserRouter([...])\` route objects (React Router catches their errors itself with \`errorElement\`); \`memo\`, \`forwardRef\` and \`lazy\` components; boundaries from packages not listed in \`boundaries\`;
+- an element passed to a function or stored in an object or array (\`showToast(<UserPage />)\`). An element held in a local \`const\` or \`let\` is checked where it is rendered;
+- a class that a \`try\` in the component may catch (with a test other than \`instanceof\`);
+- a throw that is not of a known error class (\`throw "no cart"\`), and a thrown promise (Suspense);
+- two kinds of throw that name a caller's programming mistake rather than a failure to show: the usual check in a context hook (\`if (!ctx) throw new Error("useAuth must be used within AuthProvider")\` on a value from \`useContext\`, or a comparison with a "missing" constant declared at the top of the file), and a check on a value the caller's type already rules out (\`props.title === undefined\` with \`title: string\`). A check on an optional prop or a parameter that can be \`undefined\` still counts, as does a throw on a truthy value (\`if (error) throw error\`) or a comparison (\`id === ""\`). Set \`skipContextGuards\` or \`skipInputGuards\` to \`false\` to count those too.
+
+## Getting the best from it
+
+A boundary around the whole app (the one that wraps the tree at \`createRoot(…).render(…)\`) does not count: it catches the error, but the whole app is replaced by its fallback, which is rarely what you want for one page. The finding is then at the highest place below it. If an app-wide fallback is what you want, set \`rootBoundaryCounts: true\`; \`stateward plan\` then says the rule is silent because your app's root has an error boundary.
 
 ## Turn it on or off
 
-In \`stateward.config.ts\`:
+Whether a page should handle an error itself or let a boundary do it is your call, so it is a warning. If every throw in render is a bug that should crash in development, turn it off.
 
 \`\`\`ts
 rules: { "errors/render-throw-without-boundary": "off" } // or "error"
-groups: { "errors/react": "off" } // the whole group
-rules: {
-  "errors/render-throw-without-boundary": [
-    "warning",
-    { boundaries: { "react-error-boundary": ["ErrorBoundary"], "@sentry/react": ["ErrorBoundary"] } },
-  ],
-} // Sentry's boundary counts too
-rules: {
-  "errors/render-throw-without-boundary": ["warning", { rootBoundaryCounts: true }],
-} // a boundary around the whole app is enough
+rules: { "errors/render-throw-without-boundary": ["warning", { boundaries: { "react-error-boundary": ["ErrorBoundary"], "@sentry/react": ["ErrorBoundary"] } }] }
+rules: { "errors/render-throw-without-boundary": ["warning", { rootBoundaryCounts: true }] } // a boundary around the whole app is enough
 \`\`\`
 `;
 /** At most this many notes; a longer path keeps its first steps and its last. */
@@ -86,12 +101,12 @@ function rootHeadline(component, names) {
     return fitted((cut) => `\`<${cut(component)}>\` can throw ${codeList(names, cut)} while rendering; only the app-wide boundary catches it`);
 }
 function rootHint(component) {
-    return withExample("the whole app is replaced; add a boundary around it, or set `rootBoundaryCounts` if that is what you want", ["<ErrorBoundary FallbackComponent={ErrorPage}>", `  <${component} />`, "</ErrorBoundary>"]);
+    return withExample("add a boundary around it, or set `rootBoundaryCounts` if replacing the whole app is intended:", ["<ErrorBoundary FallbackComponent={ErrorPage}>", `  <${component} />`, "</ErrorBoundary>"]);
 }
 /** The reason `plan` gives when a root boundary makes the rule silent. */
 export const ROOT_BOUNDARY_SILENT = "your app's root has an error boundary";
 function hint(component) {
-    return withExample("wrap it in an error boundary, here or nearer to what throws; for example with react-error-boundary:", ["<ErrorBoundary FallbackComponent={ErrorPage}>", `  <${component} />`, "</ErrorBoundary>"]);
+    return withExample("wrap it in an error boundary, at this render or nearer to what throws; for example with react-error-boundary:", ["<ErrorBoundary FallbackComponent={ErrorPage}>", `  <${component} />`, "</ErrorBoundary>"]);
 }
 /** The renders down from the site to the component that throws `cls`, then the call that throws it. */
 function pathNotes(model, site, cls) {
@@ -101,7 +116,7 @@ function pathNotes(model, site, cls) {
         return [];
     const notes = path.map((edge) => ({
         location: { file: edge.file, start: edge.render.at[0], end: edge.render.at[1] },
-        message: `\`<${edge.render.name}>\` is rendered here`,
+        message: `\`<${edge.render.name}>\` is rendered`,
     }));
     const thrower = path.at(-1)?.to ?? site.to;
     const brought = model.own(thrower).classes.get(cls);
@@ -138,11 +153,13 @@ function belowRoot(model, entry) {
 export const renderThrowWithoutBoundary = defineRule({
     kind: "project",
     meta: {
-        description: "A component that can throw a known error while rendering has an error boundary above it.",
+        description: "An error thrown while rendering, with no error boundary above the component, unmounts the whole React tree and leaves a blank page.",
+        summary: "a component that can throw a known error while rendering, with no error boundary above it",
         defaultSeverity: "warning",
         tier: "core",
         group: GROUP,
         needsJsDoc: true,
+        needsTypes: { library: "React", modules: ["react"] },
         options: {
             skipContextGuards: option.boolean({
                 default: true,

package/dist/result-ignored.js

@@ -3,62 +3,55 @@ import { defineRule, matchesName, option } from "@stateward/core";
 import { example, resultShapeOf, shorten } from "./result-type.js";
 const EXPLAIN = `# errors/result-ignored
 
-The Result of a call is checked or passed on, not dropped as a statement, after void or after await.
+A \`Result\` dropped as a statement discards its error, so a failed call looks the same as a successful one.
 
-## Why
-
-A \`Result\` is how a function says "this can fail". Call \`saveUser(user)\` as a statement and the answer is thrown away: nobody sees the error, and the code goes on as if the user was saved. The failure shows up later, as missing data.
-
-## When to use it
-
-Use it if your functions return a \`Result\` instead of throwing: your own, neverthrow's, or a \`safeParse\` result. It is on as an error in every preset. To drop a result on purpose, list the function in \`ignore\`, or set \`allowVoid\` and write \`void save()\`.
-
-## What it catches
+\`\`\`ts example-bad
+type Result<T> = { ok: true; value: T } | { ok: false; error: Error };
 
-A call whose value is a Result (or a \`Promise\` of one) that is dropped: written as a statement, after \`void\`, or after \`await\` on its own. A Result is recognised by its shape, so no library is needed:
+declare function saveUser(name: string): Promise<Result<void>>;
 
-- a union told apart by \`ok: true\` and \`ok: false\` (\`{ ok: true; value: T } | { ok: false; error: E }\`);
-- a union told apart by \`success: true\` and \`success: false\` (zod's \`safeParse\`);
-- a type with \`isOk()\` and \`isErr()\` methods (neverthrow);
-- a type the \`resultTypes\` option names (\`["Result", "Either"]\`), whatever its shape.
+export async function rename(name: string): Promise<void> {
+  await saveUser(name);
+}
+\`\`\`
 
-### Bad
+Check the result, or return it to your caller:
 
-\`\`\`ts
+\`\`\`ts example-good
 type Result<T> = { ok: true; value: T } | { ok: false; error: Error };
-declare function saveUser(user: User): Promise<Result<void>>;
-
-await saveUser(user);
-\`\`\`
 
-### Good
+declare function saveUser(name: string): Promise<Result<void>>;
 
-\`\`\`ts
-const saved = await saveUser(user);
-if (!saved.ok) return saved;
+export async function rename(name: string): Promise<Result<void>> {
+  const saved = await saveUser(name);
+  if (!saved.ok) return saved;
+  return { ok: true, value: undefined };
+}
 \`\`\`
 
-### Fix
+The message shows how, with your names and your Result's shape. There is no quick fix.
+
+## Why it matters
 
-Check the result, or return it to your caller; the message shows how with your names and your Result's shape. There is no quick fix.
+A \`Result\` is how a function says "this can fail". Call \`saveUser(name)\` as a statement and the answer is discarded: no code reads the error, and the code goes on as if the user was saved. The failure shows up later, as missing data.
 
 ## What it does not catch
 
-- A result that is assigned, returned, passed on, used in a condition or spread.
-- A Result of another shape (an \`Either\` with \`_tag\`, a tuple \`[error, value]\`), unless \`resultTypes\` names it.
-- A result dropped in a callback that returns nothing (\`items.forEach((item) => save(item))\`), or after \`&&\` or \`?.\`.
-- A result stored and never looked at (\`const saved = saveUser(user);\` with \`saved\` unused).
-- Reading \`.value\` without checking \`.ok\`.
+A Result is recognised by its shape, so no library is needed: a union told apart by \`ok: true\` and \`ok: false\`, or by \`success: true\` and \`success: false\` (zod's \`safeParse\`); a type with \`isOk()\` and \`isErr()\` methods (neverthrow); or a type the \`resultTypes\` option names. It is silent on:
+
+- a result that is assigned, returned, passed on, used in a condition or spread;
+- a Result of another shape (an \`Either\` with \`_tag\`, a tuple \`[error, value]\`), unless \`resultTypes\` names it;
+- a result dropped in a callback that returns nothing (\`items.forEach((item) => save(item))\`), or after \`&&\` or \`?.\`;
+- a result stored and never looked at (\`const saved = saveUser(name);\` with \`saved\` unused), and reading \`.value\` without checking \`.ok\`: \`errors/result-unchecked\` looks at those reads.
 
 ## Turn it on or off
 
-In \`stateward.config.ts\`:
+To drop a result on purpose, list the function in \`ignore\`, or set \`allowVoid\` and write \`void save()\`:
 
 \`\`\`ts
-rules: { "errors/result-ignored": "off" } // or "warning"
-groups: { "values/results": "off" } // the whole group
 rules: { "errors/result-ignored": ["error", { allowVoid: true }] } // \`void save()\` drops it on purpose
 rules: { "errors/result-ignored": ["error", { resultTypes: ["Either"] }] } // your own name for a Result
+rules: { "errors/result-ignored": "off" }
 \`\`\`
 `;
 /** The longest callee a headline shows before it is cut, and the longest call an example line shows. */
@@ -136,7 +129,7 @@ function checkStatement(statement, ctx) {
     ctx.report({
         node: statement,
         about: statement,
-        message: `the result of \`${calleeText(call, ctx)}(…)\` is dropped, so its error is never handled`,
+        message: `the \`Result\` of \`${calleeText(call, ctx)}(…)\` is dropped: its error is never handled`,
         hint: [
             "check it, or pass it on:",
             example([`const saved = ${promised ? "await " : ""}${callText};`, checkLine(shape)]),
@@ -146,7 +139,8 @@ function checkStatement(statement, ctx) {
 export const resultIgnored = defineRule({
     kind: "file",
     meta: {
-        description: "The Result of a call is checked or passed on, not dropped as a statement, after void or after await.",
+        description: "A `Result` dropped as a statement discards its error, so a failed call looks the same as a successful one.",
+        summary: "a `Result` dropped as a statement, after `void` or after `await`",
         defaultSeverity: "error",
         tier: "core",
         group: "callers",