@jmp-technologies/analytics 0.1.17 → 0.1.19

package/dist/index.d.ts

@@ -1,19 +1,95 @@
-type EarlyPageViewBeaconArgs = {
-    baseUrl: string;
-    trackingKey: string;
+/**
+ * Classify outbound contact links for auto-tracking.
+ *
+ * Keep channel set in sync with `lib/ingest/contact-click.ts` on the dashboard side.
+ *
+ * Channels detected from `href` alone (no widget / iframe detection):
+ *
+ * - `call` — `tel:` (delegates to existing `trackCallClick`)
+ * - `email` — `mailto:` (delegates to existing `trackEmailClick`)
+ * - `sms` — `sms:` / `smsto:`
+ * - `whatsapp` — `wa.me`, `api.whatsapp.com`, `whatsapp.com/send`
+ * - `maps` — Google Maps, Apple Maps, `maps.app.goo.gl`, `geo:`
+ * - `booking` — fixed allowlist of common scheduling hosts (see {@link BOOKING_LINK_HOSTS})
+ *
+ * `linkHost` returned in `contact_click` results is the hostname only — never the full URL
+ * (avoids leaking phone numbers in `tel:`/`sms:` URLs and PII-laden booking query strings).
+ */
+type ContactLinkChannel = "sms" | "whatsapp" | "maps" | "booking";
+type ClassifiedContactLink = {
+    kind: "call";
+} | {
+    kind: "email";
+} | {
+    kind: "contact_click";
+    channel: ContactLinkChannel;
+    linkHost: string | null;
+};
+/** v1 booking hosts (~80%+ SMB coverage). Add hosts here when a client uses something rare. */
+declare const BOOKING_LINK_HOSTS: readonly ["calendly.com", "cal.com", "acuityscheduling.com", "calendar.google.com", "calendar.app.google", "bookings.microsoft.com", "outlook.office.com", "outlook.office365.com", "book.ms", "setmore.com", "simplybook.me", "oncehub.com", "scheduleonce.com", "youcanbook.me", "savvycal.com", "tidycal.com", "zohobookings.com", "square.site", "squareup.com", "meetings.hubspot.com", "jobber.com", "housecallpro.com", "servicetitan.com", "thryv.com", "honeybook.com", "dubsado.com", "fresha.com", "booksy.com", "vagaro.com", "mindbodyonline.com", "mindbody.io", "janeapp.com", "cliniko.com", "practicebetter.io"];
+/** Returns `null` when the link should not be tracked as a contact link. */
+declare function classifyContactHref(href: string): ClassifiedContactLink | null;
+
+/** Inline script for Next.js `beforeInteractive` — capture referrer/UTM only (no network). */
+declare function buildLandingCaptureInlineScript(): string;
+
+/** Per-site values used when the dashboard profile is missing or fields are empty. */
+type JmpSiteContactFallback = {
+    displayName?: string;
+    founderName?: string;
+    email?: string;
+    phone?: string | null;
+    linkedin?: string | null;
+    hours?: string | null;
+    serviceArea?: string | null;
+    dashboardDemoUrl?: string;
+    profilePhotoSrc?: string;
+    privacyUrl?: string;
+    termsUrl?: string;
+};
+type JmpSiteDefinition = {
+    /** Content tabs this site uses — reported via instrumentation capabilities. */
+    contentWrappers: JmpContentWrapper[];
+    /**
+     * Public site origin (no trailing slash), e.g. `https://example.com`.
+     * Used to resolve relative profile image paths in structured data.
+     */
+    siteUrl?: string;
+    contactFallback?: JmpSiteContactFallback;
+    /**
+     * `extras` keys to read from the dashboard site profile (hyphenated keys from admin).
+     */
+    contactExtraKeys?: {
+        founderName?: readonly string[];
+        dashboardDemoUrl?: readonly string[];
+        profilePhotoSrc?: readonly string[];
+        hours?: readonly string[];
+        serviceArea?: readonly string[];
+    };
 };
 /**
- * Capture landing referrer/UTMs and send an early page_view (fetch keepalive).
- * Safe to call from inline script or module init.
+ * Register site-specific JMP integration options once (typically from `jmp.config.ts`).
+ * Call at module load time before server content or instrumentation runs.
  */
-declare function sendEarlyPageViewBeacon(args: EarlyPageViewBeaconArgs): boolean;
-/** Inline script for Next.js `beforeInteractive` — earliest capture + beacon. */
-declare function buildLandingCaptureInlineScript(args: {
-    baseUrl: string;
-    trackingKey: string;
-}): string;
+declare function defineJmpSite(definition: JmpSiteDefinition): JmpSiteDefinition;
+declare function getJmpSiteDefinition(): JmpSiteDefinition | null;
+/** Server content + lead config: env vars + wrappers from {@link defineJmpSite}. */
+declare function getJmpContentConfig(): JmpContentConfig | null;
 
-type JmpEventType = "page_view" | "form_submit" | "call_click" | "email_click";
+/** Published package version — sent with capabilities for admin readiness. */
+declare const JMP_ANALYTICS_SDK_VERSION = "0.1.19";
+/** `localStorage` key when {@link JmpAnalyticsConfig.requireConsent} is enabled. */
+declare const JMP_TRACKING_CONSENT_STORAGE_KEY = "jmp_analytics_consent_v1";
+/** Whether analytics events may be sent (after CMP / cookie banner). */
+declare function isJmpTrackingConsentGranted(): boolean;
+/** Subscribe to consent changes (for React `useSyncExternalStore`). */
+declare function subscribeJmpTrackingConsent(listener: () => void): () => void;
+/**
+ * Grant or deny analytics. Persists in `localStorage` when `requireConsent` is used.
+ * Call from your cookie banner before tracking runs.
+ */
+declare function setJmpTrackingConsent(granted: boolean): void;
+type JmpEventType = "page_view" | "form_submit" | "call_click" | "email_click" | "contact_click";
 type JmpAnalyticsConfig = {
     /** Dashboard origin, e.g. https://analytics.example.com (no trailing slash) */
     baseUrl: string;
@@ -28,6 +104,21 @@ type JmpAnalyticsConfig = {
      * Helps with React Strict Mode double-mount; typical: 500–1000.
      */
     pageViewDedupeMs?: number;
+    /**
+     * When true, no events are sent until {@link setJmpTrackingConsent}(true).
+     * Pair with your cookie banner; see `NEXT_PUBLIC_JMP_ANALYTICS_REQUIRE_CONSENT`.
+     */
+    requireConsent?: boolean;
+    /**
+     * When true, register a single delegated `click` listener that classifies links
+     * (SMS, WhatsApp, maps, scheduling) and records them via {@link trackContactClick}.
+     *
+     * Off by default — pair with privacy disclosure / consent before enabling.
+     * `tel:` / `mailto:` continue to use {@link trackCallClick} / {@link trackEmailClick}.
+     *
+     * Opt out per-link with `data-jmp-no-track` on an `<a>` (or an ancestor).
+     */
+    autoTrackContactLinks?: boolean;
 };
 type JmpContentConfig = Pick<JmpAnalyticsConfig, "baseUrl" | "trackingKey" | "debug" | "fetchImpl"> & {
     /**
@@ -36,15 +127,9 @@ type JmpContentConfig = Pick<JmpAnalyticsConfig, "baseUrl" | "trackingKey" | "de
      * Call {@link registerJmpContentWrappers} at startup / deploy.
      */
     contentWrappers?: JmpContentWrapper[];
-    /**
-     * @deprecated Use `contentWrappers` (e.g. `trust.testimonials` instead of `testimonials`).
-     */
-    trustSlots?: JmpTrustSlot[];
 };
 /** Top-level and trust sub-wrappers the client can declare. */
 type JmpContentWrapper = "blog" | "faq" | "contact" | "trust" | "trust.summary" | "trust.testimonials" | "trust.reviews" | "trust.stats" | "trust.logos" | "trust.credentials";
-/** @deprecated Trust-only shorthand; prefer `JmpContentWrapper`. */
-type JmpTrustSlot = "summary" | "testimonials" | "reviews" | "stats" | "logos" | "credentials";
 type JmpBlogPost = {
     id: string;
     title: string;
@@ -241,8 +326,16 @@ declare function createJmpAnalytics(config: JmpAnalyticsConfig): {
     trackFormSubmit: (path: string, metadata?: Record<string, unknown>) => Promise<void>;
     trackCallClick: (path: string, metadata?: Record<string, unknown>) => Promise<void>;
     trackEmailClick: (path: string, metadata?: Record<string, unknown>) => Promise<void>;
+    trackContactClick: (path: string, options: {
+        channel: ContactLinkChannel;
+        linkHost?: string | null;
+        metadata?: Record<string, unknown>;
+    }) => Promise<void>;
     trackLead: (options?: TrackLeadOptions) => Promise<void>;
     subscribeToSpaNavigation: () => () => void;
+    subscribeContactLinkAutoTrack: () => () => void;
+    setTrackingConsent: typeof setJmpTrackingConsent;
+    isTrackingConsentGranted: typeof isJmpTrackingConsentGranted;
 };
 type JmpAnalytics = ReturnType<typeof createJmpAnalytics>;
 declare function trackJmpServerPageView(config: JmpContentConfig, options?: TrackServerPageViewOptions): Promise<void>;
@@ -263,14 +356,6 @@ declare function registerJmpContentWrappers(config: JmpContentConfig): Promise<{
     ok: false;
     skipped: true;
 }>;
-/** @deprecated Use {@link registerJmpContentWrappers} with `contentWrappers`. */
-declare function registerJmpTrustCapabilities(config: JmpContentConfig): Promise<{
-    ok: true;
-    slots: JmpTrustSlot[];
-} | {
-    ok: false;
-    skipped: true;
-}>;
 declare function createJmpContentClient(config: JmpContentConfig): {
     getBlogPosts: () => Promise<JmpBlogPost[]>;
     getBlogPost: (slug: string) => Promise<JmpBlogPost | null>;
@@ -285,14 +370,6 @@ declare function createJmpContentClient(config: JmpContentConfig): {
         ok: false;
         skipped: true;
     }>;
-    /** @deprecated Use registerContentWrappers */
-    registerTrustCapabilities: () => Promise<{
-        ok: true;
-        slots: JmpTrustSlot[];
-    } | {
-        ok: false;
-        skipped: true;
-    }>;
 };
 /** Default `pageViewDedupeMs` when resolving browser config from env (Strict Mode / SPA). */
 declare const DEFAULT_JMP_BROWSER_PAGE_VIEW_DEDUPE_MS = 800;
@@ -321,4 +398,4 @@ type JmpContentClient = ReturnType<typeof createJmpContentClient>;
  */
 declare function createJmpContentClientFromServerEnv(overrides?: Partial<JmpContentConfig>): JmpContentClient | null;
 
-export { DEFAULT_JMP_BROWSER_PAGE_VIEW_DEDUPE_MS, type JmpAnalytics, type JmpAnalyticsConfig, type JmpBlogPost, type JmpContentClient, type JmpContentConfig, type JmpContentWrapper, type JmpCredential, type JmpEventType, type JmpFaqItem, type JmpPartnerLogo, type JmpServerRequestLike, type JmpSiteProfile, type JmpTestimonial, type JmpTrustBundle, type JmpTrustSlot, type JmpTrustStat, type JmpTrustSummary, type LeadMetadata, type LeadMetadataValue, type TrackLeadOptions, type TrackPageViewOptions, type TrackServerPageViewOptions, buildLandingCaptureInlineScript, createJmpAnalytics, createJmpContentClient, createJmpContentClientFromServerEnv, getJmpBlogPost, getJmpBlogPosts, getJmpBrowserAnalyticsConfigFromEnv, getJmpFaqs, getJmpRobotsTxt, getJmpServerContentConfigFromEnv, getJmpSiteProfile, getJmpTrustBundle, getOrCreateJmpAnalyticsFromBrowserEnv, isJmpBrowserAnalyticsEnvConfigured, isJmpServerContentEnvConfigured, registerJmpContentWrappers, registerJmpTrustCapabilities, sendEarlyPageViewBeacon, trackJmpServerPageView };
+export { BOOKING_LINK_HOSTS, type ClassifiedContactLink, type ContactLinkChannel, DEFAULT_JMP_BROWSER_PAGE_VIEW_DEDUPE_MS, JMP_ANALYTICS_SDK_VERSION, JMP_TRACKING_CONSENT_STORAGE_KEY, type JmpAnalytics, type JmpAnalyticsConfig, type JmpBlogPost, type JmpContentClient, type JmpContentConfig, type JmpContentWrapper, type JmpCredential, type JmpEventType, type JmpFaqItem, type JmpPartnerLogo, type JmpServerRequestLike, type JmpSiteContactFallback, type JmpSiteDefinition, type JmpSiteProfile, type JmpTestimonial, type JmpTrustBundle, type JmpTrustStat, type JmpTrustSummary, type LeadMetadata, type LeadMetadataValue, type TrackLeadOptions, type TrackPageViewOptions, type TrackServerPageViewOptions, buildLandingCaptureInlineScript, classifyContactHref, createJmpAnalytics, createJmpContentClient, createJmpContentClientFromServerEnv, defineJmpSite, getJmpBlogPost, getJmpBlogPosts, getJmpBrowserAnalyticsConfigFromEnv, getJmpContentConfig, getJmpFaqs, getJmpRobotsTxt, getJmpServerContentConfigFromEnv, getJmpSiteDefinition, getJmpSiteProfile, getJmpTrustBundle, getOrCreateJmpAnalyticsFromBrowserEnv, isJmpBrowserAnalyticsEnvConfigured, isJmpServerContentEnvConfigured, isJmpTrackingConsentGranted, registerJmpContentWrappers, setJmpTrackingConsent, subscribeJmpTrackingConsent, trackJmpServerPageView };

package/dist/index.js

@@ -1,45 +1,61 @@
 import {
+  BOOKING_LINK_HOSTS,
   DEFAULT_JMP_BROWSER_PAGE_VIEW_DEDUPE_MS,
+  JMP_ANALYTICS_SDK_VERSION,
+  JMP_TRACKING_CONSENT_STORAGE_KEY,
   buildLandingCaptureInlineScript,
+  classifyContactHref,
   createJmpAnalytics,
   createJmpContentClient,
   createJmpContentClientFromServerEnv,
+  defineJmpSite,
   getJmpBlogPost,
   getJmpBlogPosts,
   getJmpBrowserAnalyticsConfigFromEnv,
+  getJmpContentConfig,
   getJmpFaqs,
   getJmpRobotsTxt,
   getJmpServerContentConfigFromEnv,
+  getJmpSiteDefinition,
   getJmpSiteProfile,
   getJmpTrustBundle,
   getOrCreateJmpAnalyticsFromBrowserEnv,
   isJmpBrowserAnalyticsEnvConfigured,
   isJmpServerContentEnvConfigured,
+  isJmpTrackingConsentGranted,
   registerJmpContentWrappers,
-  registerJmpTrustCapabilities,
-  sendEarlyPageViewBeacon,
+  setJmpTrackingConsent,
+  subscribeJmpTrackingConsent,
   trackJmpServerPageView
-} from "./chunk-MUHLIN7P.js";
+} from "./chunk-GB37RVJJ.js";
 export {
+  BOOKING_LINK_HOSTS,
   DEFAULT_JMP_BROWSER_PAGE_VIEW_DEDUPE_MS,
+  JMP_ANALYTICS_SDK_VERSION,
+  JMP_TRACKING_CONSENT_STORAGE_KEY,
   buildLandingCaptureInlineScript,
+  classifyContactHref,
   createJmpAnalytics,
   createJmpContentClient,
   createJmpContentClientFromServerEnv,
+  defineJmpSite,
   getJmpBlogPost,
   getJmpBlogPosts,
   getJmpBrowserAnalyticsConfigFromEnv,
+  getJmpContentConfig,
   getJmpFaqs,
   getJmpRobotsTxt,
   getJmpServerContentConfigFromEnv,
+  getJmpSiteDefinition,
   getJmpSiteProfile,
   getJmpTrustBundle,
   getOrCreateJmpAnalyticsFromBrowserEnv,
   isJmpBrowserAnalyticsEnvConfigured,
   isJmpServerContentEnvConfigured,
+  isJmpTrackingConsentGranted,
   registerJmpContentWrappers,
-  registerJmpTrustCapabilities,
-  sendEarlyPageViewBeacon,
+  setJmpTrackingConsent,
+  subscribeJmpTrackingConsent,
   trackJmpServerPageView
 };
 //# sourceMappingURL=index.js.map

package/dist/next/content.cjs

@@ -0,0 +1,322 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/content.ts
+var content_exports = {};
+__export(content_exports, {
+  absoluteSiteAssetUrl: () => absoluteSiteAssetUrl,
+  filterFeaturedTrustQuotes: () => filterFeaturedTrustQuotes,
+  getJmpContentConfig: () => getJmpContentConfig,
+  getResolvedSiteContact: () => getResolvedSiteContact,
+  loadBlogPost: () => loadBlogPost,
+  loadBlogPosts: () => loadBlogPosts,
+  loadFaqBySlug: () => loadFaqBySlug,
+  loadFaqs: () => loadFaqs,
+  loadSiteProfile: () => loadSiteProfile,
+  loadTrustBundle: () => loadTrustBundle,
+  resolveSiteContact: () => resolveSiteContact
+});
+module.exports = __toCommonJS(content_exports);
+var import_react = require("react");
+
+// src/landing-capture.ts
+var LANDING_REFERER_COOKIE_MAX_AGE_SEC = 30 * 60;
+
+// src/site-config.ts
+var registeredSite = null;
+function readNextPublicEnv(key) {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  const v = key === "NEXT_PUBLIC_JMP_ANALYTICS_URL" ? process.env.NEXT_PUBLIC_JMP_ANALYTICS_URL : process.env.NEXT_PUBLIC_JMP_TRACKING_KEY;
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function getServerConfigFromEnv() {
+  const baseUrl = readNextPublicEnv("NEXT_PUBLIC_JMP_ANALYTICS_URL");
+  const trackingKey = readNextPublicEnv("NEXT_PUBLIC_JMP_TRACKING_KEY");
+  if (!baseUrl || !trackingKey) return null;
+  return { baseUrl, trackingKey };
+}
+function getJmpSiteDefinition() {
+  return registeredSite;
+}
+function getJmpContentConfig() {
+  const fromEnv = getServerConfigFromEnv();
+  if (!fromEnv) {
+    return null;
+  }
+  const site = getJmpSiteDefinition();
+  return {
+    ...fromEnv,
+    contentWrappers: site?.contentWrappers ?? fromEnv.contentWrappers
+  };
+}
+
+// src/index.ts
+function responseLooksLikeHtml(body) {
+  const s = body.trimStart();
+  return s.startsWith("<!") || s.toLowerCase().startsWith("<html") || s.startsWith("<") && /<html[\s>]/i.test(s.slice(0, 500));
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+async function getJmpBlogPosts(config) {
+  const data = await getContent(
+    config,
+    "/api/content/blog"
+  );
+  return data.posts;
+}
+async function getJmpBlogPost(config, slug) {
+  try {
+    const data = await getContent(
+      config,
+      `/api/content/blog/${encodeURIComponent(slug)}`
+    );
+    return data.post;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("HTTP 404")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function getJmpFaqs(config) {
+  const data = await getContent(
+    config,
+    "/api/content/faqs"
+  );
+  return data.faqs;
+}
+async function getJmpTrustBundle(config) {
+  return getContent(config, "/api/content/trust");
+}
+async function getJmpSiteProfile(config) {
+  const data = await getContent(
+    config,
+    "/api/content/site"
+  );
+  return data.site;
+}
+async function getContent(config, path) {
+  const text = await getContentText(config, path);
+  try {
+    return JSON.parse(text);
+  } catch {
+    const baseUrl = normalizeBaseUrl(config.baseUrl);
+    const url = `${baseUrl}${path}`;
+    throw new Error(`JMP content HTTP 200 \u2014 ${url} returned invalid JSON.`);
+  }
+}
+async function getContentText(config, path) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl);
+  const resolvedFetch = config.fetchImpl ?? (typeof globalThis !== "undefined" && globalThis.fetch ? globalThis.fetch.bind(globalThis) : void 0);
+  if (!resolvedFetch) {
+    throw new Error("JMP content: fetch is not available; pass fetchImpl in config");
+  }
+  const url = `${baseUrl}${path}`;
+  if (config.debug) {
+    console.debug("[@jmp-technologies/analytics]", "GET", url);
+  }
+  const res = await resolvedFetch(url, {
+    method: "GET",
+    headers: {
+      "X-JMP-Tracking-Key": config.trackingKey
+    }
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    if (responseLooksLikeHtml(text)) {
+      throw new Error(
+        `JMP content HTTP ${res.status} \u2014 ${url} returned HTML (not the JSON API). Set baseUrl to your JMP Analytics dashboard origin.`
+      );
+    }
+    let parsed = {};
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = { error: text };
+    }
+    throw new Error(
+      [`JMP content HTTP ${res.status}`, parsed.error, parsed.hint].filter(Boolean).join(" \u2014 ")
+    );
+  }
+  return text;
+}
+
+// src/next/content.ts
+var DEFAULT_EXTRA_KEYS = {
+  founderName: ["founder-name", "founder_name"],
+  dashboardDemoUrl: ["dashboard-demo-url", "sample-dashboard-url"],
+  profilePhotoSrc: ["profile-photo-url", "profile_photo_url"],
+  hours: ["hours", "business-hours"],
+  serviceArea: ["service-area", "service_area", "service-area-text"]
+};
+function sortBlogPosts(posts) {
+  return [...posts].sort((a, b) => {
+    const da = a.published_at ?? a.updated_at;
+    const db = b.published_at ?? b.updated_at;
+    return db.localeCompare(da);
+  });
+}
+function sortFaqs(items) {
+  return [...items].sort((a, b) => a.sort_order - b.sort_order);
+}
+function readProfileExtra(profile, keys) {
+  for (const key of keys) {
+    const value = profile?.extras?.[key]?.trim();
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+}
+function absoluteSiteAssetUrl(src) {
+  const trimmed = src.trim();
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return trimmed;
+  }
+  const siteUrl = getJmpSiteDefinition()?.siteUrl?.replace(/\/$/, "");
+  if (!siteUrl) {
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  }
+  return `${siteUrl}${trimmed.startsWith("/") ? trimmed : `/${trimmed}`}`;
+}
+var loadSiteProfile = (0, import_react.cache)(async () => {
+  const config = getJmpContentConfig();
+  if (!config) {
+    return null;
+  }
+  try {
+    return await getJmpSiteProfile(config);
+  } catch {
+    return null;
+  }
+});
+function resolveSiteContact(profile) {
+  const site = getJmpSiteDefinition();
+  const fallback = site?.contactFallback ?? {};
+  const extraKeys = {
+    ...DEFAULT_EXTRA_KEYS,
+    ...site?.contactExtraKeys
+  };
+  const email = profile?.email?.trim() || fallback.email || "";
+  const linkedin = profile?.social?.linkedin?.trim() || fallback.linkedin || null;
+  const phone = profile?.phone?.trim() || fallback.phone || null;
+  return {
+    displayName: profile?.display_name?.trim() || profile?.name?.trim() || fallback.displayName || "",
+    founderName: readProfileExtra(profile, extraKeys.founderName ?? []) || fallback.founderName || "",
+    dashboardDemoUrl: readProfileExtra(profile, extraKeys.dashboardDemoUrl ?? []) || fallback.dashboardDemoUrl || "",
+    profilePhotoSrc: readProfileExtra(profile, extraKeys.profilePhotoSrc ?? []) || fallback.profilePhotoSrc || "",
+    email,
+    linkedin,
+    phone,
+    hours: readProfileExtra(profile, extraKeys.hours ?? []) || fallback.hours || null,
+    serviceArea: readProfileExtra(profile, extraKeys.serviceArea ?? []) || fallback.serviceArea || null,
+    privacyUrl: profile?.legal?.privacy_policy_url?.trim() || fallback.privacyUrl || "/privacy",
+    termsUrl: profile?.legal?.terms_url?.trim() || fallback.termsUrl || "/terms",
+    cta: {
+      label: profile?.cta?.label?.trim() || null,
+      url: profile?.cta?.url?.trim() || null
+    }
+  };
+}
+async function getResolvedSiteContact() {
+  const profile = await loadSiteProfile();
+  return resolveSiteContact(profile);
+}
+var loadBlogPosts = (0, import_react.cache)(async () => {
+  const c = getJmpContentConfig();
+  if (!c) {
+    return [];
+  }
+  try {
+    const posts = await getJmpBlogPosts(c);
+    return sortBlogPosts(posts);
+  } catch {
+    return [];
+  }
+});
+var loadBlogPost = (0, import_react.cache)(async (slug) => {
+  const c = getJmpContentConfig();
+  if (!c) {
+    return null;
+  }
+  try {
+    return await getJmpBlogPost(c, slug);
+  } catch {
+    return null;
+  }
+});
+var loadFaqs = (0, import_react.cache)(async () => {
+  const c = getJmpContentConfig();
+  if (!c) {
+    return [];
+  }
+  try {
+    const faqs = await getJmpFaqs(c);
+    return sortFaqs(faqs);
+  } catch {
+    return [];
+  }
+});
+async function loadFaqBySlug(slug) {
+  const normalized = slug.trim();
+  if (!normalized) {
+    return null;
+  }
+  const items = await loadFaqs();
+  return items.find((item) => item.slug === normalized || item.id === normalized) ?? null;
+}
+var loadTrustBundle = (0, import_react.cache)(async () => {
+  const c = getJmpContentConfig();
+  if (!c) {
+    return null;
+  }
+  try {
+    return await getJmpTrustBundle(c);
+  } catch {
+    return null;
+  }
+});
+function filterFeaturedTrustQuotes(testimonials, placement, limit = 2) {
+  return testimonials.filter((item) => {
+    if (!item.featured) {
+      return false;
+    }
+    const bucket = item.placement?.trim().toLowerCase();
+    if (placement === "reviews") {
+      return bucket === "reviews";
+    }
+    return !bucket || bucket === "testimonials";
+  }).sort((a, b) => a.sort_order - b.sort_order).slice(0, limit);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  absoluteSiteAssetUrl,
+  filterFeaturedTrustQuotes,
+  getJmpContentConfig,
+  getResolvedSiteContact,
+  loadBlogPost,
+  loadBlogPosts,
+  loadFaqBySlug,
+  loadFaqs,
+  loadSiteProfile,
+  loadTrustBundle,
+  resolveSiteContact
+});
+//# sourceMappingURL=content.cjs.map