@sonordev/site-kit 8.5.2 → 8.7.0

package/dist/contracts/llms.d.ts

@@ -6,6 +6,13 @@
  * `@sonordev/site-kit/seo/llms/contract`.
  *
  * @see LLM_GEO_CONTRACT.md in this folder
+ *
+ * It is also where llms.txt's page notes, page titles and page order are
+ * decided, so the Sonor API's index, its fallback file and site-kit's local
+ * generator can't disagree: `pickLlmsPageDescription` (summary, curated meta,
+ * the page's own meta, the schema description, then a cleaned scrape),
+ * `llmsPageTitle`, `isLlmsListablePage`, `selectLlmsPages`, `groupLlmsPages`,
+ * `llmsPageListNote` and `llmsContactLines`.
  */
 /** Increment when public LLMs payload shape changes incompatibly. */
 export declare const LLM_GEO_CONTRACT_VERSION: 1;
@@ -29,8 +36,27 @@ export interface LLMsPayloadMeta {
     llms_disclaimer?: string | null;
 }
 export declare function clipAtWordBoundary(text: string, max: number): string;
+/**
+ * The text with its phone numbers and email addresses taken out. The business's
+ * Contact Information block already carries them, and a page's note is no place
+ * for either.
+ *
+ * Works a sentence at a time: a sentence with a detail in it keeps what comes
+ * before the detail (and before a "call" or "email us at" in front of it) when
+ * that is still a sentence of four words or more, and is dropped otherwise.
+ * "Family-owned HVAC in Cincinnati, call 513-555-1234 today." becomes
+ * "Family-owned HVAC in Cincinnati."; "Call 513-555-1234 for a quote." goes.
+ * Cutting out only the number would leave "for a quote." behind.
+ */
+export declare function stripContactDetails(text: string): string;
+export declare function stripPageFiller(note: string): string;
 /**
  * Public-safe summary for llms.txt `[title](url): notes` — never CRM-only or internal copy.
+ *
+ * A summary that mentions a phone number or an email address loses that part
+ * (`stripContactDetails`) and is still used. It used to be thrown away whole,
+ * and a page with no summary is described by its scrape, so a well-meant
+ * "...call 555-1234" summary made the page's note worse, not safer.
  */
 export declare function sanitizeLlmsPublicSummary(raw: unknown): string | null;
 /**
@@ -53,3 +79,177 @@ export declare function sanitizePrimaryLanguageTag(raw: unknown): string | null;
 export declare function isEmittableReviewNode(node: Record<string, unknown>): boolean;
 /** Pick JSON-LD-safe subset of managed_llm_schema for script injection. */
 export declare function pickManagedLlmSchemaForJsonLd(schema: Record<string, unknown> | null | undefined): Record<string, unknown> | null;
