@simmalugnt-se/payload-content-health 0.6.1 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.7.1
+
+- npm links to simmalugnt.se instead of the private source repository.
+
+## 0.7.0
+
+- Work-list rows have a dividing line and a hover band across the full width, so a row's "Fix with
+  the assistant" reads as part of that document on wide screens.
+- A document without a title in a language shows its title in the default language instead of its
+  id. The scan now reads the default language first.
+- A work-list link to a field inside a block (such as a rich text field) opens and selects that
+  field. On a fresh page load the form's rows were not there yet, so the link settled for the whole
+  blocks field and the assistant showed "Layout" as the selection.
+- New checks `seo.title-duplicate` and `seo.description-duplicate`: a meta title or description
+  another document uses in the same language, across collections, ignoring case and spacing. On by
+  default with `seo`; `seo.duplicates: false` turns them off. Both can be fixed many at once.
+- New check `links.broken` (Structure): internal links in the body, in rich text or relationship
+  fields, to documents that are deleted or not published. On by default with `content`;
+  `content.links: false` turns it off.
+
 ## 0.6.1
 
 - Work-list filters and field links update Next’s router state, so refresh preserves the current

package/README.md

@@ -38,29 +38,37 @@ Requires Payload `>=3.90.2 <4`, Next 16 and React 19. The widget uses Payload's
 
 ## Checks
 
-| Check                     | Option              | Finds                                          |
-| ------------------------- | ------------------- | ---------------------------------------------- |
-| `media.alt-missing`       | `altText`           | Images (`image/*`) with an empty alt field     |
-| `seo.title-missing`       | `seo`               | Empty meta title                               |
-| `seo.title-length`        | `seo`               | Meta title outside 50–60 characters            |
-| `seo.description-missing` | `seo`               | Empty meta description                         |
-| `seo.description-length`  | `seo`               | Meta description outside 100–150 characters    |
-| `seo.image-missing`       | `seo`               | No share image                                 |
-| `content.h1-missing`      | `content.headings`  | No H1 on the page                              |
-| `content.h1-multiple`     | `content.headings`  | More than one H1                               |
-| `content.heading-skip`    | `content.headings`  | A heading level skipped, e.g. H2 → H4          |
-| `content.thin`            | `content`           | Fewer than 300 words on the page               |
-| `content.untranslated`    | `translations`      | Localized text empty here, filled in default   |
+| Check                       | Option             | Finds                                          |
+| --------------------------- | ------------------ | ---------------------------------------------- |
+| `media.alt-missing`         | `altText`          | Images (`image/*`) with an empty alt field     |
+| `seo.title-missing`         | `seo`              | Empty meta title                               |
+| `seo.title-length`          | `seo`              | Meta title outside 50–60 characters            |
+| `seo.title-duplicate`       | `seo`              | Meta title another document also uses          |
+| `seo.description-missing`   | `seo`              | Empty meta description                         |
+| `seo.description-length`    | `seo`              | Meta description outside 100–150 characters    |
+| `seo.description-duplicate` | `seo`              | Meta description another document also uses    |
+| `seo.image-missing`         | `seo`              | No share image                                 |
+| `content.h1-missing`        | `content.headings` | No H1 on the page                              |
+| `content.h1-multiple`       | `content.headings` | More than one H1                               |
+| `content.heading-skip`      | `content.headings` | A heading level skipped, e.g. H2 → H4          |
+| `content.thin`              | `content`          | Fewer than 300 words on the page               |
+| `links.broken`              | `content`          | Internal links to deleted or unpublished pages |
+| `content.untranslated`      | `translations`     | Localized text empty here, filled in default   |
 
 `seo: true` reads the fields `@payloadcms/plugin-seo` adds (`meta.title`, `meta.description`,
 `meta.image`) with its default lengths. Point them elsewhere or turn single checks off:
 
+Duplicates are compared per language across every collection with SEO checks, ignoring case and
+spacing; each document that shares a text gets a finding naming the others. `duplicates: false`
+turns them off.
+
 ```ts
 pages: {
   seo: {
     description: "seo.summary",
     descriptionLength: { min: 80, max: 160 },
     image: false,
+    duplicates: false,
   },
 },
 media: { altText: { field: "altText" } },
@@ -82,12 +90,21 @@ pages: {
       cards: { heading: 2, "items.title": 3 },
     },
     minWords: 300, // or false
+    links: true, // or false
   },
 },
 ```
 
 Each page gets at most one finding per check: the first skipped level, the second H1.
 
