@sonordev/contracts 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 2.3.0
+
+A minor release: one new entry, `@sonordev/contracts/error-page`. Every other entry is unchanged.
+
+- **New entry `@sonordev/contracts/error-page`**: telling a rendered error page from a page's content, and copy that calls a working page missing from copy that describes it, so every writer and reader of page text answers the same way.
+  - `looksLikeErrorPage(text, wordCount?)` is true when stored text is an error page: a 404 in its common wordings, a framework or server error, a status page, a "something went wrong" or "temporarily unavailable" screen or a maintenance notice. It reads how the text opens, decodes entities, doesn't depend on word boundaries (scraped text runs elements together, as in "404This page could not be found."), and leaves phone numbers, addresses and pages that only describe an error alone.
+  - `usablePageText(text, wordCount?)` returns the text, or `null` for an error page.
+  - `findErrorPageClaim(copy, pageText?)` and `describesErrorPage(copy, pageText?)` find generated copy that says the page itself is missing or unavailable ("Page Not Found", "this page is currently unavailable", "returns a 404", "a page-not-found message"). A phrase the page's own text really says is allowed, and copy about something unavailable on a working page isn't a claim about the page.
+  - `findPageCopyClaim(fields, pageText?)` runs that check over every string in a set of fields, JSON-LD included, and returns the first `{ field, phrase }`.
+  - `ERROR_PAGE_MAX_WORDS` and `ERROR_PAGE_CONTRACT_VERSION` are exported alongside.
+
 ## 2.2.0
 
 A minor release: one new entry, `@sonordev/contracts/proposal-sitemap`. Every other entry is unchanged.

package/README.md

@@ -24,6 +24,7 @@ pnpm add @sonordev/contracts
 | `@sonordev/contracts/portfolio` | Where a portfolio number comes from and which may headline; the live-frame message | the Sonor API, Signal, agency-site-kit |
 | `@sonordev/contracts/proposal-sitemap` | How a proposal's site plan counts its pages, when its before-and-after comparison may show, and whether the page counts stated elsewhere in the proposal add up | the Sonor API, Signal's proposal writer, the dashboard's proposal pages |
 | `@sonordev/contracts/voice` | The house voice's contraction rule. `findUncontracted` and `contractText` find and apply full forms that should be contractions; `findContracted` finds the contractions a question-form heading should expand | anything that checks or rewrites copy: Sonor's APIs and dashboard |
+| `@sonordev/contracts/error-page` | Whether stored text is a rendered error page rather than a page's content, and whether generated copy says the page itself is missing | anything that stores page text or writes page copy from it: the Sonor API's page-view and sitemap writers, Signal's metadata generators |
 
 ## The voice contract
 
@@ -185,6 +186,72 @@ pages") isn't read, and a count of pages that aren't in the plan (say, a
 competitor's) is reported like any other; the issues are for a person to look
 at, not edits to apply.
 