+/** The longest note a page line carries. */
+export declare const LLMS_DESCRIPTION_MAX_LENGTH = 500;
+/**
+ * A page's scraped text (seo_pages.content_text) made fit to describe it.
+ *
+ * The DOM scrape joins elements with nothing between them: a heading, its
+ * tagline and the first paragraph arrive as "Getting paid for the
+ * workIncome, spending, budgets.Track expenses by vendor", a contact page as
+ * "First Name*Last Name*Email*PhoneMessage*Send Message". This puts the
+ * whitespace back, drops what is not about the page (form labels, menu items,
+ * skip links, cookie banners, "Eyebrow · Section" lines) and returns what is
+ * left. It may return '' when nothing worth a note is.
+ *
+ * It does not cut to a length: the caller clips (`clipAtWordBoundary`). It
+ * does not strip phone numbers: that is `stripContactDetails`. `knownTerms`
+ * are words written with a capital inside them that must stay whole.
+ */
+export declare function cleanScrapedPageText(raw: string | null | undefined, options?: {
+    knownTerms?: readonly string[];
+}): string;
+/** Where a page's note came from, best source first. */
+export type LlmsDescriptionSource = 'summary' | 'managed_meta' | 'meta' | 'schema' | 'scrape';
+export interface LlmsDescriptionInput {
+    /** The page's own name: a note that only repeats it says nothing. */
+    title?: string | null;
+    /** seo_pages.llms_public_summary: written for this file. */
+    llms_public_summary?: string | null;
+    /** seo_pages.managed_meta_description: the curated meta description. */
+    managed_meta_description?: string | null;
+    /** seo_pages.meta_description: the meta description the page serves. */
+    meta_description?: string | null;
+    /** The `description` of the page's managed LLM schema. */
+    llm_schema_description?: string | null;
+    /** seo_pages.content_text: the DOM scrape. */
+    content_text?: string | null;
+    /**
+     * True when the page's managed copy says the page itself is missing
+     * (describesErrorPage). That copy, the schema and the page's own meta
+     * description are then not used.
+     */
+    copyWithheld?: boolean;
+}
+/**
+ * The note a page's line in llms.txt carries, and where it came from.
+ *
+ * One rule for every llms.txt Sonor builds, best source first:
+ *
+ *  1. `llms_public_summary`, written for this file, with a phone number or an
+ *     email address taken out rather than the whole summary thrown away;
+ *  2. `managed_meta_description`, the curated meta description;
+ *  3. `meta_description`, the one the page serves;
+ *  4. the managed schema's description;
+ *  5. the cleaned scrape (`cleanScrapedPageText`), last, because it is the
+ *     least written of the five.
+ *
+ * Until 2026-10 the scrape was FIRST: llms.txt, the one file handed straight
+ * to AI crawlers, described a contact page as "First Name*Last Name*Email*".
+ * Every note is cut at a sentence or word boundary at 500 characters. A scrape
+ * that is an error page is not used (`usablePageText`). Returns null when
+ * nothing says anything about the page.
+ */
+export declare function pickLlmsPageDescription(input: LlmsDescriptionInput): {
+    text: string;
+    source: LlmsDescriptionSource;
+} | null;
+/** `pickLlmsPageDescription`'s text. */
+export declare function resolveLlmsPageDescription(input: LlmsDescriptionInput): string | null;
+/**
+ * The note on a page's line, from what the payload carries: its
+ * `llms_public_summary`, then its `description`. With `publicSummaryOnly`
+ * (a site that wants strict notes) only the summary counts. Single source of
+ * truth for the Sonor API's fallback file and site-kit's local generator, which
+ * each had their own copy.
+ */
+export declare function llmsPageListNote(page: {
+    description?: string | null;
+    llms_public_summary?: string | null;
+}, publicSummaryOnly?: boolean): string | undefined;
+export interface LlmsListablePage {
+    path: string;
+    http_status?: number | null;
+    has_noindex?: boolean | null;
+    robots_meta?: string | null;
+    managed_robots_meta?: string | null;
+}
+/**
+ * Whether a live seo_pages row belongs in llms.txt. A page the last visit saw
+ * answer with an error (404, 5xx), a page that asks search engines to leave it
+ * out, and a utility page (a thank-you page, a cart, a login) are not listed:
+ * llms.txt is the index of what a site is, and every dead or unwanted link in
+ * it is one a model may follow and cite. Retired pages never get here
+ * (LIVE_SEO_PAGE_FILTER).
+ */
+export declare function isLlmsListablePage(page: LlmsListablePage): boolean;
+/**
+ * What a page is called in llms.txt: its curated title, else the title it
+ * serves, else its h1, each with the brand suffix off and only when it is a
+ * name and not an address; the home page is `homeName`; else the last segment
+ * of its path as a label. Never the path itself: "[/features/accounting]" was
+ * what a page with no title got.
+ */
+export declare function llmsPageTitle(page: {
+    path: string;
+    managed_title?: string | null;
+    title?: string | null;
+    h1?: string | null;
+}, homeName?: string | null): string;
+/**
+ * Choose which pages survive a page cap.
+ *
+ * A round-robin across top-level sections, not a truncation: cutting an
+ * alphabetical list amputates its tail. On a 191-page site a cap of 50 kept 37
+ * `/industries/*` pages and dropped `/work`, `/pricing`, `/services`,
+ * `/web-design` and `/resources` entirely. Every section is represented at any
+ * cap, and the survivors keep their original order, because the round-robin
+ * decides membership, not presentation. Sections are taken most valuable first
+ * (the order `groupLlmsPages` lists them in, legal pages last), so a cap smaller
+ * than the number of sections drops the least valuable one.
+ *
+ * Single source of truth: the Sonor API caps its index with it, and site-kit's
+ * local generator caps with it instead of `slice(0, max)`.
+ */
+export declare function selectLlmsPages<T extends {
+    path: string;
+}>(pages: T[], cap: number): T[];
+export interface LlmsPageGroup<T> {
+    /** null for the one list of a small site. */
+    heading: string | null;
+    pages: T[];
+}
+/**
+ * The page index in the order and groups an answer engine reads best: the
+ * home page, then the site's top-level pages by value (what it does, where,
+ * the proof, who, the cost, contact), then one group per section of the site
+ * (`/services/*` is "Services"), biggest unlisted sections last, and the legal
+ * pages at the very end. Nothing is dropped or renamed; a list of 12 pages or
+ * fewer is one ungrouped list in the same order.
+ *
+ * Single source of truth for the Sonor API's fallback file and site-kit's
+ * local generator.
+ */
+export declare function groupLlmsPages<T extends {
+    path: string;
+}>(pages: readonly T[]): Array<LlmsPageGroup<T>>;
+/**
+ * The one-line summary under the business name: its tagline, else the first
+ * sentence of its description, else its name. The first sentence comes from
+ * `splitSentences`, not `description.split('.')[0]`, which ends "Smith &
+ * Sons, Inc. is a roofing company" at "Inc".
+ */
+export declare function llmsBlockquoteSummary(business: {
+    name?: string | null;
+    tagline?: string | null;
+    description?: string | null;
+}): string;
+export interface LlmsContactLike {
+    phone?: string | null;
+    email?: string | null;
+    address?: string | null;
+    city?: string | null;
+    state?: string | null;
+    postal_code?: string | null;
+    country?: string | null;
+    hours?: unknown;
+}
+/**
+ * The bullets of the Contact Information block, none for a field that is
+ * empty. An address reads "1 Main St, Springfield, OH 45501", and a
+ * default "US" is not printed. Empty array when there is nothing to show, so a
+ * caller leaves the whole section out rather than print a bare heading.
+ */
+export declare function llmsContactLines(contact: LlmsContactLike | null | undefined): string[];
+/** A page or service link as an absolute URL on the site, so a crawler never resolves it against llms.txt's own address. */
+export declare function llmsAbsoluteUrl(baseUrl: string | null | undefined, pathOrUrl: string): string;