+Internal links are the link nodes in rich text (`linkType: "internal"`) and relationship fields in
+the body, such as a link group's reference. A link group whose `type` or `linkType` is `custom`,
+`external` or `url` is an outside link, and the reference it keeps is skipped. A link is broken
+when its document is deleted or, in a collection with drafts, not published, since readers only see
+published pages. Targets are looked up without access control; only their title and whether they
+are published reach the list. Each page gets one finding per language, at the first broken link,
+with how many there are.
+
 ### Translations
 
 `translations: true` compares every language with the default one (Payload's
@@ -137,15 +154,15 @@ or block the unsaved form no longer has opens the nearest enclosing field instea
 
 With `@simmalugnt-se/payload-editor-assistant` (0.5.0 or later), rows in the collections the
 assistant works in also get "Fix with the assistant": the same link with a ready prompt that the
-assistant puts in its message box, with the length to aim for when a meta title or description is
-missing or off. The editor sends it. To write a missing alt text, the assistant needs to see the
+assistant offers as a task, with the length to aim for when a meta title or description is
+missing, off or shared with another document. The editor starts it. To write a missing alt text, the assistant needs to see the
 image: allow `media.view` on the media collection (0.6.0 or later). The packages do not import each
 other; they share these names:
 
 | Name                                         | Direction               | Meaning                                  |
 | -------------------------------------------- | ----------------------- | ---------------------------------------- |
 | `?field=<path>`                              | link → this plugin      | Form path to bring into view             |
-| `?ask=<prompt>`                              | link → assistant        | Prompt to put in the message box         |
+| `?ask=<prompt>`                              | link → assistant        | Prompt the assistant offers as a task    |
 | `content-health:select` (`detail: { path }`) | this plugin → assistant | The field brought into view is selected  |
 | `config.admin.custom.editorAssistant`        | assistant → this plugin | `{ collections, batchCollections }`      |
 | `?batch=…&batchScope=…&ask=…`                | link → assistant        | Documents to fix at once, and the prompt |
@@ -156,7 +173,7 @@ Both parameters are removed from the address once read. `editURL(adminRoute, fin
 ### Many documents at once
 
 Where the assistant allows `content.update` (0.11.0 or later), the sections for missing alt texts,
-meta titles or descriptions (missing or the wrong length) and missing translations offer "Fix N with
+meta titles or descriptions (missing, the wrong length or duplicated) and missing translations offer "Fix N with
 the assistant" next to their heading. It opens the assistant's panel beside the list with up to 20 of
 the documents in the section and one prompt for all of them; the assistant proposes a change per document, and
 the editor saves the ones they want. Saved documents drop out of the list. `batchURL(adminRoute,

package/dist/admin/ContentHealthFieldBridge.js

@@ -48,21 +48,31 @@ export function ContentHealthFieldBridge() {
         let cancelled = false;
         const current = () => !cancelled;
         void (async () => {
-            const { form, config, getEntityConfig, collectionSlug } = latest.current;
-            const fields = form.getFields();
-            const rootFields = collectionSlug
-                ? (getEntityConfig({ collectionSlug })?.fields ??
-                    [])
-                : [];
-            const lookup = {
-                blockTypeAt: (rowPath) => rowAt(fields, rowPath)?.blockType,
-                blocksBySlug: config.blocksMap,
+            const plan = () => {
+                const { form, config, getEntityConfig, collectionSlug } = latest.current;
+                const fields = form.getFields();
+                const rootFields = collectionSlug
+                    ? (getEntityConfig({ collectionSlug })
+                        ?.fields ?? [])
+                    : [];
+                const lookup = {
+                    blockTypeAt: (rowPath) => rowAt(fields, rowPath)?.blockType,
+                    blocksBySlug: config.blocksMap,
+                };
+                const target = revealTarget(path, (candidate) => planReveal(rootFields, candidate, lookup));
+                return { form, fields, target };
             };
-            const target = revealTarget(path, (candidate) => planReveal(rootFields, candidate, lookup));
-            if (!target) {
+            // The form's rows can arrive just after the page loads; until they do, a path in a block
+            // only plans as far as its blocks field. Wait for the whole path before settling for less.
+            const planned = (await waitFor(() => {
+                const attempt = plan();
+                return attempt.target?.path === path ? attempt : null;
+            })) ?? plan();
+            const { target } = planned;
+            if (!target || !current()) {
                 return;
             }
-            expandRows(target.steps, fields, form.dispatchFields);
+            expandRows(target.steps, planned.fields, planned.form.dispatchFields);
             const scope = await openSteps(target.steps, formRoot(anchorRef.current), current);
             if (!scope || !current()) {
                 return;

package/dist/categories.js

@@ -4,11 +4,19 @@ export const CATEGORY_CHECKS = {
     seo: [
         "seo.title-missing",
         "seo.title-length",
+        "seo.title-duplicate",
         "seo.description-missing",
         "seo.description-length",
+        "seo.description-duplicate",
         "seo.image-missing",
     ],
-    structure: ["content.h1-missing", "content.h1-multiple", "content.heading-skip", "content.thin"],
+    structure: [
+        "content.h1-missing",
+        "content.h1-multiple",
+        "content.heading-skip",
+        "content.thin",
+        "links.broken",
+    ],
     translations: ["content.untranslated"],
     accessibility: ["media.alt-missing"],
 };

package/dist/checks.d.ts

@@ -1,4 +1,5 @@
 import type { ContentSchema } from "./fields.ts";
+import type { LinksEntry, UniqueEntry } from "./site.ts";
 import type { CheckId, CollectionHealthOptions, Finding, HeadingLevels, LengthRange } from "./types.ts";
 export declare const SEO_DEFAULTS: {
     readonly title: "meta.title";
@@ -26,6 +27,19 @@ export type FieldRule = {
     path: string;
     range: LengthRange;
 }
+/** Compared with the other documents once all are read (`site.ts`). */
+ | {
+    check: CheckId;
+    kind: "unique";
+    path: string;
+    range?: LengthRange;
+}
+/** Internal links in the page body at `path`, followed once all documents are read. */
+ | {
+    check: CheckId;
+    kind: "links";
+    path: string;
+}
 /** Heading checks on the page body at `path`: missing H1, several H1s, skipped levels. */
  | {
     check: CheckId;
@@ -67,6 +81,10 @@ export type DocumentResult = {
      * for lengths. With the findings this gives each check's share of values in order.
      */
     checked: CheckId[];
+    /** Meta texts to compare across documents; they count as checked once compared. */
+    unique?: UniqueEntry[];
+    /** The body's internal links, to look up once every document is read. */
+    links?: LinksEntry[];
 };
 export declare function checkDocument(input: DocumentInput): DocumentResult;
 /** What the admin shows as the document's name; an image without alt text still needs one. */

package/dist/checks.js

@@ -3,6 +3,7 @@
  * locale at a time. Nothing here talks to Payload, so every check is testable on its own.
  */
 import { readContent } from "./content.js";
+import { readReferences } from "./references.js";
 export const SEO_DEFAULTS = {
     title: "meta.title",
     description: "meta.description",
@@ -24,6 +25,7 @@ export function rulesFor(options) {
         const image = seo.image ?? SEO_DEFAULTS.image;
         const titleLength = seo.titleLength ?? SEO_DEFAULTS.titleLength;
         const descriptionLength = seo.descriptionLength ?? SEO_DEFAULTS.descriptionLength;
+        const duplicates = seo.duplicates ?? true;
         if (title) {
             rules.push({
                 check: "seo.title-missing",
@@ -34,6 +36,14 @@ export function rulesFor(options) {
             if (titleLength) {
                 rules.push({ check: "seo.title-length", kind: "length", path: title, range: titleLength });
             }
+            if (duplicates) {
+                rules.push({
+                    check: "seo.title-duplicate",
+                    kind: "unique",
+                    path: title,
+                    ...(titleLength ? { range: titleLength } : {}),
+                });
+            }
         }
         if (description) {
             rules.push({
@@ -50,13 +60,21 @@ export function rulesFor(options) {
                     range: descriptionLength,
                 });
             }
+            if (duplicates) {
+                rules.push({
+                    check: "seo.description-duplicate",
+                    kind: "unique",
+                    path: description,
+                    ...(descriptionLength ? { range: descriptionLength } : {}),
+                });
+            }
         }
         if (image) {
             rules.push({ check: "seo.image-missing", kind: "required", path: image });
         }
     }
     if (options.content) {
-        const { field, headings, minWords = DEFAULT_MIN_WORDS } = options.content;
+        const { field, headings, minWords = DEFAULT_MIN_WORDS, links = true } = options.content;
         if (headings) {
             for (const check of ["content.h1-missing", "content.h1-multiple", "content.heading-skip"]) {
                 rules.push({ check: check, kind: "outline", path: field, headings });
@@ -65,6 +83,9 @@ export function rulesFor(options) {
         if (minWords !== false) {
             rules.push({ check: "content.thin", kind: "words", path: field, min: minWords });
         }
+        if (links) {
+            rules.push({ check: "links.broken", kind: "links", path: field });
+        }
     }
     return rules;
 }
@@ -74,6 +95,8 @@ export function checkDocument(input) {
     const status = doc._status === "draft" || doc._status === "published" ? doc._status : undefined;
     const findings = [];
     const checked = [];
+    const unique = [];
+    const links = [];
     const bodies = new Map();
     // The word count and the heading checks read the same body once, with the heading levels.
     const body = (rule) => {
@@ -108,7 +131,20 @@ export function checkDocument(input) {
             }
             continue;
         }
+        if (rule.kind === "links") {
+            const references = rule.content
+                ? readReferences(valueAt(doc, rule.path), rule.path, rule.content)
+                : [];
+            links.push({ base, references });
+            continue;
+        }
         const value = valueAt(doc, rule.path);
+        if (rule.kind === "unique") {
+            if (typeof value === "string" && !isEmpty(value)) {
+                unique.push({ base: rule.range ? { ...base, range: rule.range } : base, value });
+            }
+            continue;
+        }
         if (rule.kind === "required") {
             if (rule.imagesOnly && !isImage(doc)) {
                 continue;
@@ -129,7 +165,7 @@ export function checkDocument(input) {
             findings.push({ ...base, length: { ...rule.range, actual } });
         }
     }
-    return { findings, checked };
+    return { findings, checked, unique, links };
 }
 /** At most one finding per document and check, so counts are documents, like the other checks. */
 function checkBody(rule, { headings, words }, base) {

package/dist/content.js

@@ -16,6 +16,9 @@ export function readContent(value, root, schema, headingLevels = {}) {
         for (const field of schema.blocks[blockType] ?? []) {
             for (const { path, value: fieldValue } of fanOut(block, field.path)) {
                 const fullPath = `${root}.${index}.${path}`;
+                if (field.kind === "relationship") {
+                    continue;
+                }
                 if (field.kind === "richText") {
                     readLexical(fieldValue, fullPath, content);
                     continue;

package/dist/copy.d.ts

@@ -21,6 +21,9 @@ export declare const COPY: {
         readonly h1Count: (count: number) => string;
         readonly untranslated: (count: number) => string;
         readonly words: (actual: number, min: number) => string;
+        readonly duplicate: (titles: string[], more: number) => string;
+        readonly linkMissing: (count: number) => string;
+        readonly linkUnpublished: (target: string, count: number) => string;
         readonly problems: "Some checks could not run:";
     };
     readonly sv: {
@@ -38,6 +41,9 @@ export declare const COPY: {
         readonly h1Count: (count: number) => string;
         readonly untranslated: (count: number) => string;
         readonly words: (actual: number, min: number) => string;
+        readonly duplicate: (titles: string[], more: number) => string;
+        readonly linkMissing: (count: number) => string;
+        readonly linkUnpublished: (target: string, count: number) => string;
         readonly problems: "Några kontroller kunde inte köras:";
     };
 };

package/dist/copy.js

@@ -6,26 +6,32 @@ export const CHECK_LABELS = {
         "media.alt-missing": "Missing alt text",
         "seo.title-missing": "Missing meta title",
         "seo.title-length": "Meta title length",
+        "seo.title-duplicate": "Duplicate meta title",
         "seo.description-missing": "Missing meta description",
         "seo.description-length": "Meta description length",
+        "seo.description-duplicate": "Duplicate meta description",
         "seo.image-missing": "Missing share image",
         "content.h1-missing": "Missing H1",
         "content.h1-multiple": "More than one H1",
         "content.heading-skip": "Skipped heading levels",
         "content.thin": "Thin content",
+        "links.broken": "Broken internal links",
         "content.untranslated": "Not translated",
     },
     sv: {
         "media.alt-missing": "Alt-text saknas",
         "seo.title-missing": "Metatitel saknas",
         "seo.title-length": "Metatitelns längd",
+        "seo.title-duplicate": "Dubblerad metatitel",
         "seo.description-missing": "Metabeskrivning saknas",
         "seo.description-length": "Metabeskrivningens längd",
+        "seo.description-duplicate": "Dubblerad metabeskrivning",
         "seo.image-missing": "Delningsbild saknas",
         "content.h1-missing": "H1 saknas",
         "content.h1-multiple": "Fler än en H1",
         "content.heading-skip": "Överhoppade rubriknivåer",
         "content.thin": "Tunt innehåll",
+        "links.broken": "Trasiga interna länkar",
         "content.untranslated": "Saknar översättning",
     },
 };
@@ -59,6 +65,9 @@ export const COPY = {
         h1Count: (count) => `${count} H1s`,
         untranslated: (count) => `${count} ${count === 1 ? "field" : "fields"} not translated`,
         words: (actual, min) => `${actual} ${actual === 1 ? "word" : "words"}, aim for ${min}+`,
+        duplicate: (titles, more) => `Also on ${list("en", titles)}${more ? ` and ${more} more` : ""}`,
+        linkMissing: (count) => `Links to a deleted document${count > 1 ? `, and ${count - 1} more` : ""}`,
+        linkUnpublished: (target, count) => `Links to “${target}”, not published${count > 1 ? `, and ${count - 1} more` : ""}`,
         problems: "Some checks could not run:",
     },
     sv: {
@@ -76,6 +85,9 @@ export const COPY = {
         h1Count: (count) => `${count} H1:or`,
         untranslated: (count) => `${count} fält saknar översättning`,
         words: (actual, min) => `${actual} ord, sikta på minst ${min}`,
+        duplicate: (titles, more) => `Även på ${list("sv", titles)}${more ? ` och ${more} till` : ""}`,
+        linkMissing: (count) => `Länkar till ett borttaget dokument${count > 1 ? `, och ${count - 1} till` : ""}`,
+        linkUnpublished: (target, count) => `Länkar till ”${target}”, som inte är publicerad${count > 1 ? `, och ${count - 1} till` : ""}`,
         problems: "Några kontroller kunde inte köras:",
     },
 };
@@ -98,6 +110,8 @@ export const ASK = {
         "seo.description-length": ({ length }) => length
             ? `The meta description is ${length.actual} characters. Rewrite it to ${length.min}–${length.max} characters.`
             : "Rewrite the meta description to a better length.",
+        "seo.title-duplicate": (finding) => `This meta title is also used on ${list("en", finding.duplicate?.titles ?? [])}. Rewrite it so it fits this page only${lengthHint("en", finding)}.`,
+        "seo.description-duplicate": (finding) => `This meta description is also used on ${list("en", finding.duplicate?.titles ?? [])}. Rewrite it so it fits this page only${lengthHint("en", finding)}.`,
         "seo.image-missing": () => "Pick a share image for this page.",
         "content.h1-missing": () => "This page has no main heading (H1). Suggest how to add one that says what the page is about.",
         "content.h1-multiple": () => "This page has more than one main heading (H1). Suggest how to keep only one.",
@@ -107,6 +121,9 @@ export const ASK = {
         "content.thin": ({ words }) => words
             ? `This page has ${words.actual} words. Suggest how to expand the text to at least ${words.min} words.`
             : "This page has little text. Suggest how to expand it.",
+        "links.broken": ({ links }) => links?.target
+            ? `This links to “${links.target}”, which is not published. Suggest how to fix the link: another page to link to, or removing it.`
+            : "This links to a document that no longer exists. Suggest how to fix the link: another page to link to, or removing it.",
         "content.untranslated": ({ untranslated }) => untranslated
             ? `Translate the empty fields from ${languageName("en", untranslated.source)}.`
             : "Translate the empty fields.",
@@ -125,6 +142,8 @@ export const ASK = {
         "seo.description-length": ({ length }) => length
             ? `Metabeskrivningen är ${length.actual} tecken. Skriv om den till ${length.min}–${length.max} tecken.`
             : "Skriv om metabeskrivningen till en bättre längd.",
+        "seo.title-duplicate": (finding) => `Samma metatitel används på ${list("sv", finding.duplicate?.titles ?? [])}. Skriv om den så att den bara passar den här sidan${lengthHint("sv", finding)}.`,
+        "seo.description-duplicate": (finding) => `Samma metabeskrivning används på ${list("sv", finding.duplicate?.titles ?? [])}. Skriv om den så att den bara passar den här sidan${lengthHint("sv", finding)}.`,
         "seo.image-missing": () => "Välj en delningsbild för den här sidan.",
         "content.h1-missing": () => "Sidan saknar huvudrubrik (H1). Föreslå hur jag lägger till en som säger vad sidan handlar om.",
         "content.h1-multiple": () => "Sidan har fler än en huvudrubrik (H1). Föreslå hur jag behåller bara en.",
@@ -134,11 +153,22 @@ export const ASK = {
         "content.thin": ({ words }) => words
             ? `Sidan har ${words.actual} ord. Föreslå hur jag bygger ut texten till minst ${words.min} ord.`
             : "Sidan har lite text. Föreslå hur jag bygger ut den.",
+        "links.broken": ({ links }) => links?.target
+            ? `Här länkas till ”${links.target}”, som inte är publicerad. Föreslå hur jag rättar länken: en annan sida att länka till, eller att ta bort den.`
+            : "Här länkas till ett dokument som inte finns längre. Föreslå hur jag rättar länken: en annan sida att länka till, eller att ta bort den.",
         "content.untranslated": ({ untranslated }) => untranslated
             ? `Översätt de tomma fälten från ${languageName("sv", untranslated.source)}.`
             : "Översätt de tomma fälten.",
     },
 };
+/** ", 50–60 characters" when the finding carries the length the length check expects. */
+function lengthHint(language, { range }) {
+    if (!range)
+        return "";
+    return language === "sv"
+        ? `, ${range.min}–${range.max} tecken`
+        : `, ${range.min}–${range.max} characters`;
+}
 /** The range a length finding aims for, from either kind of meta finding. */
 const aim = ({ length, range }) => length ?? range;
 /**
@@ -160,6 +190,8 @@ export const BATCH_ASK = {
                 ? `Rewrite the meta title to ${range.min}–${range.max} characters.`
                 : "Rewrite the meta title to a better length.";
         },
+        "seo.title-duplicate": (finding) => `Rewrite the meta title so it fits the page only, not the other pages that use it${lengthHint("en", finding)}.`,
+        "seo.description-duplicate": (finding) => `Rewrite the meta description so it fits the page only, not the other pages that use it${lengthHint("en", finding)}.`,
         "seo.description-missing": (finding) => {
             const range = aim(finding);
             return range
@@ -190,6 +222,8 @@ export const BATCH_ASK = {
                 ? `Skriv om metatiteln till ${range.min}–${range.max} tecken.`
                 : "Skriv om metatiteln till en bättre längd.";
         },
+        "seo.title-duplicate": (finding) => `Skriv om metatiteln så att den bara passar sidan, inte de andra sidorna som använder den${lengthHint("sv", finding)}.`,
+        "seo.description-duplicate": (finding) => `Skriv om metabeskrivningen så att den bara passar sidan, inte de andra sidorna som använder den${lengthHint("sv", finding)}.`,
         "seo.description-missing": (finding) => {
             const range = aim(finding);
             return range
@@ -252,10 +286,18 @@ export const LIST_COPY = {
 /** A finding's detail: its length, word count, heading levels or untranslated fields, if any. */
 export function findingDetail(language, finding) {
     const copy = COPY[language];
-    const { heading, length, untranslated, words } = finding;
+    const { duplicate, heading, length, links, untranslated, words } = finding;
     if (untranslated) {
         return copy.untranslated(untranslated.count);
     }
+    if (duplicate) {
+        return copy.duplicate(duplicate.titles, duplicate.count - duplicate.titles.length);
+    }
+    if (links) {
+        return links.target
+            ? copy.linkUnpublished(links.target, links.count)
+            : copy.linkMissing(links.count);
+    }
     return length
         ? copy.length(length.actual, length.min, length.max)
         : words
@@ -266,6 +308,15 @@ export function findingDetail(language, finding) {
                     ? copy.h1Count(heading.count)
                     : undefined;
 }
+/** Names as a sentence lists them: "About, Home and Contact". */
+function list(language, names) {
+    try {
+        return new Intl.ListFormat(language, { type: "conjunction" }).format(names);
+    }
+    catch {
+        return names.join(", ");
+    }
+}
 /** A locale code as a language name in Admin's language: "engelska", "English". */
 export function languageName(language, code) {
     try {

package/dist/fields.d.ts

@@ -12,6 +12,8 @@ export type FieldLike = {
     tabs?: FieldLike[];
     blocks?: BlockLike[];
     blockReferences?: (BlockLike | string)[];
+    /** On relationship and upload fields. */
+    relationTo?: string | string[];
 };
 export type BlockLike = {
     slug: string;
@@ -26,10 +28,18 @@ export type PathInfo = {
 export declare function lookupPath(fields: FieldLike[], path: string): PathInfo | undefined;
 /** Deep-merges Local API `select` objects. */
 export declare function mergeSelect(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;
-/** A text-bearing field in a block, by its path in the block; arrays and groups add segments. */
+/**
+ * A field in a block that the body checks read, by its path in the block; arrays and groups add
+ * segments. Text counts as words and headings; relationship fields are internal links. A
+ * relationship to several collections stores `{ relationTo, value }`, to one the plain id.
+ */
 export type TextField = {
     path: string;
     kind: "text" | "richText";
+} | {
+    path: string;
+    kind: "relationship";
+    relationTo: string | string[];
 };
 /** Where a page body keeps its text: one rich text field, or text fields per block. */
 export type ContentSchema = {

package/dist/fields.js

@@ -86,7 +86,7 @@ export function contentSchema(field, resolveBlock) {
     }
     return { schema: { kind: "blocks", blocks }, localized };
 }
-/** Collects text fields in config order; returns whether any of them is localized. */
+/** Collects the fields in config order; returns whether any of them is localized. */
 function collectTextFields(fields, prefix, out) {
     let localized = false;
     for (const field of fields) {
@@ -99,6 +99,10 @@ function collectTextFields(fields, prefix, out) {
             out.push({ path, kind: "richText" });
             localized ||= Boolean(field.localized);
         }
+        else if (path && field.type === "relationship" && field.relationTo) {
+            out.push({ path, kind: "relationship", relationTo: field.relationTo });
+            localized ||= Boolean(field.localized);
+        }
         else if (field.type === "tabs") {
             localized = collectTextFields(field.tabs ?? [], prefix, out) || localized;
         }

package/dist/links.js

@@ -45,8 +45,10 @@ export const BATCH_CHECKS = {
     "media.alt-missing": "field",
     "seo.title-missing": "field",
     "seo.title-length": "field",
+    "seo.title-duplicate": "field",
     "seo.description-missing": "field",
     "seo.description-length": "field",
+    "seo.description-duplicate": "field",
     "content.untranslated": "translation",
 };
 /**

package/dist/references.d.ts

@@ -0,0 +1,8 @@
+import type { ContentSchema } from "./fields.ts";
+export type Reference = {
+    /** Form path of the field holding the link, e.g. `layout.2.content` or `layout.1.link.reference`. */
+    path: string;
+    relationTo: string;
+    id: string | number;
+};
+export declare function readReferences(value: unknown, root: string, schema: ContentSchema): Reference[];

package/dist/references.js

@@ -0,0 +1,117 @@
+/**
+ * Internal links in a page body: link nodes in rich text and relationship fields in blocks. Plain
+ * functions over the body as the Local API returns it at depth 0, like `content.ts`.
+ */
+import { fanOut } from "./content.js";
+/**
+ * Link types that point outside the site. A link group whose `type` or `linkType` says so keeps an
+ * old reference hidden by a condition; that reference is not a link a reader sees.
+ */
+const EXTERNAL_TYPES = new Set(["custom", "external", "url"]);
+export function readReferences(value, root, schema) {
+    const references = [];
+    if (schema.kind === "richText") {
+        readLexical(value, root, references);
+        return references;
+    }
+    if (!Array.isArray(value)) {
+        return references;
+    }
+    for (const [index, block] of value.entries()) {
+        const blockType = block?.blockType;
+        if (typeof blockType !== "string") {
+            continue;
+        }
+        for (const field of schema.blocks[blockType] ?? []) {
+            if (field.kind === "text") {
+                continue;
+            }
+            for (const { path, value: fieldValue, parent } of withParents(block, field.path)) {
+                const fullPath = `${root}.${index}.${path}`;
+                if (field.kind === "richText") {
+                    readLexical(fieldValue, fullPath, references);
+                }
+                else if (field.kind === "relationship" && !isExternal(parent)) {
+                    references.push(...relationValues(fieldValue, field.relationTo, fullPath));
+                }
+            }
+        }
+    }
+    return references;
+}
+/** `fanOut` with the object each value sits in, so a link field's siblings can be read. */
+function withParents(block, path) {
+    const cut = path.lastIndexOf(".");
+    const name = path.slice(cut + 1);
+    const parents = cut < 0 ? [{ path: "", value: block }] : fanOut(block, path.slice(0, cut));
+    return parents.flatMap((parent) => {
+        // An array field as the parent: its rows hold the field.
+        const rows = Array.isArray(parent.value)
+            ? parent.value.map((row, index) => ({ path: join(parent.path, String(index)), value: row }))
+            : [parent];
+        return rows.flatMap((row) => row.value !== null && typeof row.value === "object"
+            ? [
+                {
+                    path: join(row.path, name),
+                    value: row.value[name],
+                    parent: row.value,
+                },
+            ]
+            : []);
+    });
+}
+function isExternal(parent) {
+    return [parent.type, parent.linkType].some((value) => typeof value === "string" && EXTERNAL_TYPES.has(value));
+}
+/** A relationship value at depth 0, populated or not, single or `hasMany`. */
+function relationValues(value, relationTo, path) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => relationValues(item, relationTo, path));
+    }
+    if (value === null || value === undefined || value === "") {
+        return [];
+    }
+    if (typeof value === "object") {
+        const entry = value;
+        if (typeof entry.relationTo === "string") {
+            const id = idOf(entry.value);
+            return id === undefined ? [] : [{ path, relationTo: entry.relationTo, id }];
+        }
+        const id = idOf(entry);
+        return id !== undefined && typeof relationTo === "string" ? [{ path, relationTo, id }] : [];
+    }
+    const id = idOf(value);
+    return id !== undefined && typeof relationTo === "string" ? [{ path, relationTo, id }] : [];
+}
+function idOf(value) {
+    if (typeof value === "string" || typeof value === "number") {
+        return value === "" ? undefined : value;
+    }
+    if (value && typeof value === "object") {
+        return idOf(value.id);
+    }
+    return undefined;
+}
+/** Lexical's link nodes: `fields.linkType` is `internal` and `fields.doc` names the document. */
+function readLexical(value, path, references) {
+    const root = value?.root;
+    if (root) {
+        walk(root);
+    }
+    function walk(node) {
+        if (node.type === "link" || node.type === "autolink") {
+            const fields = node.fields;
+            if (fields?.linkType === "internal") {
+                references.push(...relationValues(fields.doc, [], path));
+            }
+        }
+        if (Array.isArray(node.children)) {
+            for (const child of node.children) {
+                walk(child);
+            }
+        }
+    }
+}
+function join(base, segment) {
+    return base ? `${base}.${segment}` : segment;
+}

package/dist/scan.js

@@ -1,5 +1,6 @@
 import { checkDocument, documentTitle, rulesFor } from "./checks.js";
 import { contentSchema, lookupPath, mergeSelect, } from "./fields.js";
+import { duplicateFindings, linkFindings, targetKey, } from "./site.js";
 import { checkTranslation } from "./translations.js";
 import { CHECK_IDS } from "./types.js";
 /** Where the plugin keeps its options in the (server-only) `config.custom`. */
@@ -20,6 +21,9 @@ export async function scanContentHealth({ payload, user, checks }) {
         problems: [],
     };
     const ran = new Set();
+    // Compared and followed once every collection is read.
+    const unique = [];
+    const links = [];
     const options = contentHealthOptions(payload.config);
     if (!options) {
         result.problems.push("contentHealthPlugin is not installed.");
@@ -27,8 +31,13 @@ export async function scanContentHealth({ payload, user, checks }) {
     }
     const blocks = (payload.config.blocks ?? []);
     const resolveBlock = (slug) => blocks.find((block) => block.slug === slug);
-    const locales = payload.config.localization
-        ? payload.config.localization.localeCodes
+    // The default language first, so other languages can borrow its titles.
+    const localization = payload.config.localization;
+    const locales = localization
+        ? [
+            localization.defaultLocale,
+            ...localization.localeCodes.filter((code) => code !== localization.defaultLocale),
+        ]
         : [undefined];
     for (const [slug, collectionOptions] of Object.entries(options.collections)) {
         const collection = payload.config.collections.find((collection) => collection.slug === slug);
@@ -50,7 +59,7 @@ export async function scanContentHealth({ payload, user, checks }) {
             }
             let localized = info.localized;
             let content;
-            if (rule.kind === "outline" || rule.kind === "words") {
+            if (rule.kind === "outline" || rule.kind === "words" || rule.kind === "links") {
                 const body = contentSchema(info.field, resolveBlock);
                 if (!body) {
                     result.problems.push(`${slug}: "${rule.path}" is not a blocks or rich text field.`);
@@ -85,6 +94,8 @@ export async function scanContentHealth({ payload, user, checks }) {
             mergeSelect(select, { _status: true });
         }
         const anyLocalized = rules.some((rule) => rule.localized);
+        // Titles in the default language, for documents not yet titled in another one.
+        const titles = new Map();
         for (const [index, locale] of locales.entries()) {
             if (!rules.length || (index > 0 && !anyLocalized)) {
                 break;
@@ -103,18 +114,23 @@ export async function scanContentHealth({ payload, user, checks }) {
                 });
                 result.documents[slug] = docs.length;
                 for (const doc of docs) {
-                    const { findings, checked } = checkDocument({
+                    const id = String(doc.id);
+                    const own = documentTitle(doc, useAsTitle);
+                    if (index === 0) {
+                        titles.set(id, own);
+                    }
+                    const { findings, checked, ...entries } = checkDocument({
                         collection: slug,
                         doc,
                         rules,
-                        title: documentTitle(doc, useAsTitle),
+                        title: own === id ? (titles.get(id) ?? own) : own,
                         ...(locale ? { locale } : {}),
                         includeUnlocalized: index === 0,
                     });
                     result.findings.push(...findings);
-                    for (const check of checked) {
-                        result.checked[check] = (result.checked[check] ?? 0) + 1;
-                    }
+                    countChecked(result, checked);
+                    unique.push(...(entries.unique ?? []));
+                    links.push(...(entries.links ?? []));
                 }
             }
             catch (error) {
@@ -142,9 +158,72 @@ export async function scanContentHealth({ payload, user, checks }) {
             }
         }
     }
+    result.findings.push(...duplicateFindings(unique));
+    countChecked(result, unique.map((entry) => entry.base.check));
+    if (links.length) {
+        try {
+            const targets = await linkTargets(payload, links.flatMap((entry) => entry.references));
+            const followed = linkFindings(links, targets);
+            result.findings.push(...followed.findings);
+            countChecked(result, followed.checked);
+        }
+        catch (error) {
+            result.problems.push(`links: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     result.checks = CHECK_IDS.filter((check) => ran.has(check));
     return result;
 }
+function countChecked(result, checked) {
+    for (const check of checked) {
+        result.checked[check] = (result.checked[check] ?? 0) + 1;
+    }
+}
+/**
+ * The documents the links lead to, as a reader would find them: the published version when the
+ * collection has drafts. Read without access control, so a link the editor cannot follow is not
+ * reported as broken; only whether the target exists, is published and its title leave here.
+ */
+async function linkTargets(payload, references) {
+    const targets = new Map();
+    const ids = new Map();
+    for (const { relationTo, id } of references) {
+        const own = ids.get(relationTo) ?? new Map();
+        own.set(String(id), id);
+        ids.set(relationTo, own);
+    }
+    for (const [slug, own] of ids) {
+        const collection = payload.config.collections.find((entry) => entry.slug === slug);
+        if (!collection) {
+            continue;
+        }
+        const useAsTitle = collection.admin?.useAsTitle;
+        const drafts = Boolean(collection.versions && collection.versions.drafts);
+        const select = {};
+        if (useAsTitle && useAsTitle !== "id")
+            mergeSelect(select, { [useAsTitle]: true });
+        if (collection.upload)
+            mergeSelect(select, { filename: true });
+        if (drafts)
+            mergeSelect(select, { _status: true });
+        const { docs } = await payload.find({
+            collection: slug,
+            depth: 0,
+            draft: false,
+            overrideAccess: true,
+            pagination: false,
+            select: select,
+            where: { id: { in: [...own.values()] } },
+        });
+        for (const doc of docs) {
+            targets.set(targetKey(slug, doc.id), {
+                title: documentTitle(doc, useAsTitle),
+                published: !drafts || doc._status !== "draft",
+            });
+        }
+    }
+    return targets;
+}
 /** Compares every other language with the default one, document by document. */
 async function scanTranslations(input) {
     const { payload, slug, result } = input;
@@ -188,9 +267,7 @@ async function scanTranslations(input) {
                 target,
             });
             result.findings.push(...findings);
-            for (const check of checked) {
-                result.checked[check] = (result.checked[check] ?? 0) + 1;
-            }
+            countChecked(result, checked);
         }
     }
 }

package/dist/site.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Checks that compare documents with each other or with what they link to. A document check hands
+ * over what it found (a meta text, the body's links); once every document is read, these functions
+ * make the findings. Pure, like `checks.ts`: the scan does the reading.
+ */
+import type { Reference } from "./references.ts";
+import type { CheckId, Finding } from "./types.ts";
+/** A meta text to compare with the other documents' in the same locale. */
+export type UniqueEntry = {
+    base: Finding;
+    value: string;
+};
+/** The internal links of one document's body, in one locale. */
+export type LinksEntry = {
+    base: Finding;
+    references: Reference[];
+};
+/** Case and spacing do not make a meta text unique. */
+export declare function normalizeText(value: string): string;
+/** One finding per document whose meta text another document in the same locale also uses. */
+export declare function duplicateFindings(entries: UniqueEntry[]): Finding[];
+/** What a link's target looks like to a reader; unset when it does not exist. */
+export type LinkTarget = {
+    title: string;
+    published: boolean;
+};
+export declare function targetKey(collection: string, id: string | number): string;
+/**
+ * One finding per document and locale with links to documents that are deleted or not published,
+ * at the first such link. Documents without internal links are not counted as checked.
+ */
+export declare function linkFindings(entries: LinksEntry[], targets: Map<string, LinkTarget>): {
+    findings: Finding[];
+    checked: CheckId[];
+};

package/dist/site.js

@@ -0,0 +1,67 @@
+/** Other documents named in a duplicate finding. */
+const MAX_TITLES = 3;
+/** Case and spacing do not make a meta text unique. */
+export function normalizeText(value) {
+    return value.trim().replace(/\s+/g, " ").toLocaleLowerCase();
+}
+/** One finding per document whose meta text another document in the same locale also uses. */
+export function duplicateFindings(entries) {
+    const groups = new Map();
+    for (const entry of entries) {
+        const text = normalizeText(entry.value);
+        if (!text)
+            continue;
+        const key = JSON.stringify([entry.base.check, entry.base.locale ?? "", text]);
+        groups.set(key, [...(groups.get(key) ?? []), entry]);
+    }
+    const findings = [];
+    for (const group of groups.values()) {
+        const documents = new Set(group.map(({ base }) => `${base.collection}:${base.id}`));
+        if (documents.size < 2)
+            continue;
+        for (const { base } of group) {
+            const others = group.filter((other) => other.base.collection !== base.collection || other.base.id !== base.id);
+            findings.push({
+                ...base,
+                duplicate: {
+                    count: others.length,
+                    titles: others.slice(0, MAX_TITLES).map((other) => other.base.title),
+                },
+            });
+        }
+    }
+    return findings;
+}
+export function targetKey(collection, id) {
+    return `${collection}:${id}`;
+}
+/**
+ * One finding per document and locale with links to documents that are deleted or not published,
+ * at the first such link. Documents without internal links are not counted as checked.
+ */
+export function linkFindings(entries, targets) {
+    const findings = [];
+    const checked = [];
+    for (const { base, references } of entries) {
+        if (!references.length)
+            continue;
+        checked.push(base.check);
+        const broken = references.flatMap((reference) => {
+            const target = targets.get(targetKey(reference.relationTo, reference.id));
+            return !target ? [{ reference }] : target.published ? [] : [{ reference, target }];
+        });
+        const first = broken[0];
+        if (!first)
+            continue;
+        findings.push({
+            ...base,
+            path: first.reference.path,
+            links: {
+                count: broken.length,
+                reason: first.target ? "unpublished" : "missing",
+                ...(first.target ? { target: first.target.title } : {}),
+            },
+        });
+    }
+    return { findings, checked };
+}

package/dist/styles/view.css

@@ -200,7 +200,18 @@
   flex-wrap: wrap;
   align-items: baseline;
   gap: calc(var(--base) * 0.25) calc(var(--base) * 0.5);
-  padding: calc(var(--base) * 0.25) 0;
+  margin-inline: calc(var(--base) * -0.5);
+  padding: calc(var(--base) * 0.35) calc(var(--base) * 0.5);
+}
+
+/* On a wide screen the assistant link is far from the title: lines and a hover band keep a row together. */
+.content-health-list__item + .content-health-list__item {
+  border-top: 1px solid var(--theme-elevation-100);
+}
+
+.content-health-list__item:hover,
+.content-health-list__item:focus-within {
+  background: var(--theme-elevation-50);
 }
 
 .content-health-list__item a {
@@ -219,7 +230,8 @@
   font-size: 0.9em;
 }
 
-.content-health-list__item a.content-health-list__fix:hover {
+.content-health-list__item:hover a.content-health-list__fix,
+.content-health-list__item a.content-health-list__fix:focus-visible {
   color: var(--content-health-accent-text);
 }
 

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export declare const CHECK_IDS: readonly ["media.alt-missing", "seo.title-missing", "seo.title-length", "seo.description-missing", "seo.description-length", "seo.image-missing", "content.h1-missing", "content.h1-multiple", "content.heading-skip", "content.thin", "content.untranslated"];
+export declare const CHECK_IDS: readonly ["media.alt-missing", "seo.title-missing", "seo.title-length", "seo.title-duplicate", "seo.description-missing", "seo.description-length", "seo.description-duplicate", "seo.image-missing", "content.h1-missing", "content.h1-multiple", "content.heading-skip", "content.thin", "links.broken", "content.untranslated"];
 export type CheckId = (typeof CHECK_IDS)[number];
 export type LengthRange = {
     min: number;
@@ -37,6 +37,20 @@ export type Finding = {
         count: number;
         source: string;
     };
+    /** For a duplicate meta text: the other documents with the same text in this locale. */
+    duplicate?: {
+        count: number;
+        titles: string[];
+    };
+    /**
+     * For broken links: how many internal links lead nowhere a reader can follow, and the first one,
+     * with its target's title when it still exists.
+     */
+    links?: {
+        count: number;
+        reason: "missing" | "unpublished";
+        target?: string;
+    };
     /** Draft status of the checked version, for collections with drafts. */
     status?: "draft" | "published";
 };
@@ -49,6 +63,11 @@ export type SeoOptions = {
     titleLength?: LengthRange | false;
     /** Default 100–150. */
     descriptionLength?: LengthRange | false;
+    /**
+     * Meta titles and descriptions used by more than one document in a language, across every
+     * collection with SEO checks. Default `true`.
+     */
+    duplicates?: boolean;
 };
 /**
  * Heading levels per block, as the block components render them: block slug → field path in the
@@ -65,6 +84,11 @@ export type ContentOptions = {
     headings?: HeadingLevels;
     /** Fewer words than this is thin content; `false` turns the check off. Default 300. */
     minWords?: number | false;
+    /**
+     * Internal links in the body (rich text links and relationship fields) to documents that are
+     * deleted or not published. Default `true`.
+     */
+    links?: boolean;
 };
 export type AltTextOptions = {
     /** Field holding the alt text. Default `alt`. */

package/dist/types.js

@@ -2,12 +2,15 @@ export const CHECK_IDS = [
     "media.alt-missing",
     "seo.title-missing",
     "seo.title-length",
+    "seo.title-duplicate",
     "seo.description-missing",
     "seo.description-length",
+    "seo.description-duplicate",
     "seo.image-missing",
     "content.h1-missing",
     "content.h1-multiple",
     "content.heading-skip",
     "content.thin",
+    "links.broken",
     "content.untranslated",
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simmalugnt-se/payload-content-health",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Content health checks and dashboard widgets for Payload Admin: alt texts, SEO fields and more",
   "keywords": [
     "payload",
@@ -8,11 +8,7 @@
   ],
   "license": "MIT",
   "author": "Simmalugnt AB",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/simmalugnt-se/payload-plugins.git",
-    "directory": "packages/payload-content-health"
-  },
+  "homepage": "https://simmalugnt.se",
   "type": "module",
   "engines": {
     "node": ">=22"