+## The error-page contract
+
+A page's stored text is whatever a browser or crawler rendered. Visit a URL
+while it's briefly broken and the error page's words become that page's
+content, and any title, description or summary written from that content
+describes a working page as broken. `error-page` is how writers refuse both
+halves of that.
+
+- **`looksLikeErrorPage(text, wordCount?)`** is true when the text is a
+  rendered error page: a 404 in its common wordings ("404", "This page could
+  not be found", "Page not found"), a framework error ("a client-side
+  exception has occurred", "This page couldn't load", "Internal Server
+  Error", "Cannot GET /x"), a status page ("502 Bad Gateway", "HTTP Status
+  404"), a "something went wrong" or "temporarily unavailable" screen, or a
+  maintenance notice. It reads how the text *opens* (the first 300
+  characters), decodes HTML entities, and doesn't depend on word boundaries,
+  because scraped text runs elements together ("404This page could not be
+  found."). Text up to 120 words is checked for every wording, though the
+  loosest ones (a 404 glued to its copy, "refresh the page and try again", a
+  route's "<name> not found") only read the first 60 or 40 words; up to 400
+  words only the check for how it opens after a meta description and skip link
+  applies; beyond that it's prose. A phone number, room number or street
+  address that starts with 404 isn't an error page, and neither is a help page
+  that only *describes* an error ("how to fix a 404 error", "if something went
+  wrong"). Pass the word count of the text itself, never a whole page's count
+  (a browser's includes the navigation and footer and can hide a short error
+  state): a supplied count can only raise the count the check uses.
+- **`usablePageText(text, wordCount?)`** returns the text, or `null` when it's
+  an error page. It's what a model should be shown as "the page's content".
+- **`findErrorPageClaim(copy, pageText?)`** returns the phrase in generated
+  copy that says the page itself is missing or unavailable ("Page Not Found",
+  "the pricing page is currently unavailable", "returns a 404", "a
+  page-not-found message"), or `null`. Copy about something unavailable on a
+  working page ("the patio is closed on Mondays", "tours are paused for
+  winter") isn't a claim about the page. Pass the page's own text and a phrase
+  the page really says is allowed, so a guide to fixing "page not found"
+  errors can be titled that way; the text of an error page is never accepted
+  as that exemption. `describesErrorPage` is the boolean form.
+- **`findPageCopyClaim(fields, pageText?)`** runs `findErrorPageClaim` over
+  every string in a set of fields (a title, a description, keywords, a
+  JSON-LD object; any object or class instance) and returns the first
+  `{ field, phrase }`, or `null`. It's how a writer or a reader judges a whole
+  draft in one call. It reads at most 2,000 strings, 8 levels deep and 100,000
+  characters in all, and each string's first 5,000 characters, so a hostile
+  record can't make it slow.
+
+```ts
+import { describesErrorPage, findPageCopyClaim, usablePageText } from '@sonordev/contracts/error-page'
+
+usablePageText('404This page could not be found.') // null: don't generate from it
+usablePageText('Weekly mowing for property managers.') // the text
+
+describesErrorPage('Commercial Mowing Page Not Found | Example Co') // true: don't ship it
+describesErrorPage('Seasonal tours are paused until April.') // false
+
+findPageCopyClaim({
+  title: 'Commercial Mowing | Example Co',
+  schema: { '@type': 'WebPage', description: 'This URL currently returns a 404.' },
+})
+// { field: 'schema', phrase: 'returns a 404' }
+```
+
+A text-only check can't prove a page failed. Where you observed the HTTP
+status, require 400 or more as well and use this as the fallback; the header of
+`src/contracts/error-page.ts` lists the other known limits.
+
 ## Why it exists
 
 A rule that lives in several copies is how two of them end up disagreeing.

package/dist/error-page.d.ts

@@ -0,0 +1,183 @@
+/**
+ * @sonordev/contracts/error-page: telling an error page from a page (v1)
+ *
+ * Three questions every writer of page content and page copy has to answer the
+ * same way, so they live here once:
+ *
+ *   1. Is this stored text a rendered ERROR PAGE rather than the page's own
+ *      content? (`looksLikeErrorPage`, `usablePageText`)
+ *   2. Does this generated COPY say the page itself is missing or unavailable?
+ *      (`findErrorPageClaim`, `describesErrorPage`)
+ *   3. Does any string in a page's managed copy (a title, a keyword list, a
+ *      JSON-LD block) say so? (`findPageCopyClaim`: question 2 over every
+ *      string of a record, naming the field that holds it)
+ *
+ * Why it exists: a page's stored text is the text a visitor's browser (or a
+ * build's crawler) rendered. Visit a URL while it's briefly broken and the
+ * error page's words are stored as that page's content. Everything generated
+ * from that content then describes a working page as broken, and the result
+ * is published as the page's title, meta description, social tags, JSON-LD
+ * and AI-crawler notes. The outage ends in a deploy; the poisoned copy
+ * doesn't, because nothing downstream asks whether its input was ever the
+ * page.
+ *
+ * How the text check works
+ *
+ *   - It reads the START of the text (300 characters), lowercased, with
+ *     whitespace collapsed, HTML entities decoded and curly quotes made
+ *     straight. Error copy leads; articles bury it.
+ *   - The signatures are generic on purpose. Every site words its 404
+ *     differently and frameworks ship their own ("This page could not be
+ *     found.", "Application error: a client-side exception has occurred"), so
+ *     the shape is what's matched, not any one site's copy. They're grouped by
+ *     family below: not found, server and client errors, unavailable and
+ *     maintenance, walls.
+ *   - Stored text is often the page's elements run together with no separator
+ *     ("404This page could not be found."), so no signature depends on a word
+ *     boundary around the text it's matching.
+ *   - A signature that follows a word that DESCRIBES errors rather than
+ *     showing one ("if something went wrong", "how to fix a 404 error", a
+ *     quote mark) doesn't count: a help page that names an error isn't one.
+ *     Navigation is Title Case and prose isn't, so a describing word counts
+ *     only as it's written in lower case, with only its first letter
+ *     capitalized ("How to fix..."), or opening the text or a sentence;
+ *     "Home Blog How To Something went wrong" is still an error page, and the
+ *     words a menu uses too ("About", "Monitoring", "Alerts for") describe an
+ *     error only in lower case. A describing word inside the matched phrase
+ *     counts too, and after a described match the search resumes one character
+ *     on, so a real error later in the same stretch is still found.
+ *   - A not-found phrase that sits in a question ("Page not found? Use our site
+ *     map", "Product not found in your size? Ask us") is a help line, and so is
+ *     most copy that merely uses the words ("Rare parts can't be found
+ *     elsewhere": the subject has to be a page, URL, link, file, site or app).
+ *   - Up to ERROR_PAGE_MAX_WORDS words every check applies, but the loosest
+ *     ones apply only to the shortest texts: a 404 glued to its copy and
+ *     "refresh the page and try again" up to 60 words, a dynamic route's own
+ *     "<name> not found" state up to 40. From there up to 400 words only the
+ *     prefix-aware check applies: a text written as "<meta description> —
+ *     <every string on the page>" carries its header and footer strings along,
+ *     which pushes a rendered error state past the short-text ceiling, so the
+ *     check looks at how the text opens after the description and a skip link,
+ *     and an opener followed by "explained" or "how to" is an article. Beyond
+ *     400 words the text is prose.
+ *
+ * `wordCount` semantics: pass the word count of `text` itself. Pass the whole
+ * document's count only when `text` is a truncated excerpt of it. A supplied
+ * count can only RAISE the count the check uses (an excerpt of a long document
+ * is prose however short it is), never lower it: text that is longer than the
+ * count you gave is counted by what it holds. A browser's page-wide count
+ * (navigation and footer included) is therefore the wrong number for a short
+ * error state it scraped: pass the count of the text you pass.
+ *
+ * How the copy check works
+ *
+ *   `findErrorPageClaim` looks for the copy saying THE PAGE is missing or
+ *   unavailable ("Page Not Found | Acme", "This URL currently returns a 404",
+ *   "This listing has been removed", "The page failed to load"). The subject
+ *   has to be the page, its URL, link or listing, so copy about something
+ *   unavailable on a working page ("sunset cruises are not available at this
+ *   time") is left alone, and so is a qualified one ("unavailable in winter").
+ *   Whitespace is collapsed and each string is read up to 5,000 characters, so
+ *   hostile whitespace costs nothing. The page's own text exempts a phrase the
+ *   page really says; a page that is itself an error page exempts nothing.
+ *
+ *   `findPageCopyClaim(fields, pageText?)` is the same check over a record:
+ *   each value of `fields` is checked if it's a string, and walked for every
+ *   string it holds if it's an array or an object (8 levels deep, 2,000
+ *   leaves at most; numbers, booleans and null are ignored). It returns the
+ *   first claim as `{ field, phrase }`, `field` being the TOP-LEVEL key (the
+ *   column or property that holds the copy), or null. Use it for a page row's
+ *   managed title, description, keywords and JSON-LD in one call.
+ *
+ * Known limits (a text-only check can't close these)
+ *
+ *   - Any error phrase in the first 300 characters of a text of 120 words or
+ *     fewer reads as an error page, wherever in those 300 characters it sits, unless
+ *     something describes it (see above): a short page ABOUT errors ("Page not
+ *     found: how to design a helpful 404 page. Five examples.", or a web
+ *     agency's line about its "custom 404 error page") can be misread. Texts of
+ *     121 to 400 words are only read for how they open, and longer ones are
+ *     prose. The loosest wordings (a 404 glued to its copy, "refresh the page
+ *     and try again", "<name> not found") apply only up to 60, 60 and 40 words.
+ *   - A business whose name is an error phrase ("404 Brewing Co.", "Page Not
+ *     Found Records") reads as an error page when its name leads the text.
+ *   - Chrome in front hides the error state from the wordings anchored to the
+ *     start of the text ("Not Found", "Be right back.", "Error: ...", "Oops!
+ *     This page...", a permission wall, a dynamic route's "<name> not found").
+ *     The wordings that hold anywhere in the first 300 characters (a status with
+ *     its reason, "could not be found", "something went wrong") are what's
+ *     left. Prefer the page's main content.
+ *   - The text alone never proves a page failed. Where a call site observed
+ *     the HTTP status (a browser reports it), require a status of 400 or more
+ *     as well, and treat this check as the fallback for the sites and the
+ *     paths that report none.
+ *   - It reads English. A 404 in another language isn't matched.
+ *   - Walls and pages served by the host in front of the site (a CDN block, a
+ *     bot challenge, a parked domain, a default server page, a browser
+ *     interstitial) never reach the writers this guards, so they aren't
+ *     matched here.
+ *   - Copy that claims the page is missing in words outside the closed list
+ *     below isn't caught; the real protection is that error text never reaches
+ *     the generator (`usablePageText`).
+ *
+ * Pure string logic: no I/O, no Node built-ins, no lookbehind (this ships to
+ * browsers, and Safari before 16.4 throws on a lookbehind at parse time).
+ */
+/** Bump on breaking changes to what counts as an error page or an error claim. */
+export declare const ERROR_PAGE_CONTRACT_VERSION: 1;
+/**
+ * Above this many words, text is real prose even if it mentions a 404: only
+ * the prefix-aware check (up to 400 words, see the header) still looks at it.
+ *
+ * The gate is what makes the check safe: an article about broken links ("How
+ * to fix 404 errors on your site") legitimately holds every phrase below and
+ * must not be discarded. A rendered error page is short, and this ceiling
+ * still separates the two by an order of magnitude.
+ */
+export declare const ERROR_PAGE_MAX_WORDS = 120;
+/**
+ * True when this text is a rendered error page rather than page content.
+ *
+ * @param text      the scraped or extracted body text
+ * @param wordCount the word count of `text` itself, or the whole document's
+ *                  when `text` is a truncated excerpt of it. It can only raise
+ *                  the count the check uses, never lower it; derived from
+ *                  `text` when absent.
+ */
+export declare function looksLikeErrorPage(text?: string | null, wordCount?: number | null): boolean;
+/**
+ * The page's stored text, or null when it's an error page. What a model may
+ * be shown as "the page's content".
+ */
+export declare function usablePageText(text?: string | null, wordCount?: number | null): string | null;
+/**
+ * The phrase in `copy` that says the page itself is missing or unavailable, or
+ * null when the copy is fine.
+ *
+ * @param pageText the page's own text. A phrase the page really says (an
+ *                 article about fixing "page not found" errors) is allowed;
+ *                 only copy that claims what the page doesn't is a finding.
+ *                 A pageText that is itself an error page allows nothing: its
+ *                 words are the poison, so the copy that repeats them would
+ *                 otherwise vouch for itself.
+ */
+export declare function findErrorPageClaim(copy?: string | null, pageText?: string | null): string | null;
+/** True when `copy` says the page itself is missing or unavailable (see `findErrorPageClaim`). */
+export declare function describesErrorPage(copy?: string | null, pageText?: string | null): boolean;
+/**
+ * The first string anywhere in a record of managed copy that says the page
+ * itself is missing or unavailable, or null. `findErrorPageClaim` over every
+ * string of `fields`, and the record's own field name with the phrase.
+ *
+ * Each value is checked if it's a string, and walked for the strings it holds
+ * if it's an array or an object (a JSON-LD block, a keyword list), up to 8
+ * levels deep, 2,000 strings and 100,000 characters in all; numbers, booleans and
+ * null are ignored (and don't count toward those limits).
+ * `field` is the TOP-LEVEL key, the column or property that holds the copy.
+ * `pageText` exempts what the page really says, as in `findErrorPageClaim`; the
+ * page's own text is read once for the whole record.
+ */
+export declare function findPageCopyClaim(fields: object, pageText?: string | null): {
+    field: string;
+    phrase: string;
+} | null;

package/dist/error-page.js

@@ -0,0 +1,424 @@
+'use strict';
+
+// src/contracts/error-page.ts
+var ERROR_PAGE_CONTRACT_VERSION = 1;
+var ERROR_PAGE_MAX_WORDS = 120;
+var PREFIXED_MAX_WORDS = 400;
+var SHORT_ONLY_MAX_WORDS = 60;
+var START_STATE_MAX_WORDS = 40;
+var HEAD_CHARS = 300;
+var DESCRIBE_WINDOW = 45;
+var NAMED_ENTITIES = {
+  amp: "&",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  lt: "<",
+  gt: ">",
+  rsquo: "'",
+  lsquo: "'",
+  ldquo: '"',
+  ndash: "\u2013",
+  mdash: "\u2014",
+  hellip: "\u2026"
+};
+function decodeEntities(text) {
+  let out = text;
+  for (let pass = 0; pass < 2 && out.indexOf("&") !== -1; pass++) {
+    out = out.replace(/&(?:#x([0-9a-f]{1,6})|#(\d{1,7})|([a-z]{2,8}));/gi, (whole, hex, dec, name) => {
+      if (name) {
+        const key = name.toLowerCase();
+        return Object.prototype.hasOwnProperty.call(NAMED_ENTITIES, key) ? NAMED_ENTITIES[key] : whole;
+      }
+      const code = hex ? parseInt(hex, 16) : parseInt(dec, 10);
+      return code <= 1114111 ? String.fromCodePoint(code) : whole;
+    });
+  }
+  return out;
+}
+function tidy(text) {
+  return decodeEntities(text).replace(/[‘’‛ʼ]/g, "'").replace(/\s+/g, " ").trim();
+}
+function normalize(text) {
+  return tidy(text).toLowerCase();
+}
+function textOf(text) {
+  const oc = tidy(text);
+  const lc = oc.toLowerCase();
+  return { lc, oc: lc.length === oc.length ? oc : lc };
+}
+function slice(text, from, to) {
+  return { lc: text.lc.slice(from, to), oc: text.oc.slice(from, to) };
+}
+function words(text) {
+  return text.split(/\s+/).filter(Boolean).length;
+}
+function wordsAcrossElements(text) {
+  return words(text.replace(/([a-z0-9.,;:!?)"'’])([A-Z])/g, "$1 $2"));
+}
+var NOT_A_QUESTION = String.raw`(?!\s*\?|\s+(?:in|on|for|at|with|under|from|during|to)\b[^.!?]{0,50}\?)`;
+var NOT_IN_YOUR_SIZE = String.raw`(?!\s+in\s+your\s+size\b)`;
+var RECORD_NOUN = String.raw`(?:page|project|post|article|product|listing|resource|file|deployment)`;
+var CANT_BE_FOUND = String.raw`\b(?:page|url|link|resource|route|file|deployment|site|website|app|project)\b[^.!?]{0,40}?(?:could not|couldn't|can't|cannot|can not) be found`;
+var WHICH_PAGE = String.raw`(?:\s+(?:you(?:'re| are| were)? (?:looking for|requested|asked for|(?:tried|were trying|are trying) to (?:reach|visit|access|find|open))|that you (?:requested|asked for)|at\s+\S[^.!?]{0,40}|on this (?:site|server|website)))?`;
+var DOESNT_EXIST = String.raw`(?:\b(?:this|that|the|requested)\s+(?:[a-z0-9'-]+\s+){0,2}(?:page|url|link|post|article|listing|product|resource|project|profile|record|entry|story|event|course|job|item|offer|video)|\bpage)${WHICH_PAGE}\s+(?:doesn't|does not)(?: (?:seem|appear))?(?: to)? exist(?!\s+(?:to|for|so)\s)`;
+var MAINTENANCE_QUALIFIER = String.raw`(?!\s+(?:on|from|every|each|this|next|between|during|at|after|before|once|twice|monthly|weekly|nightly|daily|contract|agreement|plan|program|warranty|coverage|with\s+(?:us|our)|for\s+(?:the|a|\d)|until(?!\s+(?:\d{1,2}(?::\d\d)?\s*(?:[ap]\.?m\b|o'clock)|\d{1,2}:\d\d|noon|midnight|tomorrow|further notice)))\b)`;
+var ERROR_PAGE_SIGNATURES = [
+  // ---- Not found: the framework defaults and the common custom wordings ----
+  new RegExp(RECORD_NOUN + " (?:was |is )?not found" + NOT_A_QUESTION + NOT_IN_YOUR_SIZE),
+  // "Can't find the page you need? Use the search box" is a help line; "We can't find that page." isn't.
+  /(?:can't|cannot|can not|couldn't|could not|unable to) (?:be )?(?:find|found|locate)(?: that| this| the)? page(?!\s*\?|\s+(?:you|that|which)\b[^.!?]{0,40}\?)/,
+  // "We can't seem to find the page", "It seems we can't find what you're looking for".
+  /(?:we|i) (?:can't|cannot|couldn't|could not|were unable to|are unable to|weren't able to)(?: seem to)? (?:find|locate) (?:that page|this page|the page|that one|that(?=[.!,?]| link)|what you(?:'re| are| were)? looking for)/,
+  // "can not" is two words in the Vercel default.
+  new RegExp(CANT_BE_FOUND),
+  // Next's own not-found.tsx example: "Not FoundCould not find requested resourceReturn Home".
+  /(?:could not|couldn't) find (?:the )?requested resource/,
+  // "doesn't exist" only with a page, link or record as the subject: a short
+  // marketing page can say "if a tool doesn't exist, we'll build it".
+  new RegExp(DOESNT_EXIST),
+  /(?:doesn't|does not) exist or (?:has|have) been (?:moved|removed|deleted)/,
+  /looking for (?:doesn't|does not) exist/,
+  // A page-ish subject, like "doesn't exist" above: a history page can say "the 1890 mill no longer exists".
+  new RegExp(String.raw`\b(?:this|that|the)\s+(?:[a-z0-9'-]+\s+){0,2}(?:page|url|link|project|post|article|product|listing|resource|content|item|offer|event|record|story|profile|entry|document|course|job|video)` + WHICH_PAGE + String.raw`\s+no longer exists`),
+  /(?:404: ?not[ _]found|code: ?not_found)/,
+  // "Error 404" and "404 Error" as a label ("404 Error | Acme") or leading into what a 404 says
+  // ("Error 404Page not found"). Not "a custom 404 error page" and not a name ("Error 404 Studio").
+  /(?:^|[.!?|:]\s*)(?:http |server )?(?:error 404|404 error)(?=\s*[-–—|:.!?,)]|\s*(?:page|this|that|the|we|oops|whoops|sorry|looks|uh|hmm|nothing|there|it|oh|please)\b)|(?:error 404|404 error)(?=\s*$|\s*[-–—|:]?\s*(?:not found|this (?:page|url)|that page)\b)/,
+  // "The page you requested was not found", "The page you were looking for has been removed".
+  /page you (?:requested|(?:were|are) looking for|tried to (?:reach|visit|access))[^.!?]{0,60}(?:not found|no longer|(?:has|have|had|might have|may have|may) been|has (?:drifted|wandered|vanished|disappeared|moved|left)|isn't|is not|doesn't|does not|could not|can't|cannot|was not)/,
+  // Apache, Flask and Django: "The requested URL was not found on this server."
+  /requested (?:url|uri|resource|file|page|document)\b[^.!?]{0,80}(?:not found|not be found|cannot be found)|(?:was|is) not found on (?:this|the) server/,
+  // Netlify, Render, Flask and Express answer with the bare words "Not Found".
+  /^not found(?=$|\s*[-–—|:.!]|the requested|request id)/,
+  // WordPress core and its default themes: "It looks like nothing was found at this location.", "Nothing Found".
+  /nothing was found at this location|^nothing found(?=$|[.,:;!?|-]|sorry|it looks|we couldn|nothing|oops|the page)/,
+  // Custom 404 copy that never says "404": "Oops! This page took a day off.", "You've hit a dead end.",
+  // "This page doesn't live here anymore." The opener needs the page to be the one that's gone ("Oops! This
+  // page is a work in progress" is a holding page), and the dead end needs to be a sentence of its own.
+  /^(?:oops|whoops|uh[- ]oh)[!,.…]*\s*(?:this|that) page (?:took|went|wandered|got lost|ran away|has (?:gone|wandered|moved|left|vanished|disappeared|been (?:removed|moved|deleted))|is (?:missing|gone|lost)|isn't (?:here|available|there)|(?:doesn't|does not|can't|cannot|couldn't) (?:exist|be found|seem)|seems? (?:to be )?(?:missing|lost|gone))/,
+  /(?:^|[.!?]\s*)(?:you've|you have|you) (?:hit|reached) a dead end(?=[.!?…]|$)/,
+  /(?:page|link|url)[^.!?]{0,40}(?:doesn't|does not|no longer|isn't|is not) (?:live |exist |work )?here(?: anymore)?(?![a-z]*\s+to\b)/,
+  // Gatsby's 404 route: "NOT FOUNDYou just hit a route that doesn't exist... the sadness."
+  /hit a route that doesn't exist/,
+  // Tomcat and IIS: "HTTP Status 404 – Not Found", "HTTP Error 403.14 - Forbidden", "HTTP Error 503. The service is unavailable."
+  /http (?:error|status) [45]\d\d(?:\.\d+)?\s*[–—-]\s*(?:not found|forbidden|unauthori[sz]ed|bad request|internal|method not allowed|service unavailable)|http error [45]\d\d(?:\.\d+)?\. the /,
+  // A status number with its reason, anywhere in the head (a nav can precede it):
+  // "404 | Not Found", "502 - Bad Gateway", "403: Forbidden", "400Bad Request", "419 | Page Expired".
+  // Not "401 unauthorized means your key is missing": a status explained is documentation.
+  /(?:^|\D)(?:(?:404|410)\s*[|:–—-]?\s*(?:not found|page not found|file not found|web site not found)|408[\s:|–—-]*request time-?out|50[0-4][\s:|–—-]*(?:internal (?:server )?error|server error|bad gateway|service (?:temporarily )?unavailable|gateway time-?out)|40[13][\s:|–—-]*(?:forbidden|unauthori[sz]ed)|400[\s:|–—-]*bad request|405[\s:|–—-]*method not allowed|413[\s:|–—-]*(?:request entity|payload|content) too large|419[\s:|–—-]*page expired|429[\s:|–—-]*too many)(?!\s+(?:(?:requests?|errors?|responses?|status(?: codes?)?|codes?|messages?|pages?)\s+)?(?:means?|is|are|indicates?|occurs?|happens?|when|if|returns?|tells?|shows?|appears?|can|should|will|occurred)\b)/,
+  // Netlify's bare "Not Found - Request ID: ..." and Express's "Cannot GET /about", even with a nav in front.
+  /not found\s*[-–—]\s*request id|\bcannot (?:get|post|put|patch|delete) \/[\w\-./?=&%]*(?:$|\s)/,
+  // IIS's classic "Server Error 404 - File or directory not found." and its "had its name changed" sentence.
+  /file or directory not found|removed,? had its name changed/,
+  // This page has been removed / moved: its own sentence, not "removed from our menu".
+  /(?:^|[.!?]\s*)this page (?:has been |has |was |is )?(?:permanently )?(?:removed|deleted|moved)(?=[.!,;]|$|\s+(?:or|and)\b|\s*(?:return|go|back|click|please|visit|head)\b)/,
+  // ---- Server and client errors ----
+  // Not "Application error monitoring for Node teams".
+  /^application error(?!\s+(?:monitoring|tracking|reporting|handling|management|detection|analytics|logs?|alerts?|rates?|budgets?|codes?))/,
+  /(?:client|server)-side exception has occurred/,
+  // The hosts spell a status as a code too: "500: INTERNAL_SERVER_ERROR", "504: GATEWAY_TIMEOUT".
+  /internal[ _]server[ _]error/,
+  new RegExp(String.raw`(?:bad[ _]gateway|gateway[ _]time-?out)` + NOT_A_QUESTION),
+  // An exception's message rendered as the page: "Error: Failed to fetch data", "TypeError: x is undefined".
+  /^(?:(?:type|reference|syntax|range)error: |error: (?:failed|cannot|can't|unable|invalid|network|request|fetch|something|unexpected|no |not ))/,
+  // "Something went wrong with your insurance claim? ..." is a headline about a claim, not an error state.
+  new RegExp(String.raw`something(?: went|'s gone| has gone| had gone) wrong(?!\s+(?:with|during|on|in|at)\s+(?:your|my)\b)` + NOT_A_QUESTION),
+  /an (?:unexpected )?error (?:has )?occurred/,
+  /this (?:page|site|website) (?:isn't working|can't be reached)/,
+  // Next.js 16 error shells: "This page couldn't load. A server error occurred. Reload to try again."
+  // and the 403 / 401 pages ("This page could not be accessed.").
+  /this page couldn't load|a server error (?:has )?occurred|reload to try again(?=[.,!]|$)|this page could not be accessed/,
+  // React Router and Remix, Spring Boot, and the "unexpected error" boundaries.
+  /unexpected application error|whitelabel error page|(?:there was|encountered) an unexpected error/,
+  // Django and ASP.NET: "Server Error (500)", "Server Error in '/' Application", "Not Found (404)".
+  /server error (?:\(500\)|in '?\/)|(?:bad request|forbidden|not found) \((?:400|403|404)\)/,
+  // Next's runtime messages when a chunk or a hydration fails and the message is the page.
+  /chunkloaderror|loading chunk [\w/.-]+ failed|hydration failed because the|there was an error while hydrating/,
+  // Generated error.tsx boundaries: "Oops, we hit a snag.", "Something unexpected happened", "Unable to load page".
+  new RegExp(
+    String.raw`(?:^|[.!?]\s*)(?:(?:oops|whoops|uh[- ]oh)[!,.…]*\s*)?we hit a snag(?!\s+(?:with|in|on|during|when|while|at)\b)|(?:^|[.!?]\s*)something unexpected happened|(?:^|[.!?]\s*)(?:failed|unable) to load (?:the |this )?(?:page|content|data|resource)` + NOT_A_QUESTION + String.raw`|^error loading (?:the |this )?(?:page|content|data)`
+  ),
+  // "We're having trouble loading this page", "We couldn't load this page".
+  /(?:we're|we are|i'm) having (?:some )?(?:trouble|difficulty|difficulties|problems?) (?:loading|displaying|showing|retrieving) (?:this|that|the) (?:page|content)|we (?:couldn't|could not|can't|cannot) load (?:this|that|the) page/,
+  // WordPress core's fatal-error and database screens.
+  /there has been a critical error on this (?:website|site)|error establishing a database connection|(?:the|this) (?:site|website) is experiencing technical difficulties/,
+  // Apache's stock pages: 503, 400, 401, 408, 410 and 414 each in its own words.
+  /the server is temporarily unable to service your request|your browser sent a request that this server could not understand|this server could not verify that you are authorized|server timeout waiting for the http request|(?:was|is) no longer available on this server|request-uri too large/,
+  // ---- Unavailable and maintenance ----
+  // A qualifier ("in Hawaii", "until April") makes it content about a service, not a dead page.
+  /(?:this|the) (?:page|site|website|service) (?:is|are) (?:temporarily|currently) unavailable(?!\s+(?:in|on|for|at|during|to|until|from|outside|after|before|through)\b)/,
+  /^(?:service (?:temporarily )?unavailable|(?:temporarily|currently) unavailable(?!:\s))(?!\s+(?:in|on|for|at|during|to|until|from|outside)\b)/,
+  // The site or the page is the one under maintenance. Not "is under maintenance contract", not "down for
+  // maintenance on Fridays": a day, a time or a contract makes it content.
+  new RegExp(String.raw`(?:site|website|page|store|shop|app|portal|server|we're|we are)(?: is| are)?(?: currently| temporarily| now)*,? (?:under|down for) (?:scheduled |routine |some |emergency )?maintenance` + MAINTENANCE_QUALIFIER),
+  // "Our website is currently undergoing scheduled maintenance", "Briefly unavailable for scheduled maintenance",
+  // "We are offline for a short while". Not "Our rental fleet is undergoing routine maintenance": the subject is the site.
+  new RegExp(String.raw`(?:(?:site|website|page|store|shop|app|portal|server|we're|we are)(?: is| are)?(?: currently| temporarily| now)*|briefly|temporarily|currently|now) (?:undergoing|(?:offline|unavailable|down)(?: temporarily)? for) (?:scheduled |routine |some |emergency )?maintenance` + MAINTENANCE_QUALIFIER),
+  /(?:we're|we are|site is|website is) offline for an? (?:short|little|brief) (?:while|time|period)/,
+  /^be right back\.?$/,
+  // "We'll be back soon." ending its sentence, or leading into the next one. Not "We should be back soon with a replacement
+  // part", "back soon after our holiday break": what follows decides.
+  /(?:we'll|we will|we should|it should) (?:be )?(?:right )?back (?:online )?(?:soon|shortly)(?=[.!;]|$|,?\s*(?:our|the|this|thank|thanks|please|we)\b|\s+(?:once|after)\s+(?:a|the|our)\s+(?:(?:short|brief|quick|scheduled|planned)\s+)*(?:maintenance|upgrade|update|outage|downtime|migration|work)\b)/,
+  // An apology for the downtime makes what follows an outage notice, whatever it promises.
+  /sorry for the (?:downtime|inconvenience|interruption|outage)\W+(?:we'll|we will|we should|we are working)/,
+  // ---- Walls that stand in for the page ----
+  new RegExp(String.raw`(?:403 forbidden|access denied)(?!\s+(?:is|was|means|errors?|messages?|pages?)\b)` + NOT_A_QUESTION),
+  // A permission wall is addressed to the visitor and about THIS page or resource, and opens the text or follows its own
+  // heading ("Sorry, you are not allowed to access this page.", "ForbiddenYou are not authorized to access this resource.").
+  // Not a person or a file ("our team is not allowed to access this page of your file"), not a gallery ("you don't have
+  // permission to view the gallery"), and not a sentence further in ("Members only. You do not have permission to ...").
+  /(?:^|sorry|oops|error|forbidden|unauthori[sz]ed|access denied|40[13])\W*you(?:'re| are| aren't) (?:not |un)?(?:allowed|authori[sz]ed|permitted) to (?:access|view|see) (?:this|that) (?:page|resource|site|website|area|section|content)/,
+  /(?:^|sorry|oops|error|forbidden|unauthori[sz]ed|access denied|40[13])\W*you (?:don't|do not) have permission to (?:access|view) (?:this (?:page|resource|site|website|area|section|content)|\S+ on this server)/,
+  /^(?:forbidden|unauthori[sz]ed)(?=$|\s*[-–—|:.!]|you(?:'re| are)\b|please\b|this (?:page|resource))/,
+  /(?:checking your browser before accessing|enable javascript and cookies to continue(?!\s+\w)|verif(?:y|ying) you are (?:a )?human)/
+];
+var LEADING_STATUS = /^(?:(?:http )?error:? ?)?(?:400|401|402|403|405|408|410|413|414|419|429|500|501|502|503|504)\W{0,3}(?:(?:service|server|temporarily|internal|gateway|bad|proxy|request|too|access|page|file|resource|connection|http|status|method|payload|entity|payment|authentication)\s+){0,3}(?:error|forbidden|unauthori[sz]ed|gone|unavailable|bad gateway|time-?out|timed out|not found|not allowed|too many|too large|bad request|page expired|payment required|not implemented)/;
+var LEADING_404 = /^404(?![\d,])(?![\s.\-–—)]*\d)/;
+var ADDRESS_AFTER_404 = /^404\s+(?:[a-z0-9.'-]+\s+){0,3}(?:street|st|avenue|ave|road|rd|boulevard|blvd|drive|dr|lane|ln|way|court|ct|highway|hwy|pike|parkway|pkwy|place|pl|suite|ste|unit|apt)\b/;
+var SHORT_ONLY_SIGNATURES = [
+  // Opening the text, and not conditional: "Please refresh the page and try again." is the boundary's own line;
+  // "Clear your cache, then refresh the page and try again" is a tip, and "...try again if the calendar doesn't load" is one.
+  /^(?:please )?(?:refresh|reload)(?: the| this)? (?:page )?(?:and|or) try again(?!\s+(?:if|when|unless|whether|once|after|later|next|the next)\b)/
+];
+var SHORT_START_SIGNATURES = [new RegExp(String.raw`^(?:[a-z0-9'&-]+\s+){0,2}[a-z0-9'&-]+ not found` + NOT_A_QUESTION + NOT_IN_YOUR_SIZE)];
+var GLUED_404 = /(?:^|[\s|])404(?=[a-z])(?!th\b)/g;
+var DELIMITED_404 = /(?:^|\s)404\s*[|:–—]\s*[a-z]/g;
+var NUMBER_PREFIX = /(?:suite|ste|room|rm|unit|apt|apartment|route|rt|hwy|highway|building|bldg|floor|#)\.?\s*$/;
+var ABOUT_THE_ERROR = String.raw`(?!\W*(?:errors?\b|explained|guide|what (?:it|this|that|is|are)|how to|how do|why|means|fix(?:es|ing)?\b|causes|vs\b|\?))`;
+var PREFIX_SIGNATURES = [
+  new RegExp(String.raw`(?:page|resource|post|article|product|listing) (?:was |is )?not found`),
+  new RegExp(CANT_BE_FOUND),
+  /(?:we|i) (?:can't|cannot|couldn't|could not)(?: seem to)? (?:find|locate) (?:that page|this page|the page|what you(?:'re| are| were)? looking for)/,
+  new RegExp(DOESNT_EXIST),
+  /something went wrong|(?:client|server)-side exception|internal server error|this page couldn't load/
+].map((pattern) => new RegExp("(?:" + pattern.source + ")" + ABOUT_THE_ERROR));
+var PREFIXED_LEADING_404 = new RegExp(LEADING_404.source + ABOUT_THE_ERROR);
+var PREFIXED_LEADING_STATUS = new RegExp(LEADING_STATUS.source + ABOUT_THE_ERROR);
+var PREFIX_SEPARATOR = " \u2014 ";
+var PREFIX_MIN_CHARS = 60;
+var PREFIX_MAX_CHARS = 400;
+var SKIP_LINK = /^(?:skip to (?:main )?content|skip to main|skip navigation)\s*/;
+var PREFIX_WINDOW_CHARS = 90;
+var DESCRIBERS = String.raw`if|when|whether|unless|how to|how do|why|what is|what's|fix(?:ing|es)?|handle|handling|resolve|resolving|troubleshoot(?:ing)?|diagnos(?:e|ing)|watch(?:es|ing)? for|encounter(?:ing)?|history of`;
+var LOWERCASE_DESCRIBERS = String.raw`about|monitor(?:ing)?|alert(?:s|ing)? (?:on|for)`;
+var DESCRIBING_CONTEXT = new RegExp(
+  String.raw`(?:\b(?:(${DESCRIBERS})|(${LOWERCASE_DESCRIBERS}))(?:\s+(?:you|your|the|a|an|their|our|my|see|get|are|is|seeing|getting|receive|receiving|hit|to|every|any|each|all|\d{3})){0,3}\s*["'“]?|["“])$`
+);
+var INNER_DESCRIBER = /\b(?:if|when|whether|unless|how to)\b/;
+var SENTENCE_OPENING = /[.!?:;|—–"“(]\s*$/;
+var VISIBILITY_SUBJECT = /\b(?:you|your|we|our|they|their|customers?|clients?|people|visitors?|buyers?|patients?|business(?:es)?|brands?|compan(?:y|ies))\s+$/;
+var FORM_FIELDS = /\b(?:name|e-?mail|phone|message|subscribe|submit)\b/;
+function globalOf(patterns) {
+  return patterns.map((pattern) => new RegExp(pattern.source, "g"));
+}
+var SIGNATURES = globalOf(ERROR_PAGE_SIGNATURES);
+var SHORT_ONLY_SIGS = globalOf(SHORT_ONLY_SIGNATURES);
+var SHORT_START_SIGS = globalOf(SHORT_START_SIGNATURES);
+var PREFIX_SIGS = globalOf(PREFIX_SIGNATURES);
+var TITLE_VERB = /\b(?:fix|handle|resolve|troubleshoot|diagnose)\b/;
+function describerIsProse(orig, start, describer, context) {
+  const word = orig.slice(start, start + describer.length);
+  if (word === describer || word === describer.charAt(0).toUpperCase() + describer.slice(1)) return true;
+  return start === 0 || SENTENCE_OPENING.test(orig.slice(Math.max(0, start - 3), start)) || TITLE_VERB.test(context);
+}
+function isDescribed(head, hit) {
+  const from = Math.max(0, hit.index - DESCRIBE_WINDOW);
+  const before = head.lc.slice(from, hit.index);
+  const context = DESCRIBING_CONTEXT.exec(before);
+  if (context) {
+    const [, describer, lowercaseDescriber] = context;
+    const at = from + context.index;
+    if (describer !== void 0) {
+      if (describerIsProse(head.oc, at, describer, context[0])) return true;
+    } else if (lowercaseDescriber !== void 0) {
+      if (head.oc.slice(at, at + lowercaseDescriber.length) === lowercaseDescriber) return true;
+    } else {
+      return true;
+    }
+  }
+  const inner = INNER_DESCRIBER.exec(hit[0]);
+  if (inner && head.oc.slice(hit.index + inner.index, hit.index + inner.index + inner[0].length) === inner[0]) return true;
+  return /be found$/.test(hit[0]) && VISIBILITY_SUBJECT.test(before) || /you are (?:a )?human$/.test(hit[0]) && FORM_FIELDS.test(head.lc);
+}
+function showsSignature(head, patterns, inFirstSentence = false) {
+  return patterns.some((pattern) => {
+    pattern.lastIndex = 0;
+    for (let hit = pattern.exec(head.lc); hit; hit = pattern.exec(head.lc)) {
+      if (inFirstSentence && /[.!?]/.test(head.lc.slice(0, hit.index))) return false;
+      if (!isDescribed(head, hit)) return true;
+      pattern.lastIndex = hit.index + 1;
+    }
+    return false;
+  });
+}
+function showsLoose404(head) {
+  for (const pattern of [GLUED_404, DELIMITED_404]) {
+    pattern.lastIndex = 0;
+    for (let hit = pattern.exec(head); hit; hit = pattern.exec(head)) {
+      if (!NUMBER_PREFIX.test(head.slice(Math.max(0, hit.index - 14), hit.index))) return true;
+    }
+  }
+  return false;
+}
+function afterPrefix(text) {
+  let start = 0;
+  const cut = text.lc.indexOf(PREFIX_SEPARATOR);
+  if (cut >= PREFIX_MIN_CHARS && cut < PREFIX_MAX_CHARS) start = cut + PREFIX_SEPARATOR.length;
+  const skip = SKIP_LINK.exec(text.lc.slice(start));
+  if (skip) start += skip[0].length;
+  return start === 0 ? text : slice(text, start);
+}
+function opensWith404(head) {
+  return LEADING_404.test(head) && !ADDRESS_AFTER_404.test(head);
+}
+function showsErrorState(head, count) {
+  return opensWith404(head.lc) || LEADING_STATUS.test(head.lc) || showsSignature(head, SIGNATURES) || count <= START_STATE_MAX_WORDS && showsSignature(head, SHORT_START_SIGS) || count <= SHORT_ONLY_MAX_WORDS && (showsSignature(head, SHORT_ONLY_SIGS) || showsLoose404(head.lc));
+}
+function looksLikeErrorPage(text, wordCount) {
+  if (!text || typeof text !== "string") return false;
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  const own = wordsAcrossElements(trimmed);
+  const count = typeof wordCount === "number" && wordCount >= 0 ? Math.max(wordCount, own) : own;
+  if (count > PREFIXED_MAX_WORDS) return false;
+  const whole = textOf(trimmed);
+  const rest = afterPrefix(whole);
+  if (own > ERROR_PAGE_MAX_WORDS) {
+    const lead = rest.lc.slice(0, HEAD_CHARS);
+    return PREFIXED_LEADING_404.test(lead) && !ADDRESS_AFTER_404.test(lead) || PREFIXED_LEADING_STATUS.test(lead) || showsSignature(slice(rest, 0, PREFIX_WINDOW_CHARS), PREFIX_SIGS, true);
+  }
+  if (count > ERROR_PAGE_MAX_WORDS) return false;
+  return showsErrorState(slice(whole, 0, HEAD_CHARS), count) || // A long description pushes the page's own words past the first 300 characters.
+  rest !== whole && showsErrorState(slice(rest, 0, HEAD_CHARS), words(rest.lc));
+}
+function usablePageText(text, wordCount) {
+  if (!text || typeof text !== "string" || !text.trim()) return null;
+  return looksLikeErrorPage(text, wordCount) ? null : text;
+}
+var QUALIFIED = String.raw`(?!\s+(?:in|on|during|until|outside|after|before|from|when|while|if|with|to|through|between|over|due|at(?!\s+(?:this|the)\s+(?:time|moment))|for(?!\s+(?:this|the|that)\s+(?:[\w'’&-]+\s+){0,3}?(?:page|url|link|listing|post|article|project|menu|item|resource|insight|study|portfolio)))\b)`;
+var QUALIFIED_LIGHT = String.raw`(?!\s+(?:when|while|if|until|after|before|during|on|in|from|to|behind|outside|within)\b)`;
+var THE_PAGE = String.raw`\b(?:this|the|that)\s+(?:[\w'’&.-]+\s+){0,4}?(?:page|url|link|route|listing|post|article|project|product|resource|insight|study|portfolio|document)`;
+var ERROR_CLAIMS = [
+  // "Page Not Found", "Project Not Found", and the hyphenated compound a model coins:
+  // "a page-not-found message". Not "Page not found? Use our site map": a question is a help line.
+  new RegExp(String.raw`\b(?:page|project|post|article|listing|product)[\s-]+not[\s-]+found\b(?!\s*\?)`, "i"),
+  // "the pricing page is currently unavailable", "this URL is unavailable", "the page is currently down",
+  // "This page is no longer available", "This URL is not found"
+  new RegExp(
+    String.raw`\b(?:web\s?page|page|url|link|route)(?:\s+(?:from|at|on|for|of)\s+[\w'’&.-]+(?:\s+[\w'’&.-]+){0,4})?\s+(?:is|was|are|were|has\s+been|appears\s+to\s+be|seems\s+to\s+be|remains)\s+(?:(?:currently\s+|temporarily\s+|now\s+)?(?:unavailable|not\s+available|missing|offline|broken|gone)\b` + QUALIFIED + String.raw`|(?:currently\s+|temporarily\s+|now\s+)?(?:down|inaccessible|not\s+accessible|unreachable|not\s+found)\b` + QUALIFIED_LIGHT + String.raw`|no\s+longer\s+(?:available|accessible|reachable|live|online)\b` + QUALIFIED_LIGHT + String.raw`)`,
+    "i"
+  ),
+  // "Page Unavailable", "Page Currently Unavailable"
+  // "offline" only as a state ("the page is offline"): "save any page offline" is a feature.
+  new RegExp(String.raw`\bpage\s+(?:(?:is|was)\s+)?(?:currently\s+|temporarily\s+|now\s+)?(?:unavailable|not\s+available)\b` + QUALIFIED + String.raw`|\bpage\s+(?:is|was)\s+(?:currently\s+|temporarily\s+|now\s+)?offline\b`, "i"),
+  // "an unavailable-page presentation": the hyphenated compound again.
+  /\bunavailable-page\b/i,
+  // "could not be found" (or located, reached, loaded) with a page, URL or link as the subject
+  // The subject is THIS page ("this/the/that ... page"): "why your business page can't be found on Google" is an SEO headline.
+  /\b(?:this|the|that)\s+(?:[\w'’&.-]+\s+){0,6}?(?:page|url|link|route)\b[^.|;:]{0,60}?\b(?:could\s+not|couldn(?:'|’)t|can(?:'|’)t|cannot)\s+be\s+(?:found|located|reached|loaded|displayed|shown)\b/i,
+  // "currently returns a 404", "shows a not-found page", "displays a 404 page", "returns an HTTP 404 status"
+  /\b(?:return(?:s|ed|ing)?|show(?:s|ed|ing)?|display(?:s|ed|ing)?|serv(?:e|es|ed|ing)|lands?\s+on)\s+(?:that\s+)?(?:an?\s+|the\s+)?(?:http\s+)?(?:404|not[- ]found|error\s+page)/i,
+  /\b404[\s-]page\b/i,
+  // "details are unavailable", "menu information is unavailable"
+  new RegExp(String.raw`\b(?:details|information|info|content|menu|page)\s+(?:is|are)\s+(?:currently\s+|temporarily\s+)?unavailable\b` + QUALIFIED, "i"),
+  // A sentence that opens with the page as its subject: "This insight is unavailable."
+  // ...and the sentence's subject has to BE a page-like thing: "The patio is not available on Fridays" is about a patio.
+  new RegExp(String.raw`(?:^|[.!?]\s+)(?:this|the)\s+(?:[^.!?|\s][^.!?|]{0,69}?\s+)?(?:page|url|link|route|insight|article|post|project|study|resource|portfolio|guide|document)(?:\s+(?:you|that|which)\s+[^.!?|]{0,40}?)?\s+is\s+(?:currently\s+|temporarily\s+)?(?:unavailable|not\s+available)\b` + QUALIFIED, "i"),
+  // JSON-LD labels: "Unavailable Harbor Buffet page". A label, not "block unavailable dates on your booking page".
+  /(?:^|[|:.!?–—-]\s*)unavailable\s+(?:[\w'’&-]+\s+){0,6}?(?:page|url|menu|insight|article|project)\b/i,
+  // "This page doesn't exist.", "This page does not currently exist.", "No page exists at this address."
+  new RegExp(THE_PAGE + String.raw`\s+(?:(?:does\s+not|doesn['’]t)\s+(?:currently\s+|seem\s+to\s+|appear\s+to\s+)?exist|no\s+longer\s+exists?)\b(?!\s+(?:for|so)\s)` + QUALIFIED_LIGHT, "i"),
+  /\bno\s+(?:page|content|resource|listing)\s+exists?\s+(?:at|for|on|here)\b/i,
+  // "This page has been removed or moved.", "This listing has been removed." Moved to somewhere ("moved to our new site") is a redirect note.
+  new RegExp(THE_PAGE + String.raw`\s+(?:has|have|had)\s+(?:since\s+)?been\s+(?:permanently\s+)?(?:removed|moved|deleted|taken\s+down)\b` + QUALIFIED, "i"),
+  // "The page you're looking for isn't available.", "The page you requested has been removed."
+  new RegExp(
+    String.raw`\bpage\s+you(?:['’]re|\s+are|\s+were)?\s+(?:looking\s+for|requested|tried\s+to\s+(?:reach|visit|access))\s+(?:(?:is(?:n['’]t|\s+not)|was(?:n['’]t|\s+not))\s+(?:available|found|here|there|accessible)\b` + QUALIFIED + String.raw`|(?:has|have|might\s+have|may\s+have)\s+been\s+(?:removed|moved|deleted|renamed)\b|(?:doesn['’]t|does\s+not)\s+exist\b|no\s+longer\s+(?:exists?|available)\b)`,
+    "i"
+  ),
+  // "The page failed to load." (past tense: "if a page fails to load, refresh" is advice).
+  /\b(?:page|url|link|route)\s+(?:has\s+)?failed\s+to\s+load\b/i,
+  // "This URL contains only an error message.", "The page returned an error message instead of service details."
+  // Not "The checkout page shows an error message when payment fails."
+  new RegExp(String.raw`\b(?:page|url|link|route)\s+(?:currently\s+)?(?:(?:returned|returns?|displays?|displayed|shows?|showed|serves?|served)\s+(?:only\s+)?|(?:contains?|contained)\s+only\s+)(?:an?\s+|the\s+)?(?:error\s+(?:message|page)|http\s+error|not[- ]found\s+(?:message|error|page))\b(?=\s*(?:[.!?;:,|]|$)|\s+(?:instead|rather|in\s+place|and|but|only|with\s+no|with\s+nothing)\b)`, "i"),
+  // "404 Error | Acme Mowing", "Error 404: Acme Mowing", "HTTP 404", "404 Not Found | Acme": a label opening the copy or a segment of it.
+  /(?:^|[|:.!?–—-]\s*)(?:http\s+)?(?:error\s+404|404\s+error|http\s+404)\s*(?:[|:–—.!?-]|$)|\b404[\s:|–—-]*not\s+found\b/i,
+  // "This page isn't available.", "This page wasn't found." (the contracted forms of the above)
+  new RegExp(String.raw`\b(?:web\s?page|page|url|link|route)\s+(?:is|was)(?:n['’]t)\s+(?:currently\s+|now\s+)?(?:available|found|accessible|here|live)\b` + QUALIFIED_LIGHT, "i"),
+  // "We couldn't find this page on the Acme website.", "Sorry, we can't find that page.", "We could not locate the page you requested."
+  // Not "Can't find the page you need? Use search": a question in the same sentence is a help line.
+  /\b(?:we|i)\s+(?:could\s+not|couldn['’]t|can['’]t|cannot|(?:were|was|are|am)\s+unable\s+to|weren['’]t\s+able\s+to)\s+(?:seem\s+to\s+)?(?:find|locate)\s+(?:this|that|the)\s+(?:requested\s+)?(?:web\s?page|page|url|link)\b(?![^.!?]*\?)/i,
+  // "Unable to find the requested page."
+  /\bunable\s+to\s+(?:find|locate)\s+(?:this|that|the)\s+requested\s+(?:web\s?page|page|url|link|resource)\b/i,
+  // "The requested URL was not found on this server."
+  /\brequested\s+(?:url|uri|resource|page)\b[^.!?]{0,60}?\b(?:was\s+not|wasn['’]t|could\s+not\s+be|cannot\s+be)\s+found\b/i,
+  // "Page missing", "Error loading page": labels (a segment or the whole copy), not "pages missing from the index".
+  /(?:^|[|:.!?–—-]\s*)(?:page\s+(?:is\s+)?missing|error\s+loading\s+(?:the\s+)?page|not\s+found)\s*(?:[|:–—.!?-]|$)/i
+];
+function ownTextOf(pageText) {
+  return pageText && typeof pageText === "string" && !looksLikeErrorPage(pageText) ? normalize(pageText) : "";
+}
+var CLAIM_MAX_CHARS = 5e3;
+function claimIn(copy, own) {
+  const text = copy.replace(/\s+/g, " ").trim().slice(0, CLAIM_MAX_CHARS);
+  if (!text) return null;
+  for (const claim of ERROR_CLAIMS) {
+    const hit = text.match(claim);
+    if (!hit) continue;
+    const phrase = hit[0].replace(/^[.!?|:–—-]\s*/, "").trim();
+    if (own && own.includes(normalize(phrase))) continue;
+    return phrase;
+  }
+  return null;
+}
+function findErrorPageClaim(copy, pageText) {
+  if (!copy || typeof copy !== "string") return null;
+  return claimIn(copy, ownTextOf(pageText));
+}
+function describesErrorPage(copy, pageText) {
+  return findErrorPageClaim(copy, pageText) !== null;
+}
+var COPY_MAX_DEPTH = 8;
+var COPY_MAX_LEAVES = 2e3;
+var COPY_MAX_TOTAL_CHARS = 1e5;
+function findPageCopyClaim(fields, pageText) {
+  if (!fields || typeof fields !== "object") return null;
+  const own = ownTextOf(pageText);
+  let leaves = 0;
+  let containers = 0;
+  let chars = 0;
+  const spent = () => leaves >= COPY_MAX_LEAVES || containers > COPY_MAX_LEAVES || chars > COPY_MAX_TOTAL_CHARS;
+  const walk = (value, level) => {
+    if (typeof value === "string") {
+      leaves++;
+      chars += Math.min(value.length, CLAIM_MAX_CHARS);
+      return spent() && chars > COPY_MAX_TOTAL_CHARS ? null : claimIn(value, own);
+    }
+    if (!value || typeof value !== "object") return null;
+    if (level >= COPY_MAX_DEPTH || ++containers > COPY_MAX_LEAVES) return null;
+    const record2 = value;
+    for (const key in record2) {
+      if (spent()) break;
+      if (!Object.prototype.hasOwnProperty.call(record2, key)) continue;
+      const phrase = walk(record2[key], level + 1);
+      if (phrase) return phrase;
+    }
+    return null;
+  };
+  const record = fields;
+  for (const key of Object.keys(record)) {
+    if (spent()) break;
+    const phrase = walk(record[key], 1);
+    if (phrase) return { field: key, phrase };
+  }
+  return null;
+}
+
+exports.ERROR_PAGE_CONTRACT_VERSION = ERROR_PAGE_CONTRACT_VERSION;
+exports.ERROR_PAGE_MAX_WORDS = ERROR_PAGE_MAX_WORDS;
+exports.describesErrorPage = describesErrorPage;
+exports.findErrorPageClaim = findErrorPageClaim;
+exports.findPageCopyClaim = findPageCopyClaim;
+exports.looksLikeErrorPage = looksLikeErrorPage;
+exports.usablePageText = usablePageText;

package/dist/error-page.mjs

@@ -0,0 +1,416 @@
+// src/contracts/error-page.ts
+var ERROR_PAGE_CONTRACT_VERSION = 1;
+var ERROR_PAGE_MAX_WORDS = 120;
+var PREFIXED_MAX_WORDS = 400;
+var SHORT_ONLY_MAX_WORDS = 60;
+var START_STATE_MAX_WORDS = 40;
+var HEAD_CHARS = 300;
+var DESCRIBE_WINDOW = 45;
+var NAMED_ENTITIES = {
+  amp: "&",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  lt: "<",
+  gt: ">",
+  rsquo: "'",
+  lsquo: "'",
+  ldquo: '"',
+  ndash: "\u2013",
+  mdash: "\u2014",
+  hellip: "\u2026"
+};
+function decodeEntities(text) {
+  let out = text;
+  for (let pass = 0; pass < 2 && out.indexOf("&") !== -1; pass++) {
+    out = out.replace(/&(?:#x([0-9a-f]{1,6})|#(\d{1,7})|([a-z]{2,8}));/gi, (whole, hex, dec, name) => {
+      if (name) {
+        const key = name.toLowerCase();
+        return Object.prototype.hasOwnProperty.call(NAMED_ENTITIES, key) ? NAMED_ENTITIES[key] : whole;
+      }
+      const code = hex ? parseInt(hex, 16) : parseInt(dec, 10);
+      return code <= 1114111 ? String.fromCodePoint(code) : whole;
+    });
+  }
+  return out;
+}
+function tidy(text) {
+  return decodeEntities(text).replace(/[‘’‛ʼ]/g, "'").replace(/\s+/g, " ").trim();
+}
+function normalize(text) {
+  return tidy(text).toLowerCase();
+}
+function textOf(text) {
+  const oc = tidy(text);
+  const lc = oc.toLowerCase();
+  return { lc, oc: lc.length === oc.length ? oc : lc };
+}
+function slice(text, from, to) {
+  return { lc: text.lc.slice(from, to), oc: text.oc.slice(from, to) };
+}
+function words(text) {
+  return text.split(/\s+/).filter(Boolean).length;
+}
+function wordsAcrossElements(text) {
+  return words(text.replace(/([a-z0-9.,;:!?)"'’])([A-Z])/g, "$1 $2"));
+}
+var NOT_A_QUESTION = String.raw`(?!\s*\?|\s+(?:in|on|for|at|with|under|from|during|to)\b[^.!?]{0,50}\?)`;
+var NOT_IN_YOUR_SIZE = String.raw`(?!\s+in\s+your\s+size\b)`;
+var RECORD_NOUN = String.raw`(?:page|project|post|article|product|listing|resource|file|deployment)`;
+var CANT_BE_FOUND = String.raw`\b(?:page|url|link|resource|route|file|deployment|site|website|app|project)\b[^.!?]{0,40}?(?:could not|couldn't|can't|cannot|can not) be found`;
+var WHICH_PAGE = String.raw`(?:\s+(?:you(?:'re| are| were)? (?:looking for|requested|asked for|(?:tried|were trying|are trying) to (?:reach|visit|access|find|open))|that you (?:requested|asked for)|at\s+\S[^.!?]{0,40}|on this (?:site|server|website)))?`;
+var DOESNT_EXIST = String.raw`(?:\b(?:this|that|the|requested)\s+(?:[a-z0-9'-]+\s+){0,2}(?:page|url|link|post|article|listing|product|resource|project|profile|record|entry|story|event|course|job|item|offer|video)|\bpage)${WHICH_PAGE}\s+(?:doesn't|does not)(?: (?:seem|appear))?(?: to)? exist(?!\s+(?:to|for|so)\s)`;
+var MAINTENANCE_QUALIFIER = String.raw`(?!\s+(?:on|from|every|each|this|next|between|during|at|after|before|once|twice|monthly|weekly|nightly|daily|contract|agreement|plan|program|warranty|coverage|with\s+(?:us|our)|for\s+(?:the|a|\d)|until(?!\s+(?:\d{1,2}(?::\d\d)?\s*(?:[ap]\.?m\b|o'clock)|\d{1,2}:\d\d|noon|midnight|tomorrow|further notice)))\b)`;
+var ERROR_PAGE_SIGNATURES = [
+  // ---- Not found: the framework defaults and the common custom wordings ----
+  new RegExp(RECORD_NOUN + " (?:was |is )?not found" + NOT_A_QUESTION + NOT_IN_YOUR_SIZE),
+  // "Can't find the page you need? Use the search box" is a help line; "We can't find that page." isn't.
+  /(?:can't|cannot|can not|couldn't|could not|unable to) (?:be )?(?:find|found|locate)(?: that| this| the)? page(?!\s*\?|\s+(?:you|that|which)\b[^.!?]{0,40}\?)/,
+  // "We can't seem to find the page", "It seems we can't find what you're looking for".
+  /(?:we|i) (?:can't|cannot|couldn't|could not|were unable to|are unable to|weren't able to)(?: seem to)? (?:find|locate) (?:that page|this page|the page|that one|that(?=[.!,?]| link)|what you(?:'re| are| were)? looking for)/,
+  // "can not" is two words in the Vercel default.
+  new RegExp(CANT_BE_FOUND),
+  // Next's own not-found.tsx example: "Not FoundCould not find requested resourceReturn Home".
+  /(?:could not|couldn't) find (?:the )?requested resource/,
+  // "doesn't exist" only with a page, link or record as the subject: a short
+  // marketing page can say "if a tool doesn't exist, we'll build it".
+  new RegExp(DOESNT_EXIST),
+  /(?:doesn't|does not) exist or (?:has|have) been (?:moved|removed|deleted)/,
+  /looking for (?:doesn't|does not) exist/,
+  // A page-ish subject, like "doesn't exist" above: a history page can say "the 1890 mill no longer exists".
+  new RegExp(String.raw`\b(?:this|that|the)\s+(?:[a-z0-9'-]+\s+){0,2}(?:page|url|link|project|post|article|product|listing|resource|content|item|offer|event|record|story|profile|entry|document|course|job|video)` + WHICH_PAGE + String.raw`\s+no longer exists`),
+  /(?:404: ?not[ _]found|code: ?not_found)/,
+  // "Error 404" and "404 Error" as a label ("404 Error | Acme") or leading into what a 404 says
+  // ("Error 404Page not found"). Not "a custom 404 error page" and not a name ("Error 404 Studio").
+  /(?:^|[.!?|:]\s*)(?:http |server )?(?:error 404|404 error)(?=\s*[-–—|:.!?,)]|\s*(?:page|this|that|the|we|oops|whoops|sorry|looks|uh|hmm|nothing|there|it|oh|please)\b)|(?:error 404|404 error)(?=\s*$|\s*[-–—|:]?\s*(?:not found|this (?:page|url)|that page)\b)/,
+  // "The page you requested was not found", "The page you were looking for has been removed".
+  /page you (?:requested|(?:were|are) looking for|tried to (?:reach|visit|access))[^.!?]{0,60}(?:not found|no longer|(?:has|have|had|might have|may have|may) been|has (?:drifted|wandered|vanished|disappeared|moved|left)|isn't|is not|doesn't|does not|could not|can't|cannot|was not)/,
+  // Apache, Flask and Django: "The requested URL was not found on this server."
+  /requested (?:url|uri|resource|file|page|document)\b[^.!?]{0,80}(?:not found|not be found|cannot be found)|(?:was|is) not found on (?:this|the) server/,
+  // Netlify, Render, Flask and Express answer with the bare words "Not Found".
+  /^not found(?=$|\s*[-–—|:.!]|the requested|request id)/,
+  // WordPress core and its default themes: "It looks like nothing was found at this location.", "Nothing Found".
+  /nothing was found at this location|^nothing found(?=$|[.,:;!?|-]|sorry|it looks|we couldn|nothing|oops|the page)/,
+  // Custom 404 copy that never says "404": "Oops! This page took a day off.", "You've hit a dead end.",
+  // "This page doesn't live here anymore." The opener needs the page to be the one that's gone ("Oops! This
+  // page is a work in progress" is a holding page), and the dead end needs to be a sentence of its own.
+  /^(?:oops|whoops|uh[- ]oh)[!,.…]*\s*(?:this|that) page (?:took|went|wandered|got lost|ran away|has (?:gone|wandered|moved|left|vanished|disappeared|been (?:removed|moved|deleted))|is (?:missing|gone|lost)|isn't (?:here|available|there)|(?:doesn't|does not|can't|cannot|couldn't) (?:exist|be found|seem)|seems? (?:to be )?(?:missing|lost|gone))/,
+  /(?:^|[.!?]\s*)(?:you've|you have|you) (?:hit|reached) a dead end(?=[.!?…]|$)/,
+  /(?:page|link|url)[^.!?]{0,40}(?:doesn't|does not|no longer|isn't|is not) (?:live |exist |work )?here(?: anymore)?(?![a-z]*\s+to\b)/,
+  // Gatsby's 404 route: "NOT FOUNDYou just hit a route that doesn't exist... the sadness."
+  /hit a route that doesn't exist/,
+  // Tomcat and IIS: "HTTP Status 404 – Not Found", "HTTP Error 403.14 - Forbidden", "HTTP Error 503. The service is unavailable."
+  /http (?:error|status) [45]\d\d(?:\.\d+)?\s*[–—-]\s*(?:not found|forbidden|unauthori[sz]ed|bad request|internal|method not allowed|service unavailable)|http error [45]\d\d(?:\.\d+)?\. the /,
+  // A status number with its reason, anywhere in the head (a nav can precede it):
+  // "404 | Not Found", "502 - Bad Gateway", "403: Forbidden", "400Bad Request", "419 | Page Expired".
+  // Not "401 unauthorized means your key is missing": a status explained is documentation.
+  /(?:^|\D)(?:(?:404|410)\s*[|:–—-]?\s*(?:not found|page not found|file not found|web site not found)|408[\s:|–—-]*request time-?out|50[0-4][\s:|–—-]*(?:internal (?:server )?error|server error|bad gateway|service (?:temporarily )?unavailable|gateway time-?out)|40[13][\s:|–—-]*(?:forbidden|unauthori[sz]ed)|400[\s:|–—-]*bad request|405[\s:|–—-]*method not allowed|413[\s:|–—-]*(?:request entity|payload|content) too large|419[\s:|–—-]*page expired|429[\s:|–—-]*too many)(?!\s+(?:(?:requests?|errors?|responses?|status(?: codes?)?|codes?|messages?|pages?)\s+)?(?:means?|is|are|indicates?|occurs?|happens?|when|if|returns?|tells?|shows?|appears?|can|should|will|occurred)\b)/,
+  // Netlify's bare "Not Found - Request ID: ..." and Express's "Cannot GET /about", even with a nav in front.
+  /not found\s*[-–—]\s*request id|\bcannot (?:get|post|put|patch|delete) \/[\w\-./?=&%]*(?:$|\s)/,
+  // IIS's classic "Server Error 404 - File or directory not found." and its "had its name changed" sentence.
+  /file or directory not found|removed,? had its name changed/,
+  // This page has been removed / moved: its own sentence, not "removed from our menu".
+  /(?:^|[.!?]\s*)this page (?:has been |has |was |is )?(?:permanently )?(?:removed|deleted|moved)(?=[.!,;]|$|\s+(?:or|and)\b|\s*(?:return|go|back|click|please|visit|head)\b)/,
+  // ---- Server and client errors ----
+  // Not "Application error monitoring for Node teams".
+  /^application error(?!\s+(?:monitoring|tracking|reporting|handling|management|detection|analytics|logs?|alerts?|rates?|budgets?|codes?))/,
+  /(?:client|server)-side exception has occurred/,
+  // The hosts spell a status as a code too: "500: INTERNAL_SERVER_ERROR", "504: GATEWAY_TIMEOUT".
+  /internal[ _]server[ _]error/,
+  new RegExp(String.raw`(?:bad[ _]gateway|gateway[ _]time-?out)` + NOT_A_QUESTION),
+  // An exception's message rendered as the page: "Error: Failed to fetch data", "TypeError: x is undefined".
+  /^(?:(?:type|reference|syntax|range)error: |error: (?:failed|cannot|can't|unable|invalid|network|request|fetch|something|unexpected|no |not ))/,
+  // "Something went wrong with your insurance claim? ..." is a headline about a claim, not an error state.
+  new RegExp(String.raw`something(?: went|'s gone| has gone| had gone) wrong(?!\s+(?:with|during|on|in|at)\s+(?:your|my)\b)` + NOT_A_QUESTION),
+  /an (?:unexpected )?error (?:has )?occurred/,
+  /this (?:page|site|website) (?:isn't working|can't be reached)/,
+  // Next.js 16 error shells: "This page couldn't load. A server error occurred. Reload to try again."
+  // and the 403 / 401 pages ("This page could not be accessed.").
+  /this page couldn't load|a server error (?:has )?occurred|reload to try again(?=[.,!]|$)|this page could not be accessed/,
+  // React Router and Remix, Spring Boot, and the "unexpected error" boundaries.
+  /unexpected application error|whitelabel error page|(?:there was|encountered) an unexpected error/,
+  // Django and ASP.NET: "Server Error (500)", "Server Error in '/' Application", "Not Found (404)".
+  /server error (?:\(500\)|in '?\/)|(?:bad request|forbidden|not found) \((?:400|403|404)\)/,
+  // Next's runtime messages when a chunk or a hydration fails and the message is the page.
+  /chunkloaderror|loading chunk [\w/.-]+ failed|hydration failed because the|there was an error while hydrating/,
+  // Generated error.tsx boundaries: "Oops, we hit a snag.", "Something unexpected happened", "Unable to load page".
+  new RegExp(
+    String.raw`(?:^|[.!?]\s*)(?:(?:oops|whoops|uh[- ]oh)[!,.…]*\s*)?we hit a snag(?!\s+(?:with|in|on|during|when|while|at)\b)|(?:^|[.!?]\s*)something unexpected happened|(?:^|[.!?]\s*)(?:failed|unable) to load (?:the |this )?(?:page|content|data|resource)` + NOT_A_QUESTION + String.raw`|^error loading (?:the |this )?(?:page|content|data)`
+  ),
+  // "We're having trouble loading this page", "We couldn't load this page".
+  /(?:we're|we are|i'm) having (?:some )?(?:trouble|difficulty|difficulties|problems?) (?:loading|displaying|showing|retrieving) (?:this|that|the) (?:page|content)|we (?:couldn't|could not|can't|cannot) load (?:this|that|the) page/,
+  // WordPress core's fatal-error and database screens.
+  /there has been a critical error on this (?:website|site)|error establishing a database connection|(?:the|this) (?:site|website) is experiencing technical difficulties/,
+  // Apache's stock pages: 503, 400, 401, 408, 410 and 414 each in its own words.
+  /the server is temporarily unable to service your request|your browser sent a request that this server could not understand|this server could not verify that you are authorized|server timeout waiting for the http request|(?:was|is) no longer available on this server|request-uri too large/,
+  // ---- Unavailable and maintenance ----
+  // A qualifier ("in Hawaii", "until April") makes it content about a service, not a dead page.
+  /(?:this|the) (?:page|site|website|service) (?:is|are) (?:temporarily|currently) unavailable(?!\s+(?:in|on|for|at|during|to|until|from|outside|after|before|through)\b)/,
+  /^(?:service (?:temporarily )?unavailable|(?:temporarily|currently) unavailable(?!:\s))(?!\s+(?:in|on|for|at|during|to|until|from|outside)\b)/,
+  // The site or the page is the one under maintenance. Not "is under maintenance contract", not "down for
+  // maintenance on Fridays": a day, a time or a contract makes it content.
+  new RegExp(String.raw`(?:site|website|page|store|shop|app|portal|server|we're|we are)(?: is| are)?(?: currently| temporarily| now)*,? (?:under|down for) (?:scheduled |routine |some |emergency )?maintenance` + MAINTENANCE_QUALIFIER),
+  // "Our website is currently undergoing scheduled maintenance", "Briefly unavailable for scheduled maintenance",
+  // "We are offline for a short while". Not "Our rental fleet is undergoing routine maintenance": the subject is the site.
+  new RegExp(String.raw`(?:(?:site|website|page|store|shop|app|portal|server|we're|we are)(?: is| are)?(?: currently| temporarily| now)*|briefly|temporarily|currently|now) (?:undergoing|(?:offline|unavailable|down)(?: temporarily)? for) (?:scheduled |routine |some |emergency )?maintenance` + MAINTENANCE_QUALIFIER),
+  /(?:we're|we are|site is|website is) offline for an? (?:short|little|brief) (?:while|time|period)/,
+  /^be right back\.?$/,
+  // "We'll be back soon." ending its sentence, or leading into the next one. Not "We should be back soon with a replacement
+  // part", "back soon after our holiday break": what follows decides.
+  /(?:we'll|we will|we should|it should) (?:be )?(?:right )?back (?:online )?(?:soon|shortly)(?=[.!;]|$|,?\s*(?:our|the|this|thank|thanks|please|we)\b|\s+(?:once|after)\s+(?:a|the|our)\s+(?:(?:short|brief|quick|scheduled|planned)\s+)*(?:maintenance|upgrade|update|outage|downtime|migration|work)\b)/,
+  // An apology for the downtime makes what follows an outage notice, whatever it promises.
+  /sorry for the (?:downtime|inconvenience|interruption|outage)\W+(?:we'll|we will|we should|we are working)/,
+  // ---- Walls that stand in for the page ----
+  new RegExp(String.raw`(?:403 forbidden|access denied)(?!\s+(?:is|was|means|errors?|messages?|pages?)\b)` + NOT_A_QUESTION),
+  // A permission wall is addressed to the visitor and about THIS page or resource, and opens the text or follows its own
+  // heading ("Sorry, you are not allowed to access this page.", "ForbiddenYou are not authorized to access this resource.").
+  // Not a person or a file ("our team is not allowed to access this page of your file"), not a gallery ("you don't have
+  // permission to view the gallery"), and not a sentence further in ("Members only. You do not have permission to ...").
+  /(?:^|sorry|oops|error|forbidden|unauthori[sz]ed|access denied|40[13])\W*you(?:'re| are| aren't) (?:not |un)?(?:allowed|authori[sz]ed|permitted) to (?:access|view|see) (?:this|that) (?:page|resource|site|website|area|section|content)/,
+  /(?:^|sorry|oops|error|forbidden|unauthori[sz]ed|access denied|40[13])\W*you (?:don't|do not) have permission to (?:access|view) (?:this (?:page|resource|site|website|area|section|content)|\S+ on this server)/,
+  /^(?:forbidden|unauthori[sz]ed)(?=$|\s*[-–—|:.!]|you(?:'re| are)\b|please\b|this (?:page|resource))/,
+  /(?:checking your browser before accessing|enable javascript and cookies to continue(?!\s+\w)|verif(?:y|ying) you are (?:a )?human)/
+];
+var LEADING_STATUS = /^(?:(?:http )?error:? ?)?(?:400|401|402|403|405|408|410|413|414|419|429|500|501|502|503|504)\W{0,3}(?:(?:service|server|temporarily|internal|gateway|bad|proxy|request|too|access|page|file|resource|connection|http|status|method|payload|entity|payment|authentication)\s+){0,3}(?:error|forbidden|unauthori[sz]ed|gone|unavailable|bad gateway|time-?out|timed out|not found|not allowed|too many|too large|bad request|page expired|payment required|not implemented)/;
+var LEADING_404 = /^404(?![\d,])(?![\s.\-–—)]*\d)/;
+var ADDRESS_AFTER_404 = /^404\s+(?:[a-z0-9.'-]+\s+){0,3}(?:street|st|avenue|ave|road|rd|boulevard|blvd|drive|dr|lane|ln|way|court|ct|highway|hwy|pike|parkway|pkwy|place|pl|suite|ste|unit|apt)\b/;
+var SHORT_ONLY_SIGNATURES = [
+  // Opening the text, and not conditional: "Please refresh the page and try again." is the boundary's own line;
+  // "Clear your cache, then refresh the page and try again" is a tip, and "...try again if the calendar doesn't load" is one.
+  /^(?:please )?(?:refresh|reload)(?: the| this)? (?:page )?(?:and|or) try again(?!\s+(?:if|when|unless|whether|once|after|later|next|the next)\b)/
+];
+var SHORT_START_SIGNATURES = [new RegExp(String.raw`^(?:[a-z0-9'&-]+\s+){0,2}[a-z0-9'&-]+ not found` + NOT_A_QUESTION + NOT_IN_YOUR_SIZE)];
+var GLUED_404 = /(?:^|[\s|])404(?=[a-z])(?!th\b)/g;
+var DELIMITED_404 = /(?:^|\s)404\s*[|:–—]\s*[a-z]/g;
+var NUMBER_PREFIX = /(?:suite|ste|room|rm|unit|apt|apartment|route|rt|hwy|highway|building|bldg|floor|#)\.?\s*$/;
+var ABOUT_THE_ERROR = String.raw`(?!\W*(?:errors?\b|explained|guide|what (?:it|this|that|is|are)|how to|how do|why|means|fix(?:es|ing)?\b|causes|vs\b|\?))`;
+var PREFIX_SIGNATURES = [
+  new RegExp(String.raw`(?:page|resource|post|article|product|listing) (?:was |is )?not found`),
+  new RegExp(CANT_BE_FOUND),
+  /(?:we|i) (?:can't|cannot|couldn't|could not)(?: seem to)? (?:find|locate) (?:that page|this page|the page|what you(?:'re| are| were)? looking for)/,
+  new RegExp(DOESNT_EXIST),
+  /something went wrong|(?:client|server)-side exception|internal server error|this page couldn't load/
+].map((pattern) => new RegExp("(?:" + pattern.source + ")" + ABOUT_THE_ERROR));
+var PREFIXED_LEADING_404 = new RegExp(LEADING_404.source + ABOUT_THE_ERROR);
+var PREFIXED_LEADING_STATUS = new RegExp(LEADING_STATUS.source + ABOUT_THE_ERROR);
+var PREFIX_SEPARATOR = " \u2014 ";
+var PREFIX_MIN_CHARS = 60;
+var PREFIX_MAX_CHARS = 400;
+var SKIP_LINK = /^(?:skip to (?:main )?content|skip to main|skip navigation)\s*/;
+var PREFIX_WINDOW_CHARS = 90;
+var DESCRIBERS = String.raw`if|when|whether|unless|how to|how do|why|what is|what's|fix(?:ing|es)?|handle|handling|resolve|resolving|troubleshoot(?:ing)?|diagnos(?:e|ing)|watch(?:es|ing)? for|encounter(?:ing)?|history of`;
+var LOWERCASE_DESCRIBERS = String.raw`about|monitor(?:ing)?|alert(?:s|ing)? (?:on|for)`;
+var DESCRIBING_CONTEXT = new RegExp(
+  String.raw`(?:\b(?:(${DESCRIBERS})|(${LOWERCASE_DESCRIBERS}))(?:\s+(?:you|your|the|a|an|their|our|my|see|get|are|is|seeing|getting|receive|receiving|hit|to|every|any|each|all|\d{3})){0,3}\s*["'“]?|["“])$`
+);
+var INNER_DESCRIBER = /\b(?:if|when|whether|unless|how to)\b/;
+var SENTENCE_OPENING = /[.!?:;|—–"“(]\s*$/;
+var VISIBILITY_SUBJECT = /\b(?:you|your|we|our|they|their|customers?|clients?|people|visitors?|buyers?|patients?|business(?:es)?|brands?|compan(?:y|ies))\s+$/;
+var FORM_FIELDS = /\b(?:name|e-?mail|phone|message|subscribe|submit)\b/;
+function globalOf(patterns) {
+  return patterns.map((pattern) => new RegExp(pattern.source, "g"));
+}
+var SIGNATURES = globalOf(ERROR_PAGE_SIGNATURES);
+var SHORT_ONLY_SIGS = globalOf(SHORT_ONLY_SIGNATURES);
+var SHORT_START_SIGS = globalOf(SHORT_START_SIGNATURES);
+var PREFIX_SIGS = globalOf(PREFIX_SIGNATURES);
+var TITLE_VERB = /\b(?:fix|handle|resolve|troubleshoot|diagnose)\b/;
+function describerIsProse(orig, start, describer, context) {
+  const word = orig.slice(start, start + describer.length);
+  if (word === describer || word === describer.charAt(0).toUpperCase() + describer.slice(1)) return true;
+  return start === 0 || SENTENCE_OPENING.test(orig.slice(Math.max(0, start - 3), start)) || TITLE_VERB.test(context);
+}
+function isDescribed(head, hit) {
+  const from = Math.max(0, hit.index - DESCRIBE_WINDOW);
+  const before = head.lc.slice(from, hit.index);
+  const context = DESCRIBING_CONTEXT.exec(before);
+  if (context) {
+    const [, describer, lowercaseDescriber] = context;
+    const at = from + context.index;
+    if (describer !== void 0) {
+      if (describerIsProse(head.oc, at, describer, context[0])) return true;
+    } else if (lowercaseDescriber !== void 0) {
+      if (head.oc.slice(at, at + lowercaseDescriber.length) === lowercaseDescriber) return true;
+    } else {
+      return true;
+    }
+  }
+  const inner = INNER_DESCRIBER.exec(hit[0]);
+  if (inner && head.oc.slice(hit.index + inner.index, hit.index + inner.index + inner[0].length) === inner[0]) return true;
+  return /be found$/.test(hit[0]) && VISIBILITY_SUBJECT.test(before) || /you are (?:a )?human$/.test(hit[0]) && FORM_FIELDS.test(head.lc);
+}
+function showsSignature(head, patterns, inFirstSentence = false) {
+  return patterns.some((pattern) => {
+    pattern.lastIndex = 0;
+    for (let hit = pattern.exec(head.lc); hit; hit = pattern.exec(head.lc)) {
+      if (inFirstSentence && /[.!?]/.test(head.lc.slice(0, hit.index))) return false;
+      if (!isDescribed(head, hit)) return true;
+      pattern.lastIndex = hit.index + 1;
+    }
+    return false;
+  });
+}
+function showsLoose404(head) {
+  for (const pattern of [GLUED_404, DELIMITED_404]) {
+    pattern.lastIndex = 0;
+    for (let hit = pattern.exec(head); hit; hit = pattern.exec(head)) {
+      if (!NUMBER_PREFIX.test(head.slice(Math.max(0, hit.index - 14), hit.index))) return true;
+    }
+  }
+  return false;
+}
+function afterPrefix(text) {
+  let start = 0;
+  const cut = text.lc.indexOf(PREFIX_SEPARATOR);
+  if (cut >= PREFIX_MIN_CHARS && cut < PREFIX_MAX_CHARS) start = cut + PREFIX_SEPARATOR.length;
+  const skip = SKIP_LINK.exec(text.lc.slice(start));
+  if (skip) start += skip[0].length;
+  return start === 0 ? text : slice(text, start);
+}
+function opensWith404(head) {
+  return LEADING_404.test(head) && !ADDRESS_AFTER_404.test(head);
+}
+function showsErrorState(head, count) {
+  return opensWith404(head.lc) || LEADING_STATUS.test(head.lc) || showsSignature(head, SIGNATURES) || count <= START_STATE_MAX_WORDS && showsSignature(head, SHORT_START_SIGS) || count <= SHORT_ONLY_MAX_WORDS && (showsSignature(head, SHORT_ONLY_SIGS) || showsLoose404(head.lc));
+}
+function looksLikeErrorPage(text, wordCount) {
+  if (!text || typeof text !== "string") return false;
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  const own = wordsAcrossElements(trimmed);
+  const count = typeof wordCount === "number" && wordCount >= 0 ? Math.max(wordCount, own) : own;
+  if (count > PREFIXED_MAX_WORDS) return false;
+  const whole = textOf(trimmed);
+  const rest = afterPrefix(whole);
+  if (own > ERROR_PAGE_MAX_WORDS) {
+    const lead = rest.lc.slice(0, HEAD_CHARS);
+    return PREFIXED_LEADING_404.test(lead) && !ADDRESS_AFTER_404.test(lead) || PREFIXED_LEADING_STATUS.test(lead) || showsSignature(slice(rest, 0, PREFIX_WINDOW_CHARS), PREFIX_SIGS, true);
+  }
+  if (count > ERROR_PAGE_MAX_WORDS) return false;
+  return showsErrorState(slice(whole, 0, HEAD_CHARS), count) || // A long description pushes the page's own words past the first 300 characters.
+  rest !== whole && showsErrorState(slice(rest, 0, HEAD_CHARS), words(rest.lc));
+}
+function usablePageText(text, wordCount) {
+  if (!text || typeof text !== "string" || !text.trim()) return null;
+  return looksLikeErrorPage(text, wordCount) ? null : text;
+}
+var QUALIFIED = String.raw`(?!\s+(?:in|on|during|until|outside|after|before|from|when|while|if|with|to|through|between|over|due|at(?!\s+(?:this|the)\s+(?:time|moment))|for(?!\s+(?:this|the|that)\s+(?:[\w'’&-]+\s+){0,3}?(?:page|url|link|listing|post|article|project|menu|item|resource|insight|study|portfolio)))\b)`;
+var QUALIFIED_LIGHT = String.raw`(?!\s+(?:when|while|if|until|after|before|during|on|in|from|to|behind|outside|within)\b)`;
+var THE_PAGE = String.raw`\b(?:this|the|that)\s+(?:[\w'’&.-]+\s+){0,4}?(?:page|url|link|route|listing|post|article|project|product|resource|insight|study|portfolio|document)`;
+var ERROR_CLAIMS = [
+  // "Page Not Found", "Project Not Found", and the hyphenated compound a model coins:
+  // "a page-not-found message". Not "Page not found? Use our site map": a question is a help line.
+  new RegExp(String.raw`\b(?:page|project|post|article|listing|product)[\s-]+not[\s-]+found\b(?!\s*\?)`, "i"),
+  // "the pricing page is currently unavailable", "this URL is unavailable", "the page is currently down",
+  // "This page is no longer available", "This URL is not found"
+  new RegExp(
+    String.raw`\b(?:web\s?page|page|url|link|route)(?:\s+(?:from|at|on|for|of)\s+[\w'’&.-]+(?:\s+[\w'’&.-]+){0,4})?\s+(?:is|was|are|were|has\s+been|appears\s+to\s+be|seems\s+to\s+be|remains)\s+(?:(?:currently\s+|temporarily\s+|now\s+)?(?:unavailable|not\s+available|missing|offline|broken|gone)\b` + QUALIFIED + String.raw`|(?:currently\s+|temporarily\s+|now\s+)?(?:down|inaccessible|not\s+accessible|unreachable|not\s+found)\b` + QUALIFIED_LIGHT + String.raw`|no\s+longer\s+(?:available|accessible|reachable|live|online)\b` + QUALIFIED_LIGHT + String.raw`)`,
+    "i"
+  ),
+  // "Page Unavailable", "Page Currently Unavailable"
+  // "offline" only as a state ("the page is offline"): "save any page offline" is a feature.
+  new RegExp(String.raw`\bpage\s+(?:(?:is|was)\s+)?(?:currently\s+|temporarily\s+|now\s+)?(?:unavailable|not\s+available)\b` + QUALIFIED + String.raw`|\bpage\s+(?:is|was)\s+(?:currently\s+|temporarily\s+|now\s+)?offline\b`, "i"),
+  // "an unavailable-page presentation": the hyphenated compound again.
+  /\bunavailable-page\b/i,
+  // "could not be found" (or located, reached, loaded) with a page, URL or link as the subject
+  // The subject is THIS page ("this/the/that ... page"): "why your business page can't be found on Google" is an SEO headline.
+  /\b(?:this|the|that)\s+(?:[\w'’&.-]+\s+){0,6}?(?:page|url|link|route)\b[^.|;:]{0,60}?\b(?:could\s+not|couldn(?:'|’)t|can(?:'|’)t|cannot)\s+be\s+(?:found|located|reached|loaded|displayed|shown)\b/i,
+  // "currently returns a 404", "shows a not-found page", "displays a 404 page", "returns an HTTP 404 status"
+  /\b(?:return(?:s|ed|ing)?|show(?:s|ed|ing)?|display(?:s|ed|ing)?|serv(?:e|es|ed|ing)|lands?\s+on)\s+(?:that\s+)?(?:an?\s+|the\s+)?(?:http\s+)?(?:404|not[- ]found|error\s+page)/i,
+  /\b404[\s-]page\b/i,
+  // "details are unavailable", "menu information is unavailable"
+  new RegExp(String.raw`\b(?:details|information|info|content|menu|page)\s+(?:is|are)\s+(?:currently\s+|temporarily\s+)?unavailable\b` + QUALIFIED, "i"),
+  // A sentence that opens with the page as its subject: "This insight is unavailable."
+  // ...and the sentence's subject has to BE a page-like thing: "The patio is not available on Fridays" is about a patio.
+  new RegExp(String.raw`(?:^|[.!?]\s+)(?:this|the)\s+(?:[^.!?|\s][^.!?|]{0,69}?\s+)?(?:page|url|link|route|insight|article|post|project|study|resource|portfolio|guide|document)(?:\s+(?:you|that|which)\s+[^.!?|]{0,40}?)?\s+is\s+(?:currently\s+|temporarily\s+)?(?:unavailable|not\s+available)\b` + QUALIFIED, "i"),
+  // JSON-LD labels: "Unavailable Harbor Buffet page". A label, not "block unavailable dates on your booking page".
+  /(?:^|[|:.!?–—-]\s*)unavailable\s+(?:[\w'’&-]+\s+){0,6}?(?:page|url|menu|insight|article|project)\b/i,
+  // "This page doesn't exist.", "This page does not currently exist.", "No page exists at this address."
+  new RegExp(THE_PAGE + String.raw`\s+(?:(?:does\s+not|doesn['’]t)\s+(?:currently\s+|seem\s+to\s+|appear\s+to\s+)?exist|no\s+longer\s+exists?)\b(?!\s+(?:for|so)\s)` + QUALIFIED_LIGHT, "i"),
+  /\bno\s+(?:page|content|resource|listing)\s+exists?\s+(?:at|for|on|here)\b/i,
+  // "This page has been removed or moved.", "This listing has been removed." Moved to somewhere ("moved to our new site") is a redirect note.
+  new RegExp(THE_PAGE + String.raw`\s+(?:has|have|had)\s+(?:since\s+)?been\s+(?:permanently\s+)?(?:removed|moved|deleted|taken\s+down)\b` + QUALIFIED, "i"),
+  // "The page you're looking for isn't available.", "The page you requested has been removed."
+  new RegExp(
+    String.raw`\bpage\s+you(?:['’]re|\s+are|\s+were)?\s+(?:looking\s+for|requested|tried\s+to\s+(?:reach|visit|access))\s+(?:(?:is(?:n['’]t|\s+not)|was(?:n['’]t|\s+not))\s+(?:available|found|here|there|accessible)\b` + QUALIFIED + String.raw`|(?:has|have|might\s+have|may\s+have)\s+been\s+(?:removed|moved|deleted|renamed)\b|(?:doesn['’]t|does\s+not)\s+exist\b|no\s+longer\s+(?:exists?|available)\b)`,
+    "i"
+  ),
+  // "The page failed to load." (past tense: "if a page fails to load, refresh" is advice).
+  /\b(?:page|url|link|route)\s+(?:has\s+)?failed\s+to\s+load\b/i,
+  // "This URL contains only an error message.", "The page returned an error message instead of service details."
+  // Not "The checkout page shows an error message when payment fails."
+  new RegExp(String.raw`\b(?:page|url|link|route)\s+(?:currently\s+)?(?:(?:returned|returns?|displays?|displayed|shows?|showed|serves?|served)\s+(?:only\s+)?|(?:contains?|contained)\s+only\s+)(?:an?\s+|the\s+)?(?:error\s+(?:message|page)|http\s+error|not[- ]found\s+(?:message|error|page))\b(?=\s*(?:[.!?;:,|]|$)|\s+(?:instead|rather|in\s+place|and|but|only|with\s+no|with\s+nothing)\b)`, "i"),
+  // "404 Error | Acme Mowing", "Error 404: Acme Mowing", "HTTP 404", "404 Not Found | Acme": a label opening the copy or a segment of it.
+  /(?:^|[|:.!?–—-]\s*)(?:http\s+)?(?:error\s+404|404\s+error|http\s+404)\s*(?:[|:–—.!?-]|$)|\b404[\s:|–—-]*not\s+found\b/i,
+  // "This page isn't available.", "This page wasn't found." (the contracted forms of the above)
+  new RegExp(String.raw`\b(?:web\s?page|page|url|link|route)\s+(?:is|was)(?:n['’]t)\s+(?:currently\s+|now\s+)?(?:available|found|accessible|here|live)\b` + QUALIFIED_LIGHT, "i"),
+  // "We couldn't find this page on the Acme website.", "Sorry, we can't find that page.", "We could not locate the page you requested."
+  // Not "Can't find the page you need? Use search": a question in the same sentence is a help line.
+  /\b(?:we|i)\s+(?:could\s+not|couldn['’]t|can['’]t|cannot|(?:were|was|are|am)\s+unable\s+to|weren['’]t\s+able\s+to)\s+(?:seem\s+to\s+)?(?:find|locate)\s+(?:this|that|the)\s+(?:requested\s+)?(?:web\s?page|page|url|link)\b(?![^.!?]*\?)/i,
+  // "Unable to find the requested page."
+  /\bunable\s+to\s+(?:find|locate)\s+(?:this|that|the)\s+requested\s+(?:web\s?page|page|url|link|resource)\b/i,
+  // "The requested URL was not found on this server."
+  /\brequested\s+(?:url|uri|resource|page)\b[^.!?]{0,60}?\b(?:was\s+not|wasn['’]t|could\s+not\s+be|cannot\s+be)\s+found\b/i,
+  // "Page missing", "Error loading page": labels (a segment or the whole copy), not "pages missing from the index".
+  /(?:^|[|:.!?–—-]\s*)(?:page\s+(?:is\s+)?missing|error\s+loading\s+(?:the\s+)?page|not\s+found)\s*(?:[|:–—.!?-]|$)/i
+];
+function ownTextOf(pageText) {
+  return pageText && typeof pageText === "string" && !looksLikeErrorPage(pageText) ? normalize(pageText) : "";
+}
+var CLAIM_MAX_CHARS = 5e3;
+function claimIn(copy, own) {
+  const text = copy.replace(/\s+/g, " ").trim().slice(0, CLAIM_MAX_CHARS);
+  if (!text) return null;
+  for (const claim of ERROR_CLAIMS) {
+    const hit = text.match(claim);
+    if (!hit) continue;
+    const phrase = hit[0].replace(/^[.!?|:–—-]\s*/, "").trim();
+    if (own && own.includes(normalize(phrase))) continue;
+    return phrase;
+  }
+  return null;
+}
+function findErrorPageClaim(copy, pageText) {
+  if (!copy || typeof copy !== "string") return null;
+  return claimIn(copy, ownTextOf(pageText));
+}
+function describesErrorPage(copy, pageText) {
+  return findErrorPageClaim(copy, pageText) !== null;
+}
+var COPY_MAX_DEPTH = 8;
+var COPY_MAX_LEAVES = 2e3;
+var COPY_MAX_TOTAL_CHARS = 1e5;
+function findPageCopyClaim(fields, pageText) {
+  if (!fields || typeof fields !== "object") return null;
+  const own = ownTextOf(pageText);
+  let leaves = 0;
+  let containers = 0;
+  let chars = 0;
+  const spent = () => leaves >= COPY_MAX_LEAVES || containers > COPY_MAX_LEAVES || chars > COPY_MAX_TOTAL_CHARS;
+  const walk = (value, level) => {
+    if (typeof value === "string") {
+      leaves++;
+      chars += Math.min(value.length, CLAIM_MAX_CHARS);
+      return spent() && chars > COPY_MAX_TOTAL_CHARS ? null : claimIn(value, own);
+    }
+    if (!value || typeof value !== "object") return null;
+    if (level >= COPY_MAX_DEPTH || ++containers > COPY_MAX_LEAVES) return null;
+    const record2 = value;
+    for (const key in record2) {
+      if (spent()) break;
+      if (!Object.prototype.hasOwnProperty.call(record2, key)) continue;
+      const phrase = walk(record2[key], level + 1);
+      if (phrase) return phrase;
+    }
+    return null;
+  };
+  const record = fields;
+  for (const key of Object.keys(record)) {
+    if (spent()) break;
+    const phrase = walk(record[key], 1);
+    if (phrase) return { field: key, phrase };
+  }
+  return null;
+}
+
+export { ERROR_PAGE_CONTRACT_VERSION, ERROR_PAGE_MAX_WORDS, describesErrorPage, findErrorPageClaim, findPageCopyClaim, looksLikeErrorPage, usablePageText };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sonordev/contracts",
-  "version": "2.2.0",
-  "description": "The rules Sonor's sites, APIs and dashboard share: popup blocks and site design tokens, site hosts, SEO page identity, title quality, llms.txt sanitizers, the forms honeypot, fleet heartbeats, slot content and signing, site cache tags, portfolio metrics, the house voice's contraction rule and how a proposal's site plan counts its pages. Pure functions, no dependencies.",
+  "version": "2.3.0",
+  "description": "The rules Sonor's sites, APIs and dashboard share: popup blocks and site design tokens, site hosts, SEO page identity, title quality, llms.txt sanitizers, the forms honeypot, fleet heartbeats, slot content and signing, site cache tags, portfolio metrics, the house voice's contraction rule, how a proposal's site plan counts its pages, and what separates an error page from a page's content. Pure functions, no dependencies.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -90,6 +90,11 @@
       "import": "./dist/proposal-sitemap.mjs",
       "require": "./dist/proposal-sitemap.js"
     },
+    "./error-page": {
+      "types": "./dist/error-page.d.ts",
+      "import": "./dist/error-page.mjs",
+      "require": "./dist/error-page.js"
+    },
     "./package.json": "./package.json"
   },
   "typesVersions": {