package/dist/contracts/outreach.d.ts

@@ -0,0 +1,267 @@
+/** Bumped when a stored shape here (SegmentGrant, the segment key) changes incompatibly. */
+export declare const OUTREACH_CONTRACT_VERSION = 1;
+/** The badge Signal's outreach writer files and acts under. */
+export declare const OUTREACH_WRITER_BADGE = "signal.outreach.writer";
+/** The ledger kind segments belong to, and its key under settings.autonomy.segments. */
+export declare const OUTREACH_EMAIL_KIND = "outreach_email";
+/**
+ * Signal's one graduation bar: a track record earns sending without a click
+ * per item once at least minMeasured are measured, at least minWinRate of
+ * them won, and none degraded without being undone. Single source of truth
+ * for both APIs: Signal measures a kind or a segment against it, and an
+ * earned segment grant needs minMeasured receipts wherever
+ * grantEvidenceRefusal checks one.
+ */
+export declare const GRADUATION_BAR: {
+    readonly minMeasured: 5;
+    readonly minWinRate: 0.7;
+    readonly maxUnrevertedDegradations: 0;
+};
+/**
+ * A segment's standing, one vocabulary everywhere:
+ *  - ungranted: nobody turned it on (its next email is a first email);
+ *  - granted: a person turned it on and it's sending without a per-email click;
+ *  - paused: it stopped itself (a quality loss or a list signal) until a person resumes it;
+ *  - lapsed: the pitch changed since it was turned on, so its next email is a first email again;
+ *  - revoked: a person stopped it.
+ * "Awaiting first approval" is a drip check's answer, never a stored state.
+ */
+export declare const SEGMENT_STATES: readonly ['ungranted', 'granted', 'paused', 'lapsed', 'revoked'];
+export type SegmentState = (typeof SEGMENT_STATES)[number];
+export type OutreachSegmentSource = 'drip' | 'mcp';
+/** The vertical of a lead with no industry. Never grantable. */
+export declare const UNSPECIFIED_INDUSTRY = "unspecified";
+/**
+ * A prospect's industry as written, in the one order every caller uses: the
+ * target company's vertical, then its industry, then the lead's
+ * company_industry. Null when none is set.
+ */
+export declare function prospectIndustry(prospect: {
+    vertical?: unknown;
+    industry?: unknown;
+    company_industry?: unknown;
+} | null | undefined): string | null;
+/**
+ * An industry as it appears in a segment key: NFKC, accents folded, lowercase,
+ * "&" read as "and", every run of anything that isn't a-z or 0-9 a single
+ * "-", trimmed, at most 48 characters. Empty is 'unspecified'. There's no
+ * synonym table: "Roofing" and "Roofers" are two segments.
+ */
+export declare function normalizeIndustry(value: unknown): string;
+/** The fields of an outreach_narratives row that are its pitch. Its name, its switch and its forbidden phrases aren't. */
+export declare const NARRATIVE_PITCH_FIELDS: readonly ['positioning_statement', 'target_icp_description', 'tone_profile', 'hook_types', 'example_angles', 'value_prop_bullets'];
+/** A narrative row, or any object carrying its pitch fields; every other column (name, enabled, forbidden_phrases, ...) is read past. */
+export type NarrativePitch = {
+    [K in (typeof NARRATIVE_PITCH_FIELDS)[number]]?: unknown;
+} & Record<string, unknown>;
+/**
+ * The narrative's pitch, fingerprinted: FNV-1a of canonical JSON of
+ * NARRATIVE_PITCH_FIELDS only. Rewriting the pitch changes it, and that
+ * lapses a segment's grant. Renaming the narrative, switching it on or off,
+ * or tightening its forbidden phrases or avoid_tone doesn't: those take
+ * effect at once through the checker and the prompt.
+ */
+export declare function narrativeFingerprint(narrative: NarrativePitch | null | undefined): string;
+/** target_ref.segment on an outreach_email row: stamped once, at filing. */
+export interface OutreachSegment {
+    key: string;
+    source: OutreachSegmentSource;
+    narrative_id: string | null;
+    mailbox_id: string | null;
+    vertical: string;
+    label: string;
+    angle_fp: string | null;
+}
+/**
+ * A segment: which pitch, from which mailbox, to which kind of business.
+ *  - drip: `drip:<narrative uuid>@<mailbox uuid>|<vertical>`. Null when either id isn't a UUID.
+ *  - mcp: `mcp:-|<vertical>`. For metrics only; never granted.
+ */
+export declare function outreachSegment(input: {
+    source: OutreachSegmentSource;
+    narrativeId?: string | null;
+    mailboxId?: string | null;
+    industry?: unknown;
+    label?: string | null;
+    angleFp?: string | null;
+}): OutreachSegment | null;
+/** A segment's label: "<narrative name> to <industry as written>, from <mailbox address>". */
+export declare function outreachSegmentLabel(input: {
+    narrativeName?: unknown;
+    industry?: unknown;
+    mailboxAddress?: unknown;
+}): string;
+export type ParsedOutreachSegmentKey = {
+    source: 'drip';
+    narrative_id: string;
+    mailbox_id: string;
+    vertical: string;
+} | {
+    source: 'mcp';
+    vertical: string;
+};
+/**
+ * A segment key, parsed strictly, or null. Nothing else is ever used as a key
+ * in projects.settings, so a caller-chosen key ("__proto__", a long string)
+ * is refused before any read or write.
+ */
+export declare function parseOutreachSegmentKey(key: unknown): ParsedOutreachSegmentKey | null;
+/**
+ * Whether a segment can ever be turned on: a drip segment with a known
+ * industry. An mcp segment, or a lead with no industry, always waits for a
+ * person. (A row whose recipient Sonor already knows waits too; that's the
+ * row's relationship, checked separately.)
+ */
+export declare function isGrantableSegmentKey(key: unknown): boolean;
+/**
+ * A person's standing approval of one segment, at
+ * projects.settings.autonomy.segments.outreach_email[key]. Written only by
+ * Signal's AutonomyPolicyService.setSegmentGrant, refused on every generic
+ * settings writer, and only ever trusted after grantEvidenceRefusal passes.
+ */
+export interface SegmentGrant {
+    state: 'granted' | 'revoked';
+    /** first_email: a person approved the segment's first email unedited with "Send the rest like this". earned: they accepted Signal's offer once the bar was met. */
+    source: 'first_email' | 'earned';
+    /** contacts.id of the person who turned it on. */
+    by: string;
+    /** Where they did it. Never MCP. */
+    via: 'dashboard' | 'drafts';
+    at: string;
+    /** first_email: the ledger id of that email. earned: the offer's dedup key. */
+    ref: string;
+    /** earned: the ledger ids of the wins that earned it. */
+    receipts?: string[];
+    /** The mailbox it sends from. A grant never covers another mailbox. */
+    mailbox_id: string;
+    label: string;
+    /** narrativeFingerprint when it was turned on. A rewritten pitch lapses it. */
+    angle_fp: string;
+    /** Stopped itself. Cleared only by a person's resume. */
+    paused?: {
+        at: string;
+        reason: string;
+        loss_ref: string | null;
+    };
+    resumed?: {
+        by: string;
+        at: string;
+    };
+    revoked?: {
+        by: string;
+        at: string;
+        reason: string;
+    };
+}
+/**
+ * Every well-formed grant, by segment key. Pass projects.settings or its
+ * autonomy document. A key that doesn't parse strictly, or a grant that isn't
+ * the SegmentGrant shape, is left out: an unreadable grant counts as no grant.
+ */
+export declare function readSegmentGrants(source: unknown): Record<string, SegmentGrant>;
+/** The grant for a segment when it's live (granted, not paused, on a grantable key), else null. Evidence is checked separately. */
+export declare function activeSegmentGrant(source: unknown, key: string): SegmentGrant | null;
+export type SegmentGrantCoverage = {
+    covers: true;
+} | {
+    covers: false;
+    code: 'not_granted' | 'revoked' | 'paused' | 'other_person' | 'granted_after' | 'angle_changed' | 'other_mailbox';
+    reason: string;
+};
+/**
+ * Whether a live grant covers one row: refused when there's no grant, it was
+ * revoked or paused, the row names another approver, the row was filed
+ * before the grant, the pitch changed since (a different fingerprint), or the
+ * row sends from another mailbox.
+ */
+export declare function segmentGrantCovers(grant: SegmentGrant | null | undefined, row: {
+    by?: string | null;
+    createdAt: string | null | undefined;
+    angleFp: string | null | undefined;
+    mailboxId: string | null | undefined;
+}): SegmentGrantCoverage;
+/** The columns of a signal_proposals row grantEvidenceRefusal reads. */
+export interface GrantEvidenceRow {
+    id: string;
+    kind: string;
+    status: string;
+    project_id?: string | null;
+    created_by?: string | null;
+    reviewed_by?: string | null;
+    reviewed_at?: string | null;
+    target_ref?: unknown;
+    payload?: unknown;
+}
+export interface GrantEvidenceScope {
+    /** The segment key the grant is stored under. */
+    key: string;
+    /** GRADUATION_BAR.minMeasured: how many receipts an earned grant needs. */
+    minMeasured: number;
+    /** The project the grant is stored on. Rows from another project never count. */
+    projectId?: string | null;
+    /** contacts.id of reviewers known to be people (not agents). When given, every reviewer must be in it. */
+    people?: ReadonlySet<string> | ReadonlyArray<string> | null;
+}
+/**
+ * Why a grant can't be trusted, or null when the ledger rows it cites stand
+ * behind it. A grant that fails counts as no grant, so a grant forged into
+ * settings never sends anything.
+ *
+ * - first_email: grant.ref is an applied outreach_email the writer filed in
+ *   this project and segment, from the grant's mailbox, approved by grant.by
+ *   at or before grant.at, in Sonor (via dashboard or drafts, never MCP),
+ *   unedited, and read back verified.
+ * - earned: at least scope.minMeasured distinct receipts, each an applied
+ *   writer row in this segment and mailbox, for the same pitch, approved by a
+ *   person in Sonor at or before grant.at, unedited and read back verified.
+ */
+export declare function grantEvidenceRefusal(grant: SegmentGrant | null | undefined, refRows: ReadonlyArray<GrantEvidenceRow> | null | undefined, scope: GrantEvidenceScope): string | null;
+/** The live roles of the person asking, read by the caller. */
+export interface SegmentGranterRoles {
+    contact_type?: string | null;
+    is_platform_admin?: boolean | null;
+    /** Their role in the project's org. */
+    org_role?: string | null;
+    /** Their role on the project itself. */
+    project_role?: string | null;
+    /** Their role in the agency that manages the project's org. */
+    managing_org_role?: string | null;
+}
+/**
+ * Whether this person may turn a segment on (or resume it): never an agent
+ * contact; otherwise a platform admin, or an owner or admin of the project,
+ * its org, or the agency that manages that org.
+ */
+export declare function segmentGranterEligible(roles: SegmentGranterRoles | null | undefined): boolean;
+/**
+ * Domains anyone can sign up for. A matching address says nothing about the
+ * company someone works for, so a relationship check never matches on one.
+ */
+export declare const PUBLIC_MAILBOX_DOMAINS: ReadonlyArray<string>;
+/** Whether an address or a domain is a public mailbox provider's. Case and a leading "mailto:" or "@" don't matter. */
+export declare function isPublicMailboxDomain(value: unknown): boolean;
+/**
+ * - live: still waiting on a person or a held send. Leave the lead reserved.
+ * - sent: the email went out. The lead moves on.
+ * - retire: a person said it shouldn't go to this person. Drop the lead.
+ * - declined: a person turned this email down for another reason. The lead goes back in line.
+ * - refile: nothing was decided about the lead (wrong timing, expired,
+ *   superseded, the kind switched off, a send that never went out). It may be
+ *   filed again after its cooldown.
+ */
+export type DripRowDisposition = 'live' | 'sent' | 'retire' | 'declined' | 'refile';
+/** The columns of a signal_proposals row dripRowDisposition reads. */
+export interface DripLedgerRow {
+    status: string;
+    review_reason?: string | null;
+    reviewed_by?: string | null;
+    autonomy_decision?: unknown;
+    payload?: unknown;
+}
+/**
+ * What a drip's ledger row means for its lead. Signal's filing dedup and the
+ * Sonor API's reservation release both read it, so "decided" means one thing.
+ * A status it doesn't know reads as live: a lead stays reserved rather than
+ * being written to twice.
+ */
+export declare function dripRowDisposition(row: DripLedgerRow | null | undefined): DripRowDisposition;

