@sonordev/site-kit 6.5.0 → 7.0.1

package/dist/commerce/server.d.ts

@@ -160,4 +160,3 @@ export declare function generateOfferingMetadata(offering: CommerceOffering | nu
  */
 export declare function createServerConfig(apiUrl: string, apiKey: string, projectId: string): ServerConfig;
 export {};
-//# sourceMappingURL=server.d.ts.map

package/dist/commerce/server.js

@@ -1,251 +1,2 @@
-'use strict';
-
-require('../chunk-SNAQBZPT.js');
-
-// src/commerce/server.ts
-function isFrameworkSignal(err) {
-  const digest = err?.digest;
-  return typeof digest === "string" && (digest === "DYNAMIC_SERVER_USAGE" || digest.startsWith("NEXT_"));
-}
-async function apiFetch(config, endpoint) {
-  try {
-    const response = await fetch(`${config.apiUrl}${endpoint}`, {
-      headers: {
-        "X-API-Key": config.apiKey,
-        "X-Project-ID": config.projectId,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      console.error(`[site-kit/commerce] GET ${endpoint} failed: ${response.status}`);
-      return { ok: false, data: null };
-    }
-    return { ok: true, data: await response.json() };
-  } catch (error) {
-    if (isFrameworkSignal(error)) throw error;
-    console.error(`[site-kit/commerce] GET ${endpoint} failed:`, error);
-    return { ok: false, data: null };
-  }
-}
-async function apiPost(config, endpoint, body) {
-  try {
-    const response = await fetch(`${config.apiUrl}${endpoint}`, {
-      method: "POST",
-      headers: {
-        "X-API-Key": config.apiKey,
-        "X-Project-ID": config.projectId,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      console.error(`[site-kit/commerce] POST ${endpoint} failed: ${response.status}`);
-      return { ok: false, data: null };
-    }
-    return { ok: true, data: await response.json() };
-  } catch (error) {
-    if (isFrameworkSignal(error)) throw error;
-    console.error(`[site-kit/commerce] POST ${endpoint} failed:`, error);
-    return { ok: false, data: null };
-  }
-}
-function transformOffering(data) {
-  return {
-    id: data.id,
-    project_id: data.project_id,
-    type: data.type,
-    status: data.status,
-    name: data.name,
-    slug: data.slug,
-    description: data.description,
-    short_description: data.short_description,
-    long_description: data.long_description,
-    featured_image_url: data.featured_image_url,
-    gallery_images: data.gallery_image_urls || [],
-    price_type: data.price_type || "fixed",
-    price: data.price,
-    compare_at_price: data.compare_at_price,
-    currency: data.currency || "USD",
-    price_is_public: data.price_is_public ?? true,
-    billing_period: data.billing_period,
-    track_inventory: data.track_inventory,
-    inventory_count: data.inventory_count,
-    allow_backorder: data.allow_backorder,
-    duration_minutes: data.duration_minutes,
-    capacity: data.capacity,
-    location: data.location,
-    is_virtual: data.is_virtual,
-    virtual_meeting_url: data.virtual_meeting_url,
-    requires_booking: data.requires_booking,
-    booking_lead_time_hours: data.booking_lead_time_hours,
-    category: data.category,
-    category_id: data.category_id,
-    tags: data.tags || [],
-    seo_title: data.seo_title,
-    seo_description: data.seo_description,
-    features: data.features || [],
-    specifications: data.specifications || {},
-    schedules: data.schedules || [],
-    variants: data.variants || [],
-    created_at: data.created_at,
-    updated_at: data.updated_at
-  };
-}
-async function getProductPaths(config) {
-  const { ok, data } = await apiFetch(
-    config,
-    `/api/public/commerce/offerings?type=product&status=active&fields=slug`
-  );
-  if (!ok) console.error("[site-kit/commerce] getProductPaths failed \u2014 0 product pages will be prerendered");
-  if (!data?.offerings) return [];
-  return data.offerings.map((item) => ({ params: { slug: item.slug } }));
-}
-async function getEventPaths(config) {
-  const { ok, data } = await apiFetch(
-    config,
-    `/api/public/commerce/offerings?type=event&status=active&fields=slug`
-  );
-  if (!ok) console.error("[site-kit/commerce] getEventPaths failed \u2014 0 event pages will be prerendered");
-  if (!data?.offerings) return [];
-  return data.offerings.map((item) => ({ params: { slug: item.slug } }));
-}
-async function getOfferingPaths(config, type) {
-  let typeParam = "";
-  if (type) {
-    if (Array.isArray(type)) {
-      typeParam = `&type=${type.join(",")}`;
-    } else {
-      typeParam = `&type=${type}`;
-    }
-  }
-  const { ok, data } = await apiFetch(
-    config,
-    `/api/public/commerce/offerings?status=active&fields=slug${typeParam}`
-  );
-  if (!ok) console.error("[site-kit/commerce] getOfferingPaths failed \u2014 0 pages will be prerendered");
-  if (!data?.offerings) return [];
-  return data.offerings.map((item) => ({ params: { slug: item.slug } }));
-}
-async function getOfferingBySlug(config, slug) {
-  return (await getOfferingBySlugResult(config, slug)).data;
-}
-async function getOfferingBySlugResult(config, slug) {
-  const { ok, data } = await apiFetch(
-    config,
-    `/api/public/commerce/offerings/${slug}`
-  );
-  if (!data?.offering) return { ok, data: null };
-  return { ok: true, data: transformOffering(data.offering) };
-}
-async function getOfferings(config, options = {}) {
-  return (await getOfferingsResult(config, options)).data;
-}
-async function getOfferingsResult(config, options = {}) {
-  const params = new URLSearchParams();
-  params.set("status", options.status || "active");
-  if (options.type) {
-    if (Array.isArray(options.type)) {
-      params.set("type", options.type.join(","));
-    } else {
-      params.set("type", options.type);
-    }
-  }
-  if (options.category) {
-    params.set("category", options.category);
-  }
-  if (options.limit) {
-    params.set("limit", options.limit.toString());
-  }
-  const { ok, data } = await apiFetch(
-    config,
-    `/api/public/commerce/offerings?${params.toString()}`
-  );
-  if (!data?.offerings) return { ok, data: [] };
-  return { ok: true, data: data.offerings.map(transformOffering) };
-}
-async function getUpcomingEvents(config, options = {}) {
-  return (await getUpcomingEventsResult(config, options)).data;
-}
-async function getUpcomingEventsResult(config, options = {}) {
-  const primary = await apiPost(
-    config,
-    "/api/public/commerce/events",
-    {
-      type: "event",
-      category: options.category,
-      limit: options.limit,
-      includePast: false
-    }
-  );
-  if (primary.ok && primary.data?.events) {
-    return { ok: true, data: primary.data.events.map(transformOffering) };
-  }
-  const params = new URLSearchParams();
-  params.set("type", "event");
-  params.set("status", "active");
-  params.set("upcoming", "true");
-  if (options.category) {
-    params.set("category", options.category);
-  }
-  if (options.limit) {
-    params.set("limit", options.limit.toString());
-  }
-  const legacy = await apiFetch(
-    config,
-    `/api/public/commerce/offerings?${params.toString()}`
-  );
-  if (legacy.ok && legacy.data?.offerings) {
-    return { ok: true, data: legacy.data.offerings.map(transformOffering) };
-  }
-  return { ok: primary.ok || legacy.ok, data: [] };
-}
-async function getNextEvent(config, category) {
-  return (await getNextEventResult(config, category)).data;
-}
-async function getNextEventResult(config, category) {
-  const { ok, data } = await getUpcomingEventsResult(config, { limit: 1, category });
-  return { ok, data: data[0] || null };
-}
-function generateOfferingMetadata(offering, siteUrl) {
-  if (!offering) return null;
-  const title = offering.seo_title || offering.name;
-  const description = offering.seo_description || offering.short_description || offering.description || "";
-  const images = offering.featured_image_url ? [offering.featured_image_url] : [];
-  const typeMap = {
-    product: "product",
-    service: "website",
-    event: "website",
-    class: "website",
-    subscription: "product"
-  };
-  return {
-    title,
-    description,
-    openGraph: {
-      title,
-      description,
-      images,
-      type: typeMap[offering.type] || "website",
-      url: `${siteUrl}/${offering.type}s/${offering.slug}`
-    }
-  };
-}
-function createServerConfig(apiUrl, apiKey, projectId) {
-  return { apiUrl, apiKey, projectId };
-}
-
-exports.createServerConfig = createServerConfig;
-exports.generateOfferingMetadata = generateOfferingMetadata;
-exports.getEventPaths = getEventPaths;
-exports.getNextEvent = getNextEvent;
-exports.getNextEventResult = getNextEventResult;
-exports.getOfferingBySlug = getOfferingBySlug;
-exports.getOfferingBySlugResult = getOfferingBySlugResult;
-exports.getOfferingPaths = getOfferingPaths;
-exports.getOfferings = getOfferings;
-exports.getOfferingsResult = getOfferingsResult;
-exports.getProductPaths = getProductPaths;
-exports.getUpcomingEvents = getUpcomingEvents;
-exports.getUpcomingEventsResult = getUpcomingEventsResult;
-//# sourceMappingURL=server.js.map
-//# sourceMappingURL=server.js.map
+export { createServerConfig, generateOfferingMetadata, getEventPaths, getNextEvent, getNextEventResult, getOfferingBySlug, getOfferingBySlugResult, getOfferingPaths, getOfferings, getOfferingsResult, getProductPaths, getUpcomingEvents, getUpcomingEventsResult } from '../chunk-G3NHWMP5.js';
+import '../chunk-PKBMQBKP.js';

package/dist/commerce/types.d.ts

@@ -338,4 +338,3 @@ export interface FetchEventsOptions {
     offset?: number;
     category?: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/commerce/useEventModal.d.ts

@@ -18,4 +18,3 @@ export interface UseEventModalReturn {
 }
 export declare function useEventModal(): UseEventModalReturn;
 export default useEventModal;
-//# sourceMappingURL=useEventModal.d.ts.map

package/dist/commerce/utils.d.ts

@@ -15,4 +15,3 @@ export declare function getOfferingUrl(slug: string, type: string, basePaths?: {
     event?: string;
     class?: string;
 }): string;
-//# sourceMappingURL=utils.d.ts.map

package/dist/config/index.d.ts

@@ -55,4 +55,3 @@ export interface SiteKitNextConfig {
 }
 export declare function withSiteKitConfig(config?: SiteKitNextConfig): NextConfig;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -1,8 +1,6 @@
-'use strict';
-
-var chunkKP5BFPGT_js = require('../chunk-KP5BFPGT.js');
-var chunkWS7MH3GD_js = require('../chunk-WS7MH3GD.js');
-require('../chunk-SNAQBZPT.js');
+import { buildSecurityHeaders } from '../chunk-KXPBMCFL.js';
+import { buildAiDiscoveryHeaders } from '../chunk-PO2TRJPY.js';
+import '../chunk-PKBMQBKP.js';
 
 // src/config/index.ts
 function resolvePublicSiteUrl(explicit) {
@@ -15,7 +13,7 @@ function resolvePublicSiteUrl(explicit) {
   return null;
 }
 function withSiteKitConfig(config) {
-  const securityHeaders = chunkKP5BFPGT_js.buildSecurityHeaders(
+  const securityHeaders = buildSecurityHeaders(
     config?.securityHeaders
   );
   const includeSecurityHeaders = config?.securityHeaders !== false;
@@ -66,7 +64,7 @@ function withSiteKitConfig(config) {
           ([key, value]) => ({ key, value })
         );
         if (includeDiscovery && discoverySiteUrl) {
-          const linkMap = chunkWS7MH3GD_js.buildAiDiscoveryHeaders({
+          const linkMap = buildAiDiscoveryHeaders({
             siteUrl: discoverySiteUrl,
             llmsPath: discoveryLlmsPath,
             includeTypeParameter: discoveryIncludeType
@@ -81,7 +79,7 @@ function withSiteKitConfig(config) {
           headers: baseHeaders
         });
       } else if (includeDiscovery && discoverySiteUrl) {
-        const linkMap = chunkWS7MH3GD_js.buildAiDiscoveryHeaders({
+        const linkMap = buildAiDiscoveryHeaders({
           siteUrl: discoverySiteUrl,
           llmsPath: discoveryLlmsPath,
           includeTypeParameter: discoveryIncludeType
@@ -113,6 +111,4 @@ function withSiteKitConfig(config) {
   return result;
 }
 
-exports.withSiteKitConfig = withSiteKitConfig;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { withSiteKitConfig };

package/dist/contracts/color.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @sonordev/contracts/color — CSS colour reading and WCAG contrast
+ *
+ * Single source of truth for turning a CSS colour string into something the
+ * kit can reason about. Used at build time by the brand-profile extractor
+ * (`src/brand/extract-brand-profile.ts`, theme detection) and in the browser
+ * by Echo (`src/engage/brand-color.ts`, brand text contrast). Pure, no
+ * imports, safe in both.
+ */
+export type Rgb = {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare const HEX_COLOR: RegExp;
+/**
+ * WCAG relative luminance below which a color reads as dark — the point where
+ * it contrasts more with white than with black.
+ */
+export declare const DARK_LUMINANCE = 0.179;
+/** WCAG 2.x relative luminance of an sRGB colour (0 = black, 1 = white). */
+export declare function relativeLuminance({ r, g, b }: Rgb): number;
+/** WCAG 2.x contrast ratio between two relative luminances (1 to 21). */
+export declare function contrastRatio(a: number, b: number): number;
+/**
+ * The sRGB channels (0-255, alpha ignored) of a resolved CSS color, or null
+ * when the value isn't one this can read or paints nothing. Covers hex (3, 4,
+ * 6 and 8 digits), rgb()/rgba() and hsl()/hsla() in comma or space syntax, a
+ * bare shadcn-style HSL triple (`0 0% 100%`), and white/black. oklch(), lab()
+ * and named colours beyond those two return null.
+ */
+export declare function parseColor(value: string): Rgb | null;
+/**
+ * Relative luminance (0 = black, 1 = white) of a resolved CSS color, or null
+ * when the value isn't a color this can read. Everything `parseColor` reads,
+ * plus oklch()/oklab()/lab()/lch() (from their lightness).
+ */
+export declare function colorLuminance(value: string): number | null;

package/dist/contracts/entries.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The entries @sonordev/contracts publishes, one per file in this folder
+ * (sites-normalize is part of `sites`). Read by packages/contracts'
+ * tsup config, its package.json check and the boundary test, so a new
+ * contract is added in one place.
+ */
+export declare const CONTRACT_ENTRIES: readonly ['forms', 'llms', 'slots', 'website', 'color', 'fleet', 'sites', 'seo-pages', 'seo-meta', 'portfolio'];
+export type ContractEntry = (typeof CONTRACT_ENTRIES)[number];

package/dist/contracts/fleet.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @sonordev/contracts/fleet — Fleet heartbeat wire contract (v1)
+ *
+ * Single source of truth for the heartbeat payload shape, shared by site-kit
+ * (send side, `@sonordev/site-kit/fleet/contract`) and sonor-api (ingest
+ * side: its DTO is type-checked against FleetHeartbeatPayload).
+ *
+ * Why it exists: ~24+ client sites run site-kit at wildly drifted versions and
+ * the platform could not answer "which version / modules / key state is each
+ * site running" without shelling into every local repo. The heartbeat answers
+ * that from live traffic. It is fire-and-forget, deferred to idle (never in the
+ * hydration path), and carries NO visitor data — only the site's own build
+ * fingerprint. Project identity is resolved server-side from the x-api-key
+ * header, exactly like every other /api/public/* endpoint; sites never send
+ * project IDs.
+ *
+ * The x-sitekit-version header (set by shared/sonorFetch on every request)
+ * already gives the platform a passive "last seen version" for ALL traffic,
+ * including server-only module fetches. The heartbeat adds the things a header
+ * can't carry: the active module set and the host Next.js version.
+ */
+/** Bump on breaking payload changes. Ingest accepts the current version. */
+export declare const FLEET_CONTRACT_VERSION = 1;
+/**
+ * Client-observable site-kit modules — the set a site can honestly self-report
+ * from a client boot, because SiteKitClientProviders actually mounts them.
+ *
+ * Server-only modules (seo, article, images, reputation, redirects, llms) are
+ * intentionally absent: they render on the server and cannot be observed from
+ * the browser. Their usage still surfaces passively through the
+ * x-sitekit-version header on their own server fetches.
+ */
+export type FleetModule = 'analytics' | 'engage' | 'signal' | 'sitemapSync' | 'forms' | 'commerce' | 'sync' | 'maps' | 'slots';
+/** Canonical order — used to serialize equal module sets identically. */
+export declare const FLEET_MODULES: readonly FleetModule[];
+/** Where a heartbeat originated. */
+export type FleetHeartbeatSource = 'client' | 'build';
+/** Hard cap on modules accepted in one payload (junk guard). */
+export declare const FLEET_MODULES_MAX = 32;
+/** Hard cap on the free-form version strings we accept. */
+export declare const FLEET_VERSION_MAX_LENGTH = 40;
+/** Semver-ish shape. Non-matching values are stored as null, never rejected. */
+export declare const FLEET_VERSION_PATTERN: RegExp;
+/** Max host length per RFC 1035. */
+export declare const FLEET_SITE_MAX_LENGTH = 253;
+/**
+ * The heartbeat body a site POSTs to `/api/public/fleet/heartbeat`.
+ * All wire fields are snake_case to match the other contract modules and the
+ * agent-facing read endpoints.
+ */
+export interface FleetHeartbeatPayload {
+    contract_version: number;
+    /** SITE_KIT_VERSION at runtime, e.g. "3.2.0". */
+    kit_version: string;
+    /** Installed Next.js version if detectable, else null. */
+    next_version?: string | null;
+    /** Client-observable active modules — deduped, validated, canonical order. */
+    modules: FleetModule[];
+    /** Normalized lowercase host (multi-site sub-dimension; see CLAUDE.md). */
+    site?: string | null;
+    /** 'client' (runtime boot) or 'build' (CI/build step). Default 'client'. */
+    source?: FleetHeartbeatSource;
+}
+/** The ingest endpoint's response. `received_at` is server-stamped ISO 8601. */
+export interface FleetHeartbeatResponse {
+    ok: boolean;
+    contract_version: number;
+    received_at: string;
+}
+export declare function isFleetModule(x: unknown): x is FleetModule;
+/**
+ * Dedupe + validate a modules array: drop unknowns, cap length, emit in the
+ * canonical FLEET_MODULES order so equal sets always serialize identically.
+ */
+export declare function normalizeFleetModules(input: unknown): FleetModule[];
+/** Coerce a version-ish string to a clean value or null (never throws). */
+export declare function sanitizeFleetVersion(raw: unknown): string | null;
+/**
+ * Light client-side site normalization to the canonical host shape (lowercase,
+ * no protocol/path/port). sonor-api's IngestService.normalizeSite is the
+ * AUTHORITATIVE normalizer and re-runs on ingest — this just avoids sending
+ * obvious noise. Keep the two shapes aligned (see CLAUDE.md "site" convention).
+ */
+export declare function normalizeFleetSite(raw: unknown): string | null;
+/**
+ * Build a validated heartbeat payload from loose inputs. Used by BOTH the
+ * client component and the build-time sender so the wire shape is produced in
+ * exactly one place (single source of truth for the heartbeat body).
+ */
+export declare function buildFleetHeartbeatPayload(input: {
+    kitVersion: string;
+    nextVersion?: string | null;
+    modules?: unknown;
+    site?: string | null;
+    source?: FleetHeartbeatSource;
+}): FleetHeartbeatPayload;

package/dist/contracts/forms.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @sonordev/contracts/forms — managed-form honeypot policy (v1)
+ *
+ * Single source of truth for the honeypot trap-field naming + server-side
+ * detection policy, shared by the client (site-kit emits the trap field) and
+ * the server (sonor-api names the trap in the form config it returns AND
+ * detects hits on intake). Both import this: site-kit as
+ * `@sonordev/site-kit/forms/contract`, sonor-api through
+ * `src/modules/forms/honeypot-contract.ts`.
+ *
+ * The default field name (`_sk_hp_url`) is deliberately obscure: a common name
+ * like "website" collides with real form fields and flags genuine submissions
+ * as spam, so generic names are only trusted when they DON'T match a real
+ * field of the form (see `resolveHoneypotFieldNames`).
+ */
+/** Bump on breaking changes to the honeypot policy. */
+export declare const FORMS_HONEYPOT_CONTRACT_VERSION: 1;
+/**
+ * Default honeypot field name emitted by site-kit and used by the server as the
+ * fallback trap name when a form has no explicitly configured `honeypot_field`.
+ * Deliberately obscure to avoid colliding with real form fields.
+ */
+export declare const DEFAULT_HONEYPOT_FIELD = "_sk_hp_url";
+/**
+ * Generic trap names the server also watches on intake — the canonical default
+ * plus legacy names still emitted by older deployed forms. Each is only trusted
+ * when it doesn't collide with a real configured field of the form.
+ */
+export declare const GENERIC_HONEYPOT_FIELDS: readonly string[];
+/**
+ * Build the set of field names the server treats as honeypot traps for one form.
+ * Generic names that collide with a real field slug are dropped (or every real
+ * lead using that field would be flagged); the form's dedicated
+ * `honeypot_field` is always honored. Returns an empty set when disabled.
+ */
+export declare function resolveHoneypotFieldNames(opts: {
+    enabled: boolean;
+    formHoneypotField?: string | null;
+    realFieldSlugs?: Iterable<string>;
+}): Set<string>;
+/**
+ * What a tripped trap looked like. Deliberately carries NO value — an
+ * autofilled trap can hold the visitor's real name, URL, or email, and this
+ * rides along into stored spam analysis. The field name is the diagnostic that
+ * matters; type and length are enough to tell autofill from a bot.
+ */
+export interface HoneypotHit {
+    /** Which trap fired. Several are watched per form; only this one tripped. */
+    field: string;
+    valueType: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    /** Character length for strings, element count for arrays, else null. */
+    length: number | null;
+}
+/**
+ * The first watched trap this submission actually filled, or null.
+ *
+ * Returns the NAME, not a boolean, because "honeypot fired" alone is
+ * unfalsifiable after the fact: the trap values are stripped before storage, so
+ * a bare flag left no way to tell a bot from a browser autofilling a hidden
+ * field. Callers stamp the name into the spam reasons.
+ */
+export declare function findTrippedTrap(data: Record<string, unknown> | null | undefined, fieldNames: Iterable<string>): HoneypotHit | null;
+/**
+ * True when any watched trap field carries a real value — the marker of an
+ * automated submission (real users never see or fill the trap).
+ * Thin view over {@link findTrippedTrap}; one detection rule, two shapes.
+ */
+export declare function isHoneypotTriggered(data: Record<string, unknown> | null | undefined, fieldNames: Iterable<string>): boolean;
+/**
+ * Agent-native contract: JSON Schema for the honeypot slice of the public form
+ * config, so services and agents can validate it mechanically.
+ */
+export declare const HONEYPOT_CONFIG_JSON_SCHEMA: {
+    readonly $schema: 'http://json-schema.org/draft-07/schema#';
+    readonly $id: 'https://sonor.io/schemas/honeypot-config.v1.json';
+    readonly title: 'HoneypotConfig';
+    readonly description: 'The honeypot slice of a public managed-form config.';
+    readonly type: 'object';
+    readonly properties: {
+        readonly honeypot_enabled: {
+            readonly type: 'boolean';
+        };
+        readonly honeypot_field: {
+            readonly description: "Trap field name; defaults to \"_sk_hp_url\" when unset.";
+            readonly type: 'string';
+        };
+    };
+    readonly additionalProperties: true;
+};

package/dist/contracts/llms.d.ts

@@ -0,0 +1,54 @@
+/**
+ * GEO / AEO contract — shared shape for Sonor API, Signal API, and site-kit.
+ * Bump LLM_GEO_CONTRACT_VERSION when making breaking changes to public payloads.
+ *
+ * The APIs import it as `@sonordev/contracts/llms`; sites get the same code as
+ * `@sonordev/site-kit/seo/llms/contract`.
+ *
+ * @see LLM_GEO_CONTRACT.md in this folder
+ */
+/** Increment when public LLMs payload shape changes incompatibly. */
+export declare const LLM_GEO_CONTRACT_VERSION: 1;
+/** Max length for llms_public_summary (plain text, single line in llms.txt link notes). */
+export declare const LLMS_PUBLIC_SUMMARY_MAX_LENGTH = 400;
+/** Max length for optional llms.txt blockquote disclaimer line. */
+export declare const LLMS_DISCLAIMER_MAX_LENGTH = 280;
+/**
+ * Optional keys we allow inside managed_llm_schema JSON from Portal.
+ * Values outside this set should not be relied on by consumers; strip unknown keys when emitting JSON-LD.
+ */
+export declare const MANAGED_LLM_SCHEMA_KNOWN_KEYS: Set<string>;
+export interface LLMsPayloadMeta {
+    /** Contract version for this payload (matches LLM_GEO_CONTRACT_VERSION when current). */
+    contract_version: number;
+    /** ISO 8601 — best-effort freshness for the project’s SEO data. */
+    last_updated?: string | null;
+    /** BCP 47 tag for primary public content (e.g. from project settings). */
+    primary_language?: string | null;
+    /** Optional single-line, public-safe note in the llms.txt blockquote (e.g. scope / not legal advice). */
+    llms_disclaimer?: string | null;
+}
+/**
+ * Public-safe summary for llms.txt `[title](url): notes` — never CRM-only or internal copy.
+ */
+export declare function sanitizeLlmsPublicSummary(raw: unknown): string | null;
+/**
+ * Single line for llms.txt blockquote disclaimer — shorter min length than link notes.
+ */
+export declare function sanitizeLlmsDisclaimerLine(raw: unknown): string | null;
+/** Normalize BCP 47 tag for display (no quotes). */
+export declare function sanitizePrimaryLanguageTag(raw: unknown): string | null;
+/**
+ * Google requires `author` on every Review node and treats its absence as a
+ * CRITICAL error that suppresses review rich results for the whole page.
+ * Generated schema has shipped Review nodes carrying only `reviewBody` and
+ * `itemReviewed` — editorial prose about a client, not an attributed review —
+ * so they are invalid markup AND self-serving-review-policy risk.
+ *
+ * Single source of truth for "is this Review node safe to emit as JSON-LD".
+ * An author must resolve to a non-empty name; a bare `{"@type":"Review"}` and
+ * `author: {}` both fail.
+ */
+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;