@sonordev/site-kit 6.4.0 → 7.0.0

package/dist/chunk-BQR4IPBW.js

@@ -0,0 +1,146 @@
+// src/contracts/seo-meta.ts
+var SEO_META_CONTRACT_VERSION = 1;
+var TITLE_SEPARATOR = " | ";
+var DANGLING_TAIL = /[|,\-–—:;·•]\s*$/;
+var TRAILING_FUNCTION_WORD = /\s(?:for|of|and|or|in|on|at|to|with|from|by|a|an|the|your|our|that|&)$/i;
+var MIN_HOST_FRAGMENT = 8;
+var MIN_NAME_LETTERS = 6;
+var lettersOf = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "");
+var wordsOf = (s) => ` ${s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
+function metaHost(value) {
+  if (!value || typeof value !== "string" || /\s/.test(value.trim())) return null;
+  const s = value.trim().toLowerCase().replace(/^[a-z][a-z0-9+.-]*:\/\//, "").split(/[/?#]/)[0].split(":")[0].replace(/\.+$/, "").replace(/^www\./, "");
+  return s.includes(".") ? s : null;
+}
+function hostsOf(id) {
+  const out = /* @__PURE__ */ new Set();
+  for (const h of id.hosts ?? []) {
+    const host = metaHost(h);
+    if (host) out.add(host);
+  }
+  return [...out];
+}
+function labelsOf(id) {
+  return hostsOf(id).map((h) => lettersOf(h.split(".")[0])).filter((l) => l.length >= MIN_NAME_LETTERS);
+}
+function brandCore(name) {
+  let s = name.replace(/^the\s+/i, "").trim();
+  let prev;
+  do {
+    prev = s;
+    s = s.replace(/[\s,]+(?:apartments|apts|llc|inc|co|corp|ltd|company)\.?$/i, "").trim();
+  } while (s !== prev);
+  return s;
+}
+function brandVariants(id) {
+  const out = [];
+  for (const raw of [id.brand, ...id.brandAliases ?? []]) {
+    const name = typeof raw === "string" ? raw.replace(/\s+/g, " ").trim() : "";
+    if (!name) continue;
+    out.push(name);
+    const core = brandCore(name);
+    if (core && core !== name) out.push(core);
+  }
+  return out;
+}
+function nameVariants(id) {
+  return brandVariants(id).filter((v) => metaHost(v) === null);
+}
+function namesBrand(text, id) {
+  const words = wordsOf(text);
+  return brandVariants(id).some((v) => wordsOf(v).trim() !== "" && words.includes(wordsOf(v)));
+}
+function titleSuffix(title) {
+  const t = title.trim();
+  const i = t.lastIndexOf(TITLE_SEPARATOR);
+  return i > 0 ? t.slice(i + TITLE_SEPARATOR.length).trim() : null;
+}
+function stripTitleSuffix(title) {
+  const t = title.trim();
+  const i = t.lastIndexOf(TITLE_SEPARATOR);
+  return i > 0 ? t.slice(0, i).trim() : t;
+}
+function namesHost(text, id) {
+  const lower = text.toLowerCase();
+  const brands = brandVariants(id).map((b) => b.toLowerCase());
+  return hostsOf(id).some((host) => lower.includes(host) && !brands.some((b) => b.includes(host)));
+}
+function endsOnTruncatedHost(text, id) {
+  const tokens = text.trim().split(/[\s|,()[\]]+/);
+  const last = (tokens[tokens.length - 1] ?? "").replace(/^[^a-z0-9]+/i, "");
+  if (!last || last !== last.toLowerCase()) return false;
+  const stem = lettersOf(last.split(".")[0]);
+  return stem.length >= MIN_HOST_FRAGMENT && labelsOf(id).some((l) => l.startsWith(stem));
+}
+function occurrences(hay, needle, step = needle.length) {
+  let n = 0;
+  for (let i = hay.indexOf(needle); i !== -1; i = hay.indexOf(needle, i + step)) n++;
+  return n;
+}
+function respellsBrand(text, id) {
+  const letters = lettersOf(text);
+  const words = wordsOf(text);
+  return nameVariants(id).some((v) => {
+    const vl = lettersOf(v);
+    if (vl.length < MIN_NAME_LETTERS) return false;
+    const vw = wordsOf(v);
+    return occurrences(letters, vl) > occurrences(words, vw, vw.length - 1);
+  });
+}
+function gluesHostLabel(text, id) {
+  const variants = nameVariants(id);
+  if (!variants.length) return false;
+  const labels = labelsOf(id);
+  return text.split(/[\s|,()[\]:;]+/).some((token) => {
+    const tl = lettersOf(token);
+    return tl.length >= MIN_NAME_LETTERS && labels.includes(tl) && !variants.some((v) => wordsOf(v).includes(wordsOf(token)));
+  });
+}
+function suffixProblem(suffix, id) {
+  const s = suffix.trim();
+  if (!s) return null;
+  if (namesHost(s, id) || endsOnTruncatedHost(s, id)) return "hostname";
+  const variants = nameVariants(id);
+  if (!variants.length) return null;
+  if (respellsBrand(s, id) || gluesHostLabel(s, id)) return "mangled-brand";
+  if (/\s/.test(s)) return null;
+  const sl = lettersOf(s);
+  const fromLabel = sl.length >= MIN_NAME_LETTERS && labelsOf(id).some((l) => l.startsWith(sl));
+  const sw = wordsOf(brandCore(s));
+  const isBrand = variants.some((v) => {
+    const vw = wordsOf(brandCore(v));
+    return vw.startsWith(sw) || sw.startsWith(vw);
+  });
+  return fromLabel && !isBrand ? "mangled-brand" : null;
+}
+function isPlaceholder(title, path) {
+  const t = title.trim();
+  if (!path) return false;
+  const strip = (s) => s.replace(/\/+$/, "") || "/";
+  if (t.startsWith("/") && strip(t.toLowerCase()) === strip(path.trim().toLowerCase())) return true;
+  return strip(path.trim()) === "/" && /^(home|index|untitled)$/i.test(t);
+}
+function titleProblem(title, id, opts = {}) {
+  const t = (title ?? "").trim();
+  if (!t) return "empty";
+  if (isPlaceholder(t, opts.path)) return "placeholder";
+  if (DANGLING_TAIL.test(t)) return "dangling-separator";
+  if (namesHost(t, id) || endsOnTruncatedHost(t, id)) return "hostname";
+  const suffix = titleSuffix(t);
+  if (suffix !== null) {
+    const problem = suffixProblem(suffix, id);
+    if (problem) return problem;
+  }
+  if (respellsBrand(t, id) || gluesHostLabel(t, id)) return "mangled-brand";
+  return null;
+}
+function descriptionProblem(description, id) {
+  const d = (description ?? "").trim();
+  if (!d) return "empty";
+  if (namesHost(d, id)) return "hostname";
+  if (respellsBrand(d, id) || gluesHostLabel(d, id)) return "mangled-brand";
+  if (DANGLING_TAIL.test(d) || TRAILING_FUNCTION_WORD.test(d)) return "truncated";
+  return null;
+}
+
+export { SEO_META_CONTRACT_VERSION, descriptionProblem, metaHost, namesBrand, stripTitleSuffix, suffixProblem, titleProblem, titleSuffix };

package/dist/chunk-BR4ZKUHH.js

@@ -0,0 +1,227 @@
+'use client';
+import { fetchReviews } from './chunk-EDYHROQ7.js';
+import { useState, useEffect, useCallback } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function TestimonialSection({
+  title,
+  subtitle,
+  autoplay = true,
+  autoplayInterval = 5e3,
+  showRating = true,
+  maxReviews,
+  featuredOnly = false,
+  service,
+  className = ""
+}) {
+  const [reviews, setReviews] = useState([]);
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const [isLoading, setIsLoading] = useState(true);
+  const [direction, setDirection] = useState("next");
+  useEffect(() => {
+    async function loadReviews() {
+      setIsLoading(true);
+      const data = await fetchReviews({
+        service,
+        limit: maxReviews,
+        featured: featuredOnly
+      });
+      setReviews(data);
+      setIsLoading(false);
+    }
+    loadReviews();
+  }, [service, maxReviews, featuredOnly]);
+  useEffect(() => {
+    if (!autoplay || reviews.length <= 1) return;
+    const interval = setInterval(() => {
+      setDirection("next");
+      setCurrentIndex((prev) => (prev + 1) % reviews.length);
+    }, autoplayInterval);
+    return () => clearInterval(interval);
+  }, [autoplay, autoplayInterval, reviews.length]);
+  useCallback((index) => {
+    setDirection(index > currentIndex ? "next" : "prev");
+    setCurrentIndex(index);
+  }, [currentIndex]);
+  const nextSlide = useCallback(() => {
+    setDirection("next");
+    setCurrentIndex((prev) => (prev + 1) % reviews.length);
+  }, [reviews.length]);
+  const prevSlide = useCallback(() => {
+    setDirection("prev");
+    setCurrentIndex((prev) => (prev - 1 + reviews.length) % reviews.length);
+  }, [reviews.length]);
+  if (isLoading) {
+    return null;
+  }
+  if (!reviews.length) {
+    return null;
+  }
+  const currentReview = reviews[currentIndex];
+  return /* @__PURE__ */ jsxs("section", { className: `testimonial-section ${className}`, "data-site-kit-testimonials": true, children: [
+    /* @__PURE__ */ jsx("style", { children: `
+        .testimonial-section {
+          position: relative;
+          padding: 4rem 1rem;
+        }
+        
+        .testimonial-content {
+          position: relative;
+          overflow: hidden;
+        }
+        
+        .testimonial-slide {
+          animation: ${direction === "next" ? "slideInRight" : "slideInLeft"} 0.6s cubic-bezier(0.4, 0, 0.2, 1);
+        }
+        
+        @keyframes slideInRight {
+          from {
+            opacity: 0;
+            transform: translateX(50px);
+          }
+          to {
+            opacity: 1;
+            transform: translateX(0);
+          }
+        }
+        
+        @keyframes slideInLeft {
+          from {
+            opacity: 0;
+            transform: translateX(-50px);
+          }
+          to {
+            opacity: 1;
+            transform: translateX(0);
+          }
+        }
+        
+        .testimonial-quote-icon {
+          font-size: 4rem;
+          line-height: 1;
+          text-align: center;
+          margin-bottom: 1.5rem;
+          opacity: 0.15;
+        }
+        
+        .testimonial-stars {
+          display: flex;
+          justify-content: center;
+          gap: 0.25rem;
+          margin-bottom: 1.5rem;
+        }
+        
+        .testimonial-quote {
+          text-align: center;
+          font-size: 1.25rem;
+          line-height: 1.8;
+          margin-bottom: 2rem;
+        }
+        
+        .testimonial-author {
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+          gap: 1rem;
+        }
+        
+        .testimonial-avatar {
+          width: 4rem;
+          height: 4rem;
+          border-radius: 50%;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          font-size: 1.5rem;
+        }
+        
+        .testimonial-name {
+          font-weight: 600;
+          font-size: 1.125rem;
+        }
+        
+        .testimonial-role {
+          font-size: 0.875rem;
+          opacity: 0.7;
+        }
+        
+        .testimonial-nav {
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          gap: 1.5rem;
+          margin-top: 2rem;
+        }
+        
+        .testimonial-nav-button {
+          border: none;
+          background: none;
+          cursor: pointer;
+          padding: 0.5rem;
+          transition: opacity 0.2s;
+          font-size: 1.5rem;
+        }
+        
+        .testimonial-nav-button:hover {
+          opacity: 0.7;
+        }
+        
+        .testimonial-nav-button:disabled {
+          opacity: 0.3;
+          cursor: not-allowed;
+        }
+      ` }),
+    /* @__PURE__ */ jsxs("div", { className: "container", children: [
+      title && /* @__PURE__ */ jsx("h2", { className: "testimonial-title", children: title }),
+      subtitle && /* @__PURE__ */ jsx("p", { className: "testimonial-subtitle", children: subtitle }),
+      /* @__PURE__ */ jsx("div", { className: "testimonial-content", children: /* @__PURE__ */ jsxs("div", { className: "testimonial-slide", children: [
+        /* @__PURE__ */ jsx("div", { className: "testimonial-quote-icon", children: "\u201C" }),
+        showRating && /* @__PURE__ */ jsx("div", { className: "testimonial-stars", children: [...Array(5)].map((_, i) => /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: `star ${i < currentReview.rating ? "star-filled" : "star-empty"}`,
+            "aria-hidden": "true",
+            children: "\u2605"
+          },
+          i
+        )) }),
+        /* @__PURE__ */ jsxs("blockquote", { className: "testimonial-quote", children: [
+          "\u201C",
+          currentReview.quote,
+          "\u201D"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "testimonial-author", children: [
+          /* @__PURE__ */ jsx("div", { className: "testimonial-avatar", "aria-hidden": "true", children: currentReview.image ? /* @__PURE__ */ jsx("img", { src: currentReview.image, alt: "" }) : /* @__PURE__ */ jsx("span", { children: "\u{1F464}" }) }),
+          /* @__PURE__ */ jsxs("div", { className: "testimonial-author-info", children: [
+            /* @__PURE__ */ jsx("div", { className: "testimonial-name", children: currentReview.name }),
+            currentReview.role && /* @__PURE__ */ jsx("div", { className: "testimonial-role", children: currentReview.role })
+          ] })
+        ] })
+      ] }, currentIndex) }),
+      reviews.length > 1 && /* @__PURE__ */ jsxs("div", { className: "testimonial-nav", children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: prevSlide,
+            className: "testimonial-nav-button testimonial-nav-prev",
+            "aria-label": "Previous review",
+            disabled: reviews.length <= 1,
+            children: "\u2039"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: nextSlide,
+            className: "testimonial-nav-button testimonial-nav-next",
+            "aria-label": "Next review",
+            disabled: reviews.length <= 1,
+            children: "\u203A"
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+
+export { TestimonialSection };

package/dist/chunk-BU66S5B7.js

@@ -0,0 +1 @@
+

package/dist/chunk-C4G3NW2E.js

@@ -0,0 +1,25 @@
+// src/motion/failsafe.ts
+var scrolled = false;
+var armed = false;
+function arm() {
+  if (armed || typeof window === "undefined") return;
+  armed = true;
+  window.addEventListener(
+    "scroll",
+    () => {
+      scrolled = true;
+    },
+    { passive: true, once: true }
+  );
+}
+function onNoScroll(fn, ms = 2500) {
+  if (typeof window === "undefined") return () => {
+  };
+  arm();
+  const t = setTimeout(() => {
+    if (!scrolled) fn();
+  }, ms);
+  return () => clearTimeout(t);
+}
+
+export { onNoScroll };

package/dist/chunk-D7SLSJS4.js

@@ -0,0 +1 @@
+

package/dist/chunk-DIKNRN34.js

@@ -0,0 +1,28 @@
+import { resolveSiteHost } from './chunk-FESKKJAS.js';
+import { normalizeSiteHost } from './chunk-A4CC4ZG3.js';
+
+// src/seo/register-sitemap-request.ts
+function resolveSyncSite(explicit) {
+  const host = normalizeSiteHost(explicit) || resolveSiteHost();
+  return host === "example.com" ? "" : host;
+}
+function registerSitemapBody(req) {
+  const body = { entries: req.entries, mode: req.mode };
+  const site = normalizeSiteHost(req.site);
+  if (site) body.site = site;
+  if (req.optimizeMeta !== void 0) body.optimize_meta = req.optimizeMeta;
+  if (req.awaitMeta !== void 0) body.await_meta = req.awaitMeta;
+  return body;
+}
+function postRegisterSitemap(req) {
+  return fetch(`${req.apiUrl}/api/public/seo/register-sitemap`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": req.apiKey
+    },
+    body: JSON.stringify(registerSitemapBody(req))
+  });
+}
+
+export { postRegisterSitemap, resolveSyncSite };

package/dist/chunk-DXO6SBMD.js

@@ -0,0 +1,43 @@
+import { jsx } from 'react/jsx-runtime';
+
+// src/forms/HoneypotField.tsx
+function HoneypotField({ name, value, onChange }) {
+  const interactive = typeof onChange === "function";
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      type: "text",
+      name,
+      tabIndex: -1,
+      autoComplete: "new-password",
+      "aria-hidden": "true",
+      inert: true,
+      "data-sk-honeypot": "",
+      "data-1p-ignore": "",
+      "data-lpignore": "true",
+      "data-form-type": "other",
+      "data-bwignore": "",
+      style: {
+        position: "absolute",
+        left: -9999,
+        width: 1,
+        height: 1,
+        overflow: "hidden",
+        opacity: 0,
+        visibility: "hidden",
+        pointerEvents: "none"
+      },
+      ...interactive ? {
+        value: value ?? "",
+        onChange: (e) => {
+          onChange(e.target.value);
+          if (e.target.value) {
+            console.warn("[Forms] Honeypot triggered");
+          }
+        }
+      } : { defaultValue: "" }
+    }
+  );
+}
+
+export { HoneypotField };

package/dist/chunk-EDYHROQ7.js

@@ -0,0 +1,77 @@
+import { monotonicMs } from './chunk-MH2DSGC6.js';
+
+// src/reputation/api.ts
+var reviewsCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 6e4;
+function getApiConfig() {
+  const apiUrl = typeof window !== "undefined" ? window.__SITE_KIT_API_URL__ || "https://api.sonor.io" : process.env.SONOR_API_URL || "https://api.sonor.io";
+  const apiKey = typeof window !== "undefined" ? window.__SITE_KIT_API_KEY__ || "" : process.env.SONOR_API_KEY || "";
+  return { apiUrl, apiKey };
+}
+async function fetchWithRetry(url, headers, retries = 2) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const response = await fetch(url, { headers });
+    if (response.ok) return response;
+    if (response.status === 429 && attempt < retries) {
+      const delay = Math.pow(2, attempt + 1) * 1e3;
+      await new Promise((r) => setTimeout(r, delay));
+      continue;
+    }
+    return response;
+  }
+  return new Response(null, { status: 500 });
+}
+async function fetchReviews(options = {}) {
+  const { apiUrl, apiKey } = getApiConfig();
+  if (!apiKey) {
+    return [];
+  }
+  const params = new URLSearchParams();
+  if (options.service) params.append("service", options.service);
+  if (options.limit) params.append("limit", options.limit.toString());
+  if (options.featured) params.append("featured", "true");
+  const qs = params.toString() ? `?${params.toString()}` : "";
+  const url = `${apiUrl}/api/public/reviews${qs}`;
+  const cacheKey = `${apiKey}|${url}`;
+  const cached = reviewsCache.get(cacheKey);
+  if (cached && monotonicMs() - cached.timestamp < CACHE_TTL) {
+    return cached.data;
+  }
+  try {
+    const response = await fetchWithRetry(url, { "x-api-key": apiKey });
+    if (!response.ok) {
+      if (response.status !== 429) {
+        console.error("[Reputation] Error fetching reviews:", response.statusText);
+      }
+      return [];
+    }
+    const data = await response.json();
+    const reviews = data.reviews || [];
+    reviewsCache.set(cacheKey, { data: reviews, timestamp: monotonicMs() });
+    return reviews;
+  } catch (error) {
+    console.error("[Reputation] Error fetching reviews:", error);
+    return [];
+  }
+}
+async function fetchReviewStats() {
+  const { apiUrl, apiKey } = getApiConfig();
+  if (!apiKey) {
+    return null;
+  }
+  try {
+    const response = await fetchWithRetry(
+      `${apiUrl}/api/public/reviews/stats`,
+      { "x-api-key": apiKey }
+    );
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("[Reputation] Error fetching stats:", error);
+    return null;
+  }
+}
+
+export { fetchReviewStats, fetchReviews };

package/dist/chunk-EKBEOXTH.js

@@ -0,0 +1,114 @@
+// src/contracts/portfolio.ts
+var FRAME_READY_MESSAGE = "sonor:frame-ready";
+function isFrameReadyMessage(data) {
+  return !!data && typeof data === "object" && data.type === FRAME_READY_MESSAGE && data.v === 1;
+}
+var PORTFOLIO_CONTRACT_VERSION = 1;
+var LIGHTHOUSE_RE = /lighthouse/i;
+function isLighthouseKpi(kpi) {
+  return LIGHTHOUSE_RE.test(kpi.label || "");
+}
+function curateHeroKpis(kpis) {
+  const business = kpis.filter((k) => !isLighthouseKpi(k));
+  const lighthouse = kpis.filter(isLighthouseKpi);
+  if (lighthouse.length <= 1) return kpis;
+  const allPerfect = lighthouse.length >= 4 && lighthouse.every((k) => k.value === 100);
+  const summary = allPerfect ? {
+    ...lighthouse[0],
+    label: "Lighthouse, all 4 categories",
+    description: "Perfect scores across performance, SEO, accessibility, and best practices."
+  } : lighthouse.find((k) => /performance/i.test(k.label)) ?? lighthouse[0];
+  return [...business, summary];
+}
+var PORTFOLIO_KPI_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://sonor.io/schemas/portfolio-kpi.v1.json",
+  title: "KpiLike",
+  description: "The subset of a portfolio KPI tile the Lighthouse-collapse policy reads.",
+  type: "object",
+  required: ["label", "value"],
+  properties: {
+    label: { type: "string" },
+    value: { type: "number" },
+    description: { type: "string" },
+    source: { enum: ["measured", "reported", "estimated"] },
+    reportedBy: {
+      type: "object",
+      required: ["name", "organization", "date"],
+      properties: {
+        name: { type: "string", minLength: 1 },
+        role: { type: "string" },
+        organization: { type: "string", minLength: 1 },
+        date: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$" }
+      }
+    }
+  },
+  // A reported number is only valid with someone named behind it.
+  if: { properties: { source: { const: "reported" } }, required: ["source"] },
+  then: { required: ["reportedBy"] },
+  additionalProperties: true
+};
+var METRIC_SOURCES = ["measured", "reported", "estimated"];
+var ISO_DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function isMetricSource(value) {
+  return typeof value === "string" && METRIC_SOURCES.includes(value);
+}
+function metricSourceProblem(metric) {
+  if (metric.source === void 0 || metric.source === null) return null;
+  if (!isMetricSource(metric.source)) return `source must be one of ${METRIC_SOURCES.join(", ")}`;
+  if (metric.source !== "reported") return null;
+  const by = metric.reportedBy;
+  if (!by || typeof by !== "object") {
+    return "a reported number needs reportedBy: who reported it, where they work, and when";
+  }
+  if (typeof by.name !== "string" || !by.name.trim()) return "reportedBy.name is required";
+  if (typeof by.organization !== "string" || !by.organization.trim()) {
+    return "reportedBy.organization is required";
+  }
+  if (typeof by.date !== "string" || !ISO_DAY_RE.test(by.date) || Number.isNaN(Date.parse(by.date))) {
+    return "reportedBy.date must be a real day, YYYY-MM-DD";
+  }
+  if (by.role !== void 0 && typeof by.role !== "string") return "reportedBy.role must be text";
+  return null;
+}
+function isHeadlineMetric(metric) {
+  if (metric.source === "measured") return true;
+  return metric.source === "reported" && metricSourceProblem(metric) === null;
+}
+function metricSourceLabel(source) {
+  if (source === "measured") return "Measured";
+  if (source === "reported") return "Client-reported";
+  if (source === "estimated") return "Estimated";
+  return null;
+}
+function formatAttribution(by) {
+  const [year, month, day] = by.date.split("-").map(Number);
+  const when = MONTHS[month - 1] ? `${MONTHS[month - 1]} ${day}, ${year}` : by.date;
+  return [`Reported by ${by.name.trim()}`, by.role?.trim(), by.organization.trim(), when].filter(Boolean).join(", ");
+}
+function shortAttribution(by) {
+  return `per ${by.organization.trim()}`;
+}
+function carryReportedMetrics(previous, next, keyOf) {
+  const norm = (metric) => String(keyOf(metric) ?? "").trim().toLowerCase();
+  const reported = (previous ?? []).filter((m) => m?.source === "reported");
+  const taken = new Set(reported.map(norm));
+  const generated = (next ?? []).filter((m) => m && m.source !== "reported" && !taken.has(norm(m)));
+  return [...reported, ...generated];
+}
+
+export { FRAME_READY_MESSAGE, METRIC_SOURCES, PORTFOLIO_CONTRACT_VERSION, PORTFOLIO_KPI_JSON_SCHEMA, carryReportedMetrics, curateHeroKpis, formatAttribution, isFrameReadyMessage, isHeadlineMetric, isLighthouseKpi, isMetricSource, metricSourceLabel, metricSourceProblem, shortAttribution };

package/dist/chunk-FESKKJAS.js

@@ -0,0 +1,19 @@
+import { normalizeSiteHost } from './chunk-A4CC4ZG3.js';
+
+// src/sites/resolve.ts
+function resolveSiteHost(explicitSite) {
+  const envSiteUrl = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_SITE_URL : void 0;
+  let resolved = explicitSite ?? "";
+  if (!resolved && envSiteUrl) {
+    try {
+      resolved = new URL(envSiteUrl).host;
+    } catch {
+    }
+  }
+  if (!resolved && typeof window !== "undefined") {
+    resolved = window.location.host;
+  }
+  return normalizeSiteHost(resolved) ?? "";
+}
+
+export { resolveSiteHost };