package/dist/contracts/page-titles.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Page-titles contract: what a page is called when a list, a sitemap or a
+ * case study needs its own name and not its whole <title>. The Sonor APIs and
+ * the agency site kit import it as `@sonordev/contracts/page-titles`.
+ *
+ * Why it exists: three places each turned a stored title or a URL slug into a
+ * label with their own logic, and they disagreed. "ac-replacement" became "Ac
+ * Replacement", "faq" became "Faq", "smith-and-smith" became "Smith And
+ * Smith", and a title with a stray second pipe shipped as "Loans | | Brand".
+ * There's one rule now:
+ *
+ *  - `titleHead` is the page's own name: the title without its trailing
+ *    " | Brand" segment. Prefer it. A page's title is the label it was
+ *    written with, so it beats anything guessed from a URL.
+ *  - `slugLabel` is for the rare case a label has to come from a slug, a file
+ *    name or a path, because the page has no title at all.
+ *  - `isRoutePlaceholder` says whether a value is a framework route
+ *    placeholder (":slug", "[slug]", "[...rest]") and not a page's name.
+ *  - `isPageAddress` says whether a value is a page's address (a path, a
+ *    URL, a route pattern, or the page's own path without its slashes) and
+ *    not its name. It's the one "is this title really a path" rule, so the
+ *    writer of a page list and the reader that prints it can't disagree.
+ *  - `isPageName` says whether a stored title is a name: something is left
+ *    once the pipes are set aside, and no piece between them is an address.
+ *    It's the one rule for a title that gets printed whole, so the writer
+ *    that stores a name and the reader that prints it can't disagree about
+ *    a path, a URL or a placeholder behind a pipe.
+ *
+ * Pure string logic: no I/O, no Node built-ins. The brand split is
+ * seo-meta's `stripTitleSuffix`, imported, never copied: only the LAST
+ * " | " segment of a title is its brand.
+ */
+/**
+ * The page's own name: the title without its trailing " | Brand" segment.
+ *
+ * Whitespace is collapsed first. Stray pipes are repaired before the brand is
+ * cut, so "Loans | | Brand" reads as "Loans | Brand" (a run of pipes with
+ * only whitespace between them is one separator) and a leading or trailing
+ * pipe is dropped ("Pricing |" is "Pricing"). Then the last " | " segment is
+ * the brand and goes; anything before it stays, pipes and all:
+ * "1 Bedroom | 1BR 1BA | Example Apartments" is "1 Bedroom | 1BR 1BA".
+ *
+ * Apply it once to a stored title. A title with two or more separators
+ * loses one segment per call, so its own output isn't a fixed point.
+ *
+ * A title with no separator comes back as written (trimmed): this can't tell
+ * a brand from a name, so a title that's only a brand stays that brand.
+ * Empty, whitespace-only, non-string, null and undefined input give "".
+ */
+export declare function titleHead(title: string | null | undefined): string;
+/**
+ * A readable label for a slug, a file name or a path: "ac-replacement" is
+ * "AC Replacement", "/services/hvac-repair/" is "HVAC Repair".
+ *
+ * Reach for it only when the page has no title (`titleHead` is the page's own
+ * name). It reads the last non-empty path segment of the input, after
+ * dropping a "https://host" origin, a query or a hash, and decodes %-escapes
+ * without ever throwing. A trailing .html, .htm, .php or .aspx is dropped. The
+ * words split on "-", "_", "+" and whitespace.
+ *
+ * Each word is cased by the first rule that fits:
+ *  - an acronym is upper case ("ac", "ai", "cms", "faq", "hvac", "seo",
+ *    "llc", "mls", ...), and "faqs" is "FAQs";
+ *  - a two-letter US state or DC code is upper case ("ky" is "KY"), apart
+ *    from the codes that are ordinary words as often as not ("in", "or",
+ *    "me", "hi", "id", "la", "ma", "pa", "al", "de", "co"). "mt" goes by its
+ *    position: last, it's Montana ("billings-mt" is "Billings MT"); with a
+ *    word after it, it's Mount ("mt-adams" is "Mt Adams"). "us" isn't a
+ *    state: "about-us" is "About Us";
+ *  - a word with a digit keeps its case and only gains a leading capital
+ *    when it starts with a letter ("c1" is "C1", "075ct" stays);
+ *  - a small word ("a", "an", "and", "at", "by", "for", "in", "of", "on",
+ *    "or", "the", "to", "vs", "with") is lower case, unless it's first;
+ *  - anything else is capitalized with the rest lower case.
+ *
+ * Nothing left to label ("", "/", "?x=1") gives "". The home page is the
+ * caller's to name. A label isn't a title: "index" isn't special-cased,
+ * and a brand's own capitalization ("DeWalt") isn't recoverable from a slug.
+ */
+export declare function slugLabel(input: string): string;
+/**
+ * True when the value, or any "/"-separated segment of it, is a framework
+ * route placeholder: a page's pattern leaked into its name ("/floor-plans/:slug",
+ * ":Slug", "[...rest]"). A placeholder is one token with no spaces, so
+ * ordinary text that contains a colon or a bracket isn't one ("Update: new
+ * hours", "FAQ / [draft] notes"). Nullish, empty and non-string values are
+ * false.
+ */
+export declare function isRoutePlaceholder(value: string | null | undefined): boolean;
+/**
+ * Whether `value` is a page's address and not its name: what a page's title
+ * becomes when nothing better was stored (the old sitemap writers saved the
+ * path there), or a pattern that leaked out of the router. True for:
+ *
+ *  - a path, or anything starting with a slash ("/services/ac-repair",
+ *    "//example.com/services");
+ *  - an absolute URL ("https://example.com/services");
+ *  - a host and a path with no scheme ("example.com/services");
+ *  - a route placeholder, as `isRoutePlaceholder` reads it ("/floor-plans/:slug",
+ *    ":Slug", "[slug]");
+ *  - the page's own path written without its slashes. Given `path`, the
+ *    comparison drops leading and trailing slashes from both sides, so for
+ *    "/services/ac-repair" the values "services/ac-repair" and
+ *    "services/ac-repair/" are the address, and for "/faq" the value "faq" is.
+ *    It compares the whole path and it's case-sensitive: "ac-repair" isn't
+ *    the address of "/services/ac-repair", and "Pricing" for "/pricing" is a
+ *    name where "pricing" is the path.
+ *
+ * The value is trimmed first. Empty, whitespace-only, nullish and non-string
+ * values give false: they aren't an address, they're nothing, and the caller
+ * decides what an empty title means. `path` is optional; without it only the
+ * checks that don't need the page's own path run.
+ *
+ * It judges one string. A title with a " | Brand" tail is `titleHead`'s to
+ * cut, and the caller asks about the head: `isPageAddress(titleHead(title), path)`.
+ * Pure string logic, linear in the length of the input.
+ */
+export declare function isPageAddress(value: string | null | undefined, path?: string | null): boolean;
+/**
+ * Whether a stored title is a real name for the page at `path`: something is
+ * left once the pipes are set aside, and none of its pieces is a page's
+ * address (`isPageAddress`, given the page's path). It's the one rule for a
+ * title that gets printed whole, so whoever stores a name and whoever prints
+ * it can't disagree.
+ *
+ * Every piece is judged, the first and the last included, because a title
+ * with a pipe in it prints with its pipes: ":slug | Example Apartments" (a
+ * placeholder in front of a brand tail) and "Floor Plans | /floor-plans/x" (a
+ * path behind the name) are both refused, and so is the unspaced
+ * "Floor Plans|/floor-plans/x". A name with a pipe in it stays a name while
+ * every piece is text ("1 Bedroom | 1BR 1BA"). A title that's only pipes has
+ * no piece and isn't a name. Empty, whitespace-only, nullish and non-string
+ * values aren't names either.
+ *
+ * It judges the title it is given, brand tail and all. A writer cuts the tail
+ * first and asks about what it stores: `isPageName(titleHead(title), path)`.
+ * `path` is optional, as it is for `isPageAddress`. Pure string logic, linear
+ * in the length of the input.
+ */
+export declare function isPageName(title: string | null | undefined, path?: string | null): boolean;