@sonordev/site-kit 8.6.0 → 8.8.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/portfolio.d.ts

@@ -16,16 +16,369 @@
  * must carry, and which numbers may headline. The Sonor API applies the same
  * rules.
  */
-/** The message a cross-origin-framed site-kit page posts to its embedder once it has painted. */
-export declare const FRAME_READY_MESSAGE: 'sonor:frame-ready';
-export interface FrameReadyMessage {
-    type: typeof FRAME_READY_MESSAGE;
-    v: 1;
-}
-/** True for a {@link FrameReadyMessage}, for the embedder's message handler. */
-export declare function isFrameReadyMessage(data: unknown): data is FrameReadyMessage;
+export { FRAME_READY_MESSAGE, isFrameReadyMessage, type FrameReadyMessage } from './frame-ready';
 /** Bump on breaking changes to the collapse policy. */
 export declare const PORTFOLIO_CONTRACT_VERSION: 1;
+/** The four beats, in reading order. */
+export declare const CASE_STUDY_STAGES: readonly ['problem', 'build', 'proof', 'outcome'];
+export type CaseStudyStage = (typeof CASE_STUDY_STAGES)[number];
+/** The generic name of each beat and the question its sections answer. */
+export declare const CASE_STUDY_STAGE_COPY: Record<CaseStudyStage, {
+    name: string;
+    question: string;
+}>;
+/**
+ * A site's own names for the four stages ("Heat", "Shape", "Temper",
+ * "Finish"), set per project in the dashboard (branding is per project) and
+ * read everywhere a stage is named: the editor, the public portfolio config,
+ * the site itself. A stage left unnamed falls back to its generic name. The
+ * ids never change; only what people see does.
+ */
+export type CaseStudyStageNames = Partial<Record<CaseStudyStage, string>>;
+/** The longest a stage name may run. It's a heading word, a rail label, a tab. */
+export declare const STAGE_NAME_MAX_CHARS = 24;
+/**
+ * What's wrong with a set of stage names, or an empty list. Absent passes
+ * (generic names); present must be an object of short text keyed by stage.
+ */
+export declare function stageNamesProblems(names: unknown): string[];
+/** The name a stage is shown under: the site's own when set, else the generic one. */
+export declare function stageName(names: CaseStudyStageNames | null | undefined, stage: CaseStudyStage): string;
+/**
+ * Every section type a case study can hold, in canonical reading order:
+ * hero, then each stage's sections, then the two that aren't rendered as
+ * sections of the story (SEO metadata, the closing CTA). This is THE list;
+ * the Sonor API and agency-site-kit import it rather than keeping their own.
+ */
+export declare const PORTFOLIO_SECTION_TYPES: readonly ['portfolioHero', 'portfolioChallenges', 'portfolioBeforeAfter', 'portfolioStrategy', 'portfolioSiteArchitecture', 'portfolioDesignSystem', 'portfolioFeatureSpotlight', 'portfolioGallery', 'portfolioVideo', 'portfolioTechStack', 'portfolioPerformance', 'portfolioSpeedComparison', 'portfolioVerification', 'portfolioResults', 'portfolioMetricsTimeline', 'portfolioConversionFunnel', 'portfolioServices', 'portfolioTeam', 'portfolioTestimonial', 'portfolioDetails', 'portfolioSeo', 'portfolioCTA'];
+export type PortfolioSectionType = (typeof PORTFOLIO_SECTION_TYPES)[number];
+export declare function isPortfolioSectionType(value: unknown): value is PortfolioSectionType;
+/**
+ * Which stage each section belongs to. Null for the hero (it opens the page,
+ * above the story), SEO metadata (never rendered as a section) and the CTA
+ * (closes the page, after the story). Typed over every section type so a new
+ * type without a stage is a compile error, not a section that renders last.
+ */
+export declare const SECTION_STAGE: Record<PortfolioSectionType, CaseStudyStage | null>;
+/** The stage a section type belongs to, or null when it sits outside the story. Unknown types are null. */
+export declare function sectionStage(type: string): CaseStudyStage | null;
+/**
+ * The one section each stage can't do without, and the one an editor offers
+ * to add when the stage has nothing. A stage with other sections but not its
+ * core (or a stand-in, {@link STAGE_CORE_ALTERNATES}) is told so by
+ * {@link caseStudyStageStatus}: a proof stage that's only a speed comparison
+ * has no measurement of the finished build.
+ */
+export declare const STAGE_CORE_SECTION: Record<CaseStudyStage, PortfolioSectionType>;
+/**
+ * Sections that stand in for a stage's core. A Lighthouse run can only score
+ * what a browser can reach without signing in, so an app whose screens sit
+ * behind a login has no honest Performance section; its proof is a
+ * verification: checks that each say what they cover and what they don't.
+ * Either one completes the proof stage. This is deliberately not gated on
+ * the kind of project: the status below only sees section types, and the
+ * rule for "is this an app" lives with each caller's own data. A verification
+ * is a measurement of the finished build with its limits stated, which is
+ * what the stage asks for. Single source of truth for what completes a stage.
+ */
+export declare const STAGE_CORE_ALTERNATES: Partial<Record<CaseStudyStage, readonly PortfolioSectionType[]>>;
+/** Every section type that completes a stage: its core first, then its stand-ins. */
+export declare function stageCoreSections(stage: CaseStudyStage): PortfolioSectionType[];
+/**
+ * Canonical display order, derived from the list above so it can't disagree
+ * with the stages. Renderers sort by this when nobody has reordered; the
+ * dashboard's stored order only ever moves a section within its stage.
+ */
+export declare const PORTFOLIO_SECTION_ORDER: Record<PortfolioSectionType, number>;
+/**
+ * The least a section needs for the ordering helpers: its type. Anything else
+ * rides along. `data` is optional for them and needed by
+ * {@link caseStudyStageStatus}, which won't count a stand-in section for a
+ * stage's core (a verification) unless its data shows something.
+ */
+export interface SectionLike {
+    sectionType: string;
+    data?: unknown;
+}
+/**
+ * The sections in the order the case study reads.
+ *
+ * The arc always wins: the hero, then problem, build, proof, outcome, then
+ * the CTA. Within a stage, the agency's own order is kept once it has
+ * reordered in the dashboard (`sectionsOrdered`); otherwise the canonical
+ * order. Before this, a reordered case study rendered in exactly its stored
+ * order, so Results could sit above Challenges and the page read backwards.
+ * Never mutates.
+ */
+export declare function orderSections<T extends SectionLike>(sections: readonly T[] | null | undefined, options?: {
+    sectionsOrdered?: boolean;
+}): T[];
+/** One beat of the story with the sections that tell it. */
+export interface CaseStudyStageGroup<T extends SectionLike = SectionLike> {
+    stage: CaseStudyStage;
+    /** 1-based position among the stages this case study actually has. */
+    index: number;
+    sections: T[];
+}
+/**
+ * The story's beats, in order, each with its sections in reading order
+ * ({@link orderSections}). A stage with no sections is left out and the
+ * numbering follows, so a software case study with nothing measured runs
+ * problem, build, outcome as 1, 2, 3. The hero, SEO and CTA aren't in any
+ * group; a renderer places them itself.
+ */
+export declare function groupSectionsByStage<T extends SectionLike>(sections: readonly T[] | null | undefined, options?: {
+    sectionsOrdered?: boolean;
+}): CaseStudyStageGroup<T>[];
+/** What each stage of a case study has and what it's missing. */
+export interface CaseStudyStageStatus {
+    stage: CaseStudyStage;
+    /** The section types present, in reading order. */
+    present: PortfolioSectionType[];
+    /**
+     * True when the stage's core section ({@link STAGE_CORE_SECTION}) is present, or a stand-in for it
+     * ({@link STAGE_CORE_ALTERNATES}) is present with something a page can show. Pass each section's `data`:
+     * a stand-in without it doesn't count.
+     */
+    complete: boolean;
+    /** Null when complete; otherwise one sentence on what the stage is missing. */
+    missing: string | null;
+}
+/**
+ * Each stage's status, all four, in order, whether or not the case study has
+ * sections in it. The dashboard shows these beside the editor so an empty
+ * proof stage is seen before the case study is published, not after.
+ *
+ * A stage's core section completes it by type. A stand-in for the core (a
+ * verification) completes it only when its `data` holds something a page can
+ * show, so pass `data`; without it a stand-in reads as empty, never as done.
+ */
+export declare function caseStudyStageStatus(sections: readonly SectionLike[] | null | undefined): CaseStudyStageStatus[];
+export interface CaseStudyNarrative {
+    /** One sentence: what this project was, in the end. */
+    thesis: string;
+    /** One or two sentences opening each stage, specific to this project. A stage may be left unwritten. */
+    stages: Partial<Record<CaseStudyStage, string>>;
+}
+/** The longest a thesis or a stage lede may run. Longer is a paragraph, and the sections are the paragraphs. */
+export declare const NARRATIVE_MAX_CHARS = 320;
+/**
+ * What's wrong with a narrative, or an empty list when nothing is. An absent
+ * narrative is legacy data and passes (renderers fall back to house copy);
+ * one that's present must be prose, under the length, with no unknown stage.
+ */
+export declare function narrativeProblems(narrative: unknown): string[];
+/** Agent-native contract: JSON Schema for {@link CaseStudyNarrative}. */
+export declare const CASE_STUDY_NARRATIVE_JSON_SCHEMA: {
+    readonly $schema: 'http://json-schema.org/draft-07/schema#';
+    readonly $id: 'https://sonor.io/schemas/case-study-narrative.v1.json';
+    readonly title: 'CaseStudyNarrative';
+    readonly description: 'The thesis of a case study and the lede that opens each of its four stages.';
+    readonly type: 'object';
+    readonly required: readonly ['thesis'];
+    readonly properties: {
+        readonly thesis: {
+            readonly type: 'string';
+            readonly minLength: 1;
+            readonly maxLength: 320;
+        };
+        readonly stages: {
+            readonly type: 'object';
+            readonly properties: {
+                [k: string]: {
+                    type: string;
+                    maxLength: number;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+    };
+    readonly additionalProperties: false;
+};
+export interface ChallengeLike {
+    id?: string | null;
+    title?: string;
+}
+export interface PhaseLike {
+    resolves?: readonly string[] | null;
+}
+export interface ResultLike {
+    proves?: readonly string[] | null;
+}
+/** A stable id for the n-th challenge (1-based): "c1", "c2"… Writers that don't mint their own use this. */
+export declare function challengeId(position: number): string;
+/**
+ * The problems with how a case study's story hangs together, each one
+ * sentence, or an empty list. Read by the generator's audit and the
+ * dashboard. It judges links only where they've been written: a case study
+ * whose challenges carry no ids has nothing to check and passes, so legacy
+ * content isn't failed for predating the thread.
+ */
+export declare function caseStudyFlowProblems(input: {
+    challenges?: readonly ChallengeLike[] | null;
+    phases?: readonly PhaseLike[] | null;
+    results?: readonly ResultLike[] | null;
+}): string[];
+/**
+ * True for a real calendar day written YYYY-MM-DD. "2026-02-31" is not (Date.parse
+ * rolls it into March), and neither is a year under 100 (Date.UTC maps those into
+ * the 1900s). Single source of truth for what counts as a day.
+ */
+export declare function isRealDay(value: string): boolean;
+/** The most checks one verification lists. It's a short list; the case study isn't an audit report. */
+export declare const VERIFICATION_MAX_CHECKS = 8;
+/** Every field of a check, in the order a renderer reads them. */
+export declare const VERIFICATION_CHECK_FIELDS: readonly ['label', 'result', 'measured', 'where', 'method', 'date', 'scope'];
+export type VerificationCheckField = (typeof VERIFICATION_CHECK_FIELDS)[number];
+/** The longest each text field may run. Each is a line, not a paragraph. `date` is a day, not text. */
+export declare const VERIFICATION_FIELD_MAX_CHARS: {
+    readonly label: 80;
+    readonly result: 120;
+    readonly measured: 200;
+    readonly where: 200;
+    readonly method: 240;
+    readonly scope: 240;
+};
+/** One thing we checked on the finished build. Every field is required. */
+export interface VerificationCheck {
+    /** What the check is called: "Sign-in page, mobile speed". */
+    label: string;
+    /** What came out: "Performance 89", "42 of 42 tables have row-level security". */
+    result: string;
+    /** What was measured: "Lighthouse performance score of the page a visitor sees before signing in". */
+    measured: string;
+    /** Where: a URL, or the screen or file. "https://example.com/login", "the migrations in the repository". */
+    where: string;
+    /** The tool and settings: "Lighthouse 13, mobile preset, median of 3 runs". */
+    method: string;
+    /** The day it was checked, YYYY-MM-DD. */
+    date: string;
+    /** What the check does NOT cover, as a limit: "The sign-in page only; the screens behind it weren't measured." */
+    scope: string;
+}
+/** The `data` of a `portfolioVerification` section. */
+export interface PortfolioVerificationData {
+    checks: VerificationCheck[];
+}
+/** The earliest day a check may carry. An earlier date is a typo, not a check of this build. */
+export declare const VERIFICATION_EARLIEST_DAY = "2000-01-01";
+/**
+ * The latest day a check may carry: tomorrow in UTC. A check run today anywhere
+ * on earth is dated no later than that (the furthest-ahead zone is UTC+14), so a
+ * server's clock can't drop a check dated "today" where the person ran it, and a
+ * date further out is a check that hasn't happened. Single source of truth for
+ * the allowance: writers and readers both use it, so no one keeps a second one.
+ * `now` is for tests and for callers with a clock of their own.
+ */
+export declare function latestVerificationDay(now?: Date): string;
+export interface VerificationOptions {
+    /**
+     * The latest day a check may carry, YYYY-MM-DD; a later one is a problem. Leave it out to use
+     * {@link latestVerificationDay}, which is what a page and a write path both want. Pass one for a fixed clock.
+     */
+    latestDay?: string;
+}
+/**
+ * True when a line says nothing: it has no words, or every word is a
+ * placeholder or filler ("N/A", "n/a n/a", "TBD", "see above", "none at all").
+ */
+export declare function isPlaceholderText(text: string): boolean;
+/**
+ * True when a scope line doesn't state a limit. A scope is "what this check
+ * does NOT cover", so it has to be a sentence that uses a word marking where
+ * coverage stops ("only", "not", "except", "without", "n't") and says
+ * something beyond that word. A coverage claim ("All screens", "Fully
+ * tested"), a placeholder ("N/A", "None at all", "Not applicable") and a
+ * denied limit ("No restrictions", "Nothing excluded") fail. "Desktop only",
+ * "Counted, not exercised" and "No queries ran as a signed-in user" pass.
+ *
+ * It reads English. It can't judge whether a limit is true or useful, only
+ * that one was written; a person still reads the scope.
+ */
+export declare function isVacuousScope(scope: string): boolean;
+/**
+ * What's wrong with a verification section's data, or an empty list. The
+ * section needs between one and {@link VERIFICATION_MAX_CHECKS} checks, and
+ * every field of every check is required, the scope most of all. Whatever
+ * stores a verification should run this first. The contract can't make it:
+ * until a write path calls it, stored data can hold anything, and
+ * {@link readVerificationChecks} is what keeps a bad check off the page.
+ */
+export declare function verificationProblems(data: unknown, options?: VerificationOptions): string[];
+/**
+ * The checks a renderer may show: the ones with every field present, within
+ * the limits, with a real day and a scope that states a limit, trimmed, in their
+ * stored order and no more than {@link VERIFICATION_MAX_CHECKS}. A check that
+ * fails is left out, so one with no scope line (or a placeholder for one) never
+ * prints. That's all it can promise: whether a scope is true is a person's call.
+ * Empty when the data is anything else. Single source of truth for what a case
+ * study prints from this section.
+ */
+export declare function readVerificationChecks(data: unknown, options?: VerificationOptions): VerificationCheck[];
+/**
+ * The link for a check's `where`: the address when it is exactly one http or
+ * https URL with no credentials in it and a public host, else null. A screen
+ * name or a file path is printed as text; nothing else is ever made into a link.
+ */
+export declare function verificationLink(where: string): string | null;
+/** Agent-native contract: JSON Schema for {@link PortfolioVerificationData}. What a scope or a where says, and whether a date is a real day in range, are checked by {@link verificationProblems}. */
+export declare const PORTFOLIO_VERIFICATION_JSON_SCHEMA: {
+    readonly $schema: 'http://json-schema.org/draft-07/schema#';
+    readonly $id: 'https://sonor.io/schemas/portfolio-verification.v1.json';
+    readonly title: 'PortfolioVerificationData';
+    readonly description: 'A short list of checks on the finished build. Each says what was checked, where, how, when, what came out, and what it does not cover.';
+    readonly type: 'object';
+    readonly required: readonly ['checks'];
+    readonly properties: {
+        readonly checks: {
+            readonly type: 'array';
+            readonly minItems: 1;
+            readonly maxItems: 8;
+            readonly items: {
+                readonly type: 'object';
+                readonly required: readonly ["label", "result", "measured", "where", "method", "date", "scope"];
+                readonly properties: {
+                    readonly label: {
+                        readonly type: 'string';
+                        readonly minLength: 1;
+                        readonly maxLength: 80;
+                    };
+                    readonly result: {
+                        readonly type: 'string';
+                        readonly minLength: 1;
+                        readonly maxLength: 120;
+                    };
+                    readonly measured: {
+                        readonly type: 'string';
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                    readonly where: {
+                        readonly type: 'string';
+                        readonly minLength: 1;
+                        readonly maxLength: 200;
+                    };
+                    readonly method: {
+                        readonly type: 'string';
+                        readonly minLength: 1;
+                        readonly maxLength: 240;
+                    };
+                    readonly date: {
+                        readonly type: 'string';
+                        readonly pattern: '^\\d{4}-\\d{2}-\\d{2}$';
+                    };
+                    readonly scope: {
+                        readonly type: 'string';
+                        readonly minLength: 1;
+                        readonly maxLength: 240;
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly additionalProperties: false;
+};
 /** Minimal KPI shape the policy reads — callers pass their own richer tiles. */
 export interface KpiLike {
     label: string;

package/dist/contracts/publication-branding.d.ts

@@ -9,11 +9,12 @@ export type PublicationPlatform = (typeof PUBLICATION_PLATFORMS)[number];
 /** The sections of a profile and of each platform override, in the order they're read. */
 export declare const PUBLICATION_BRANDING_SECTIONS: readonly ['identity', 'colors', 'typography', 'editorial', 'newsletter'];
 export type PublicationBrandingSection = (typeof PUBLICATION_BRANDING_SECTIONS)[number];
-export declare const PUBLICATION_IDENTITY_FIELDS: readonly ['publicationName', 'wordmark', 'tagline', 'publisherName', 'publisherUrl', 'publisherLogoUrl', 'logos'];
+export declare const PUBLICATION_IDENTITY_FIELDS: readonly ['publicationName', 'wordmark', 'tagline', 'publisherName', 'publisherUrl', 'publisherLogoUrl', 'logos', 'squareLogoUrl', 'fullLogoUrl'];
 export declare const PUBLICATION_LOGO_VARIANTS: readonly ['default', 'light', 'dark'];
 export declare const PUBLICATION_COLOR_FIELDS: readonly ['primary', 'secondary', 'accent', 'background', 'surface', 'text', 'muted', 'border'];
 export declare const PUBLICATION_TYPOGRAPHY_FIELDS: readonly ['heading', 'body', 'mono', 'emailHeadingFallback', 'emailBodyFallback'];
-export declare const PUBLICATION_EDITORIAL_FIELDS: readonly ['articleStyle', 'cardLayout', 'charter', 'siteCharters'];
+export declare const PUBLICATION_EDITORIAL_FIELDS: readonly ['articleStyle', 'cardLayout', 'focusClosingBackground', 'charter', 'siteCharters'];
+export declare const FOCUS_CLOSING_BACKGROUNDS: readonly ['planned_photo', 'article_atmosphere'];
 export declare const PUBLICATION_NEWSLETTER_FIELDS: readonly ['name', 'tagline', 'layout', 'maxWidth'];
 /** Fonts every email client has, the only families an email fallback may name. Lowercase. */
 export declare const EMAIL_SAFE_FONTS: ReadonlySet<string>;
@@ -27,6 +28,11 @@ export interface PublicationIdentity {
     publisherUrl?: string;
     /** The publisher's attribution mark, separate from the publication masthead. */
     publisherLogoUrl?: string;
+    /** The publication's square mark; independent of theme variants and publisher attribution. */
+    squareLogoUrl?: string;
+    /** The publication's full/display logo; wordmark remains a text fallback. */
+    fullLogoUrl?: string;
+    /** Legacy theme variants, not square/full logo roles. */
     logos?: {
         default?: string;
         light?: string;
@@ -56,6 +62,8 @@ export interface PublicationEditorial {
     /** Shared Broadcast style for articles, reviews and generated posts; portfolio is excluded. Legacy wire name. */
     articleStyle?: BroadcastStyleId;
     cardLayout?: PublicationCardLayout;
+    /** Focus closing frames may reuse the article's saved atmosphere and real author portrait. */
+    focusClosingBackground?: (typeof FOCUS_CLOSING_BACKGROUNDS)[number];
 }
 export interface PublicationNewsletter {
     name?: string;

package/dist/contracts/site-cache.d.ts

@@ -29,6 +29,8 @@ export declare const SITE_CACHE_TAGS: {
     readonly portfolio: 'portfolio';
     /** Products, services, events and membership plans (commerce-kit). */
     readonly commerce: 'commerce';
+    /** Published managed landing pages. Draft previews never enter this cache. */
+    readonly funnels: 'sonor-funnels';
 };
 export type SiteCacheTag = (typeof SITE_CACHE_TAGS)[keyof typeof SITE_CACHE_TAGS];
 /** The body Sonor POSTs to the revalidation route. */

package/dist/fleet/index.js

@@ -1,11 +1,11 @@
 'use client';
-export { FLEET_HEARTBEAT_PATH, FleetHeartbeat, detectNextVersion, sendFleetHeartbeat } from '../chunk-U34O6I7W.js';
+export { FLEET_HEARTBEAT_PATH, FleetHeartbeat, detectNextVersion, sendFleetHeartbeat } from '../chunk-HN7GVGWC.js';
 export { FLEET_CONTRACT_VERSION, FLEET_MODULES, FLEET_MODULES_MAX, FLEET_SITE_MAX_LENGTH, FLEET_VERSION_MAX_LENGTH, FLEET_VERSION_PATTERN, buildFleetHeartbeatPayload, isFleetModule, normalizeFleetModules, normalizeFleetSite, sanitizeFleetVersion } from '../chunk-ZTZQPYP6.js';
 import '../chunk-YC7ELZS3.js';
-import '../chunk-DLM4FFNH.js';
-import '../chunk-EKBEOXTH.js';
-import '../chunk-IYCSDFPN.js';
-import '../chunk-QQT2T6JQ.js';
+import '../chunk-ZQSCMYZO.js';
+import '../chunk-64XODP7M.js';
+import '../chunk-FLOJUMFR.js';
+import '../chunk-7HW4TZB5.js';
 import '../chunk-W7OPEMGJ.js';
-import '../chunk-BUE3Z32O.js';
+import '../chunk-F6WLHVMQ.js';
 import '../chunk-PKBMQBKP.js';