@flamingo-stack/openframe-frontend-core 0.0.711 → 0.0.712

package/dist/chunk-CMZ3QTFQ.js

@@ -0,0 +1,1207 @@
+"use client";
+import {
+  apiErrorMessage
+} from "./chunk-34I6XI3N.js";
+import {
+  getPlatformBrandClasses,
+  useMediaQuery
+} from "./chunk-ADBE7QF3.js";
+import {
+  FlamingoLogo,
+  MiamiCyberGangLogoFaceOnly,
+  MlgLogo,
+  OpenFrameLogo,
+  OpenmspLogo
+} from "./chunk-N45D4ZXQ.js";
+import {
+  cn
+} from "./chunk-7RXWKTAP.js";
+
+// src/hooks/ui/use-debounce.ts
+import { useState, useEffect } from "react";
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/hooks/ui/use-header-height.ts
+import { useEffect as useEffect2, useState as useState2 } from "react";
+var SITE_HEADER_SELECTOR = "[data-site-header]";
+function useHeaderHeight(defaultHeight = 72, options = {}) {
+  const { enabled = true, stuckOnly = false } = options;
+  const [height, setHeight] = useState2(defaultHeight);
+  useEffect2(() => {
+    if (!enabled) return void 0;
+    if (stuckOnly) {
+      let stop;
+      const watch = (header2) => {
+        const measureStuck = () => setHeight(header2.style.transform.includes("-100%") ? 0 : header2.offsetHeight);
+        measureStuck();
+        const resize = new ResizeObserver(measureStuck);
+        resize.observe(header2);
+        const mutation = new MutationObserver(measureStuck);
+        mutation.observe(header2, { attributes: true, attributeFilter: ["style"] });
+        stop = () => {
+          resize.disconnect();
+          mutation.disconnect();
+        };
+      };
+      const present = document.querySelector(SITE_HEADER_SELECTOR);
+      if (present) {
+        watch(present);
+        return () => stop?.();
+      }
+      const arrival = new MutationObserver(() => {
+        const header2 = document.querySelector(SITE_HEADER_SELECTOR);
+        if (!header2) return;
+        arrival.disconnect();
+        watch(header2);
+      });
+      arrival.observe(document.body, { childList: true, subtree: true });
+      return () => {
+        arrival.disconnect();
+        stop?.();
+      };
+    }
+    const measure = () => {
+      let total = 0;
+      const header2 = document.querySelector("header");
+      if (header2) total += header2.offsetHeight;
+      const bar2 = document.querySelector("[data-announcement-bar]");
+      if (bar2 instanceof HTMLElement) total += bar2.offsetHeight;
+      setHeight(total > 0 ? total : defaultHeight);
+    };
+    measure();
+    const resizeObserver = new ResizeObserver(measure);
+    const header = document.querySelector("header");
+    if (header) resizeObserver.observe(header);
+    const bar = document.querySelector("[data-announcement-bar]");
+    if (bar) resizeObserver.observe(bar);
+    const mutationObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (mutation.type === "childList" || mutation.type === "attributes") {
+          measure();
+          const newBar = document.querySelector("[data-announcement-bar]");
+          if (newBar) resizeObserver.observe(newBar);
+        }
+      }
+    });
+    mutationObserver.observe(document.body, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["data-announcement-bar"]
+    });
+    return () => {
+      resizeObserver.disconnect();
+      mutationObserver.disconnect();
+    };
+  }, [defaultHeight, enabled, stuckOnly]);
+  return height;
+}
+
+// src/hooks/ui/use-marquee-engine.ts
+import { useCallback, useEffect as useEffect3, useRef } from "react";
+var RESYNC_EPSILON = 1.5;
+function useMarqueeEngine(options) {
+  const posRef = useRef(0);
+  const glideRemainingRef = useRef(0);
+  const speedEnvRef = useRef(0);
+  const optsRef = useRef(options);
+  useEffect3(() => {
+    optsRef.current = options;
+  });
+  const wrap = useCallback((pos) => {
+    const half = optsRef.current.getWrapSize();
+    if (half <= 0) return pos;
+    const min = optsRef.current.getWrapMin?.() ?? 0;
+    let wrapped = pos;
+    while (wrapped >= min + half) wrapped -= half;
+    while (wrapped < min) wrapped += half;
+    return wrapped;
+  }, []);
+  const glideBy = useCallback((px) => {
+    glideRemainingRef.current += px;
+  }, []);
+  const active = options.active;
+  useEffect3(() => {
+    if (!active) return void 0;
+    let raf = 0;
+    let last = performance.now();
+    const readBack = optsRef.current.readBack;
+    if (readBack) posRef.current = readBack();
+    const tick = (now) => {
+      const opts = optsRef.current;
+      const dt = Math.min(now - last, 100) / 1e3;
+      last = now;
+      const paused = opts.isPaused(now);
+      const targetSpeed = paused ? 0 : opts.speed;
+      speedEnvRef.current += (targetSpeed - speedEnvRef.current) * Math.min(1, dt / 0.25);
+      if (targetSpeed === 0 && speedEnvRef.current < 0.5) speedEnvRef.current = 0;
+      const external = opts.readBack ? opts.readBack() : null;
+      const resync = () => {
+        if (external !== null && Math.abs(external - posRef.current) > RESYNC_EPSILON) {
+          posRef.current = external;
+        }
+      };
+      const glide = glideRemainingRef.current;
+      if (glide !== 0) {
+        resync();
+        const speed = Math.max(Math.abs(glide) * 6, 240);
+        const step = Math.sign(glide) * Math.min(Math.abs(glide), speed * dt);
+        glideRemainingRef.current = Math.abs(glide - step) < 0.5 ? 0 : glide - step;
+        posRef.current = wrap(posRef.current + step);
+        opts.apply(posRef.current);
+      } else if (speedEnvRef.current > 0) {
+        resync();
+        posRef.current = wrap(posRef.current + speedEnvRef.current * dt);
+        opts.apply(posRef.current);
+      } else if (external !== null) {
+        posRef.current = external;
+      }
+      opts.onAfterFrame?.();
+      raf = requestAnimationFrame(tick);
+    };
+    raf = requestAnimationFrame(tick);
+    return () => cancelAnimationFrame(raf);
+  }, [active, wrap]);
+  return { posRef, glideBy, wrap };
+}
+
+// src/hooks/ui/use-reset-on-page-hidden.ts
+import { useEffect as useEffect4 } from "react";
+function useResetOnPageHidden(reset) {
+  useEffect4(() => {
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") reset();
+    };
+    window.addEventListener("blur", reset);
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      window.removeEventListener("blur", reset);
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, [reset]);
+}
+
+// src/hooks/ui/use-suppress-clone-focus.ts
+import { useEffect as useEffect5, useRef as useRef2 } from "react";
+var CLONE_FOCUSABLE_SELECTOR = 'a[href],button,input,select,textarea,iframe,summary,audio[controls],video[controls],[tabindex],[contenteditable]:not([contenteditable="false"])';
+function useSuppressCloneFocus(active) {
+  const ref = useRef2(null);
+  useEffect5(() => {
+    const root = ref.current;
+    if (!root || !active) return void 0;
+    const suppress = () => {
+      root.querySelectorAll(CLONE_FOCUSABLE_SELECTOR).forEach((el) => {
+        if (el.getAttribute("tabindex") !== "-1") el.setAttribute("tabindex", "-1");
+      });
+    };
+    suppress();
+    const mo = new MutationObserver(suppress);
+    mo.observe(root, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["href", "tabindex", "contenteditable", "controls"]
+    });
+    return () => mo.disconnect();
+  }, [active]);
+  return ref;
+}
+
+// src/hooks/ui/use-prefers-reduced-motion.ts
+var PREFERS_REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+function usePrefersReducedMotion() {
+  return useMediaQuery(PREFERS_REDUCED_MOTION_QUERY) === true;
+}
+function usePrefersReducedMotionState() {
+  return useMediaQuery(PREFERS_REDUCED_MOTION_QUERY);
+}
+
+// src/hooks/ui/use-in-view.ts
+import { useCallback as useCallback2, useEffect as useEffect6, useRef as useRef3, useState as useState3 } from "react";
+var STEPS = Array.from({ length: 21 }, (_, i) => i / 20);
+function useInView({
+  threshold = 0,
+  rootMargin = "0px",
+  initial = false
+} = {}) {
+  const [inView, setInView] = useState3(initial);
+  const observerRef = useRef3(null);
+  const disconnect = useCallback2(() => {
+    observerRef.current?.disconnect();
+    observerRef.current = null;
+  }, []);
+  const ref = useCallback2(
+    (node) => {
+      disconnect();
+      if (!node) {
+        setInView(false);
+        return;
+      }
+      if (typeof IntersectionObserver === "undefined") {
+        setInView(initial);
+        return;
+      }
+      const observer = new IntersectionObserver(
+        (entries) => {
+          const entry = entries[entries.length - 1];
+          if (!entry) return;
+          const ofElement = entry.intersectionRatio >= threshold;
+          const viewportHeight = entry.rootBounds?.height ?? 0;
+          const ofViewport = viewportHeight > 0 && (entry.intersectionRect?.height ?? 0) >= viewportHeight * threshold;
+          setInView(entry.isIntersecting && (ofElement || ofViewport));
+        },
+        { threshold: STEPS, rootMargin }
+      );
+      observer.observe(node);
+      observerRef.current = observer;
+    },
+    [disconnect, threshold, rootMargin, initial]
+  );
+  useEffect6(() => disconnect, [disconnect]);
+  return { ref, inView };
+}
+
+// src/hooks/ui/use-autoplay.ts
+import { useEffect as useEffect7, useState as useState4 } from "react";
+function useAutoplay(onScreen) {
+  const reducedState = usePrefersReducedMotionState();
+  const [paused, setPaused] = useState4(false);
+  const [tabHidden, setTabHidden] = useState4(false);
+  useEffect7(() => {
+    const sync = () => setTabHidden(document.visibilityState === "hidden");
+    sync();
+    document.addEventListener("visibilitychange", sync);
+    window.addEventListener("pageshow", sync);
+    return () => {
+      document.removeEventListener("visibilitychange", sync);
+      window.removeEventListener("pageshow", sync);
+    };
+  }, []);
+  return {
+    playing: onScreen && !paused && !tabHidden && reducedState === false,
+    paused,
+    setPaused,
+    reducedMotion: reducedState === true
+  };
+}
+
+// src/utils/visitor-os.ts
+var DESKTOP_OSES = ["mac", "windows", "linux"];
+var HINT_PLATFORMS = {
+  macos: "mac",
+  windows: "windows",
+  linux: "linux",
+  "chrome os": "linux",
+  "chromium os": "linux",
+  android: "android",
+  ios: "ios"
+};
+function detectVisitorOs(userAgent, hints = {}) {
+  const touchMac = (os) => os === "mac" && (hints.maxTouchPoints ?? 0) > 1 ? "ios" : os;
+  const hinted = HINT_PLATFORMS[(hints.platform ?? "").replace(/"/g, "").trim().toLowerCase()];
+  if (hinted) return touchMac(hinted);
+  const ua = userAgent ?? "";
+  if (!ua) return null;
+  if (/iPhone|iPad|iPod/i.test(ua)) return "ios";
+  if (/Android/i.test(ua)) return "android";
+  if (/Windows NT|Win64|Win32/i.test(ua)) return "windows";
+  if (/Macintosh|Mac OS X/i.test(ua)) return touchMac("mac");
+  if (/Linux|X11|CrOS/i.test(ua)) return "linux";
+  return null;
+}
+function desktopOsOf(os) {
+  return os !== null && DESKTOP_OSES.includes(os) ? os : null;
+}
+function detectDesktopOs(userAgent, hints) {
+  return desktopOsOf(detectVisitorOs(userAgent, hints));
+}
+function usesCommandKey(os) {
+  return os === "mac" || os === "ios";
+}
+function shortcutLabel(os, key) {
+  return usesCommandKey(os) ? `\u2318${key}` : `Ctrl ${key}`;
+}
+
+// src/hooks/ui/use-visitor-os.ts
+import { useSyncExternalStore } from "react";
+var UNKNOWN = { known: false, os: null };
+var KNOWN = /* @__PURE__ */ new Map();
+var subscribe = () => () => {
+};
+var getServerSnapshot = () => UNKNOWN;
+function getSnapshot() {
+  const stated = navigator.userAgentData?.platform;
+  const os = detectVisitorOs(navigator.userAgent, { platform: stated, maxTouchPoints: navigator.maxTouchPoints });
+  let state = KNOWN.get(os);
+  if (!state) {
+    state = { known: true, os };
+    KNOWN.set(os, state);
+  }
+  return state;
+}
+function useVisitorOs() {
+  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+
+// src/utils/platform-config.tsx
+import { Globe } from "lucide-react";
+import { jsx } from "react/jsx-runtime";
+function renderPlatformIcon(platformName, className) {
+  const tinted = cn(className, getPlatformBrandClasses(platformName).accentText);
+  switch (platformName) {
+    case "openframe":
+      return /* @__PURE__ */ jsx(
+        OpenFrameLogo,
+        {
+          className: tinted,
+          lowerPathColor: "currentColor",
+          upperPathColor: "var(--ods-system-greys-white)"
+        }
+      );
+    case "openmsp":
+      return /* @__PURE__ */ jsx(
+        OpenmspLogo,
+        {
+          className: tinted,
+          backBubbleColor: "currentColor",
+          frontBubbleColor: "var(--ods-system-greys-white)",
+          innerFrontBubbleColor: "var(--ods-system-greys-black)"
+        }
+      );
+    case "tmcg":
+      return /* @__PURE__ */ jsx(MiamiCyberGangLogoFaceOnly, { className });
+    case "mlg":
+      return /* @__PURE__ */ jsx(MlgLogo, { className: tinted, size: 20 });
+    case "universal":
+      return /* @__PURE__ */ jsx(Globe, { className: tinted });
+    default:
+      return /* @__PURE__ */ jsx(FlamingoLogo, { className: tinted, fill: "currentColor" });
+  }
+}
+var platformIcons = {
+  openframe: renderPlatformIcon("openframe", "h-5 w-5"),
+  openmsp: renderPlatformIcon("openmsp", "h-5 w-5"),
+  flamingo: renderPlatformIcon("flamingo", "h-5 w-5"),
+  "flamingo-teaser": renderPlatformIcon("flamingo-teaser", "h-5 w-5"),
+  "marketing-hub": renderPlatformIcon("marketing-hub", "h-5 w-5"),
+  "product-hub": renderPlatformIcon("product-hub", "h-5 w-5"),
+  "revenue-hub": renderPlatformIcon("revenue-hub", "h-5 w-5"),
+  "people-hub": renderPlatformIcon("people-hub", "h-5 w-5"),
+  "company-hub": renderPlatformIcon("company-hub", "h-5 w-5"),
+  tmcg: renderPlatformIcon("tmcg", "h-5 w-5"),
+  mlg: renderPlatformIcon("mlg", "h-5 w-5"),
+  universal: renderPlatformIcon("universal", "h-5 w-5")
+};
+function transformPlatformConfigsToOptions(platformConfigs) {
+  return platformConfigs.map((platform) => ({
+    id: platform.id,
+    // Database UUID for matching
+    name: platform.name,
+    // Platform name enum
+    displayName: platform.display_name,
+    // Human-readable name
+    description: platform.description,
+    icon: getPlatformIcon(platform.name),
+    color: getPlatformColorClass(platform.name)
+  }));
+}
+function getPlatformIcon(platformName) {
+  return platformIcons[platformName] ?? platformIcons.universal;
+}
+function getSmallPlatformIcon(platformName) {
+  return renderPlatformIcon(platformName, "h-4 w-4 flex-shrink-0");
+}
+function getPlatformIconComponent(platformName, className = "h-6 w-6") {
+  return renderPlatformIcon(platformName, className);
+}
+function getPlatformColorClass(platformName) {
+  return getPlatformBrandClasses(platformName).accentBg;
+}
+
+// src/utils/access-code-client.ts
+async function validateAccessCode(email, code, endpoints) {
+  try {
+    const response = await fetch(endpoints.validateUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ email, code })
+    });
+    if (!response.ok) {
+      const failure = await response.json().catch(() => null);
+      throw new Error(apiErrorMessage(failure, "Validation request failed"));
+    }
+    return await response.json();
+  } catch (error) {
+    return {
+      valid: false,
+      message: error instanceof Error ? error.message : "Validation failed"
+    };
+  }
+}
+async function consumeAccessCode(email, code, endpoints) {
+  try {
+    const response = await fetch(endpoints.consumeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ email, code })
+    });
+    if (!response.ok) {
+      const failure = await response.json().catch(() => null);
+      throw new Error(apiErrorMessage(failure, "Consumption request failed"));
+    }
+    return await response.json();
+  } catch (error) {
+    return {
+      success: false,
+      consumed: false,
+      message: error instanceof Error ? error.message : "Consumption failed"
+    };
+  }
+}
+async function validateAndConsumeAccessCode(email, code, endpoints) {
+  const validation = await validateAccessCode(email, code, endpoints);
+  if (!validation.valid) {
+    return validation;
+  }
+  const consumption = await consumeAccessCode(email, code, endpoints);
+  return {
+    ...validation,
+    consumed: consumption.consumed,
+    message: consumption.consumed ? `Access granted for ${validation.cohort_name}` : consumption.message || validation.message
+  };
+}
+
+// src/utils/embed-url-converters.ts
+function toGoogleSheetsEmbedUrl(url) {
+  if (url.includes("/htmlembed")) return url;
+  const match = url.match(/\/spreadsheets\/d\/([a-zA-Z0-9-_]+)/);
+  if (!match) return url;
+  const gidMatch = url.match(/[#?&]gid=(\d+)/);
+  const gid = gidMatch ? gidMatch[1] : "0";
+  return `https://docs.google.com/spreadsheets/d/${match[1]}/htmlembed?widget=true&chrome=false&headers=false&gid=${gid}`;
+}
+function toGoogleSheetsOriginalUrl(url) {
+  const match = url.match(/\/spreadsheets\/d\/([a-zA-Z0-9-_]+)/);
+  if (!match) return url;
+  const gidMatch = url.match(/[#?&]gid=(\d+)/);
+  const gid = gidMatch ? gidMatch[1] : "0";
+  return `https://docs.google.com/spreadsheets/d/${match[1]}/edit#gid=${gid}`;
+}
+function toFigmaEmbedUrl(url, opts) {
+  if (url.includes("embed.figma.com")) return url;
+  if (url.includes("figma.com/embed")) return url;
+  const match = url.match(/figma\.com\/(design|file|proto|board|slides|deck)\/([a-zA-Z0-9]+)(?:\/([^?]*))?(\?.*)?$/);
+  if (match) {
+    const [, urlType, fileKey, titleSlug, queryString] = match;
+    const isSlides = urlType === "slides" || urlType === "deck";
+    const embedType = urlType === "proto" ? "proto" : isSlides ? opts?.slidesView === "browse" ? "slides" : "deck" : "design";
+    const pathSuffix = titleSlug ? `/${titleSlug}` : "";
+    const params = new URLSearchParams(queryString?.replace(/^\?/, "") || "");
+    if (!params.has("embed-host")) {
+      params.set("embed-host", "flamingo");
+    }
+    const clientId = process.env.NEXT_PUBLIC_FIGMA_CLIENT_ID;
+    if (clientId && !params.has("client-id")) {
+      params.set("client-id", clientId);
+    }
+    return `https://embed.figma.com/${embedType}/${fileKey}${pathSuffix}?${params.toString()}`;
+  }
+  return `https://www.figma.com/embed?embed-host=flamingo&url=${encodeURIComponent(url)}`;
+}
+function isFigmaSlidesUrl(url) {
+  if (!url) return false;
+  return /(?:www\.|embed\.)?figma\.com\/(?:slides|deck)\/[a-zA-Z0-9]+/.test(url);
+}
+function toFigmaOriginalUrl(url) {
+  if (url.includes("embed.figma.com")) {
+    return url.replace("embed.figma.com", "www.figma.com").replace(/\?.*$/, "");
+  }
+  return url.replace(/\?.*$/, "");
+}
+function toClaudeMirrorPath(url, storageViewBaseUrl) {
+  if (!url || !storageViewBaseUrl) return null;
+  try {
+    const u = new URL(url);
+    const host = u.hostname.toLowerCase();
+    const id = host === "claude.ai" && /^\/(?:code\/artifact|public\/artifacts)\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:[/?#]|$)/i.exec(
+      u.pathname
+    )?.[1] || host === "claude.site" && /^\/artifacts\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:[/?#]|$)/i.exec(
+      u.pathname
+    )?.[1] || null;
+    return id ? `${storageViewBaseUrl.replace(/\/$/, "")}/design-briefs/${id.toLowerCase()}.html` : null;
+  } catch {
+    return null;
+  }
+}
+function toClaudeEmbedUrl(url) {
+  if (!url) return null;
+  try {
+    const u = new URL(url);
+    const host = u.hostname.toLowerCase();
+    const publicId = host === "claude.ai" && /^\/public\/artifacts\/([\w-]+)(?:\/embed)?\/?$/.exec(u.pathname)?.[1] || host === "claude.site" && /^\/artifacts\/([\w-]+)(?:\/embed)?\/?$/.exec(u.pathname)?.[1] || null;
+    return publicId ? `https://claude.ai/public/artifacts/${publicId}/embed` : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/markdown-fences.ts
+var FENCE_RE = /^ {0,3}(`{3,}|~{3,})([^\n]*?)\r?$/;
+var BLANK_LINE_RE = /^[ \t\r]*$/;
+function isBlankLine(line) {
+  return BLANK_LINE_RE.test(line);
+}
+function createFenceTracker() {
+  let fenceChar = null;
+  let fenceLength = 0;
+  return {
+    push(line) {
+      const fence = FENCE_RE.exec(line);
+      if (fence) {
+        const run = fence[1];
+        if (fenceChar === null) {
+          fenceChar = run[0];
+          fenceLength = run.length;
+          return "open";
+        }
+        if (run[0] === fenceChar && run.length >= fenceLength && isBlankLine(fence[2])) {
+          fenceChar = null;
+          fenceLength = 0;
+          return "close";
+        }
+        return "inside";
+      }
+      return fenceChar === null ? "text" : "inside";
+    },
+    openChar: () => fenceChar,
+    openLength: () => fenceLength
+  };
+}
+
+// src/utils/markdown-heading-id.ts
+var HEADING_EMOJI_RE = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]/gu;
+function stripHeadingEmojis(text) {
+  return text.replace(HEADING_EMOJI_RE, "").trim();
+}
+function slugifyHeadingBase(text) {
+  return text.trim().toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/^-+|-+$/g, "");
+}
+function slugifyHeadingText(text) {
+  return slugifyHeadingBase(stripHeadingEmojis(text));
+}
+var ATX_HEADING_RE = /^ {0,3}(#{1,6})[ \t]+(.*?)(?:[ \t]+#+)?[ \t]*\r?$/;
+var ATX_EMPTY_RE = /^ {0,3}(#{1,6})[ \t]*#*[ \t]*\r?$/;
+var RAW_HEADING_RE = /<h([1-6])\b[^>]*>([\s\S]*?)(?:<\/h\1>|$)/gi;
+var CONTAINER_PREFIX_RE = /^ {0,3}(?:(?:>[ \t]?)+|(?:[-+*]|\d{1,9}[.)])[ \t]+)+/;
+var SETEXT_UNDERLINE_RE = /^ {0,3}(=+|-+)[ \t]*\r?$/;
+var THEMATIC_BREAK_RE = /^ {0,3}(\*|_){3,}[ \t]*\r?$/;
+var HTML_BLOCK_TAGS = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var HTML_BLOCK_OPENER_RE = new RegExp(
+  `^ {0,3}(?:<(?:script|pre|style|textarea)(?:[\\s>]|$)|<!--|<\\?|<![a-zA-Z]|<!\\[CDATA\\[|</?(?:${HTML_BLOCK_TAGS})(?:[\\s/>]|$)|<[a-zA-Z][a-zA-Z0-9-]*(?:\\s[^>]*)?/?>[ \\t]*\\r?$|</[a-zA-Z][a-zA-Z0-9-]*[ \\t]*>[ \\t]*\\r?$)`,
+  "i"
+);
+function scanHeadings(content, options = {}) {
+  const { skipFrontmatter = true, includeRawHtml = true, skipFences = true } = options;
+  const out = [];
+  const lines = content.split("\n");
+  const fences = skipFences ? createFenceTracker() : null;
+  let start = 0;
+  if (skipFrontmatter && lines[0]?.trim() === "---") {
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === "---" || lines[i].trim() === "...") {
+        start = i + 1;
+        break;
+      }
+    }
+  }
+  let setextRun = null;
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i];
+    if (fences) {
+      const role = fences.push(line);
+      if (role !== "text") {
+        setextRun = null;
+        continue;
+      }
+    }
+    const prefix = CONTAINER_PREFIX_RE.exec(line)?.[0] ?? "";
+    const body = prefix ? line.slice(prefix.length) : line;
+    const setext = SETEXT_UNDERLINE_RE.exec(body);
+    if (setext) {
+      if (setextRun && !setextRun.disqualified && setextRun.prefix === prefix) {
+        out.push({
+          line: setextRun.line,
+          level: setext[1][0] === "=" ? 1 : 2,
+          text: setextRun.lines.join("\n")
+        });
+      }
+      setextRun = null;
+      continue;
+    }
+    const atx = ATX_HEADING_RE.exec(body) ?? ATX_EMPTY_RE.exec(body);
+    if (atx) {
+      out.push({ line: i + 1, level: atx[1].length, text: (atx[2] ?? "").trim() });
+      setextRun = null;
+      continue;
+    }
+    if (includeRawHtml && line.indexOf("<") !== -1) {
+      RAW_HEADING_RE.lastIndex = 0;
+      let raw;
+      let matched = false;
+      while ((raw = RAW_HEADING_RE.exec(line)) !== null) {
+        matched = true;
+        out.push({
+          line: i + 1,
+          level: Number(raw[1]),
+          text: raw[2].replace(/<[^>]*>/g, "").trim()
+        });
+      }
+      if (matched) {
+        setextRun = null;
+        continue;
+      }
+    }
+    if (isBlankLine(body) || THEMATIC_BREAK_RE.test(body)) {
+      setextRun = null;
+      continue;
+    }
+    if (setextRun && setextRun.prefix === prefix) {
+      setextRun.lines.push(body.trim());
+    } else {
+      setextRun = {
+        line: i + 1,
+        prefix,
+        lines: [body.trim()],
+        disqualified: HTML_BLOCK_OPENER_RE.test(body)
+      };
+    }
+  }
+  return out;
+}
+function createHeadingIdDeduper() {
+  const counts = {};
+  return (cleanId) => {
+    if (counts[cleanId]) {
+      counts[cleanId]++;
+      return `${cleanId}-${counts[cleanId]}`;
+    }
+    counts[cleanId] = 1;
+    return cleanId;
+  };
+}
+
+// src/utils/anchor-id.ts
+function normalizeAnchorId(raw) {
+  return slugifyHeadingText(raw).replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+var HEADING_SELECTOR = "h1[id], h2[id], h3[id], h4[id], h5[id], h6[id]";
+var DUPLICATE_SUFFIX_RE = /^(.+)-(\d+)$/;
+function findDuplicateShifted(normalized, doc) {
+  const parts = DUPLICATE_SUFFIX_RE.exec(normalized);
+  if (!parts) return null;
+  const ordinal = Number(parts[2]);
+  if (!Number.isSafeInteger(ordinal)) return null;
+  return doc.getElementById(`${parts[1]}-${ordinal + 1}`);
+}
+function findAnchorElementByNormalizedId(rawId, doc) {
+  const normalized = normalizeAnchorId(rawId);
+  if (!normalized) return null;
+  if (normalized !== rawId) {
+    const direct = doc.getElementById(normalized);
+    if (direct) return direct;
+  }
+  for (const heading of Array.from(doc.querySelectorAll(HEADING_SELECTOR))) {
+    if (normalizeAnchorId(heading.id) === normalized) return heading;
+  }
+  return findDuplicateShifted(normalized, doc);
+}
+
+// src/utils/scroll-into-view.ts
+var activeRaf = 0;
+var teardownActive = null;
+function cancelActiveScroll() {
+  if (activeRaf) {
+    cancelAnimationFrame(activeRaf);
+    activeRaf = 0;
+  }
+  if (teardownActive) {
+    teardownActive();
+    teardownActive = null;
+  }
+}
+var easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+function getScrollableAncestor(el) {
+  for (let node = el.parentElement; node; node = node.parentElement) {
+    const overflowY = getComputedStyle(node).overflowY;
+    if ((overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay") && node.scrollHeight > node.clientHeight) {
+      return node;
+    }
+  }
+  return null;
+}
+function declaredScrollMarginTop(target) {
+  const margin = Number.parseFloat(getComputedStyle(target).scrollMarginTop);
+  return Number.isFinite(margin) ? margin : 0;
+}
+function scrollElementIntoView(target, options = {}) {
+  if (typeof window === "undefined" || !target) return;
+  const { headerOffset = 0, behavior = "smooth", adjustTargetY, durationMs = 320 } = options;
+  const container = getScrollableAncestor(target);
+  const readCurrent = () => container ? container.scrollTop : window.scrollY;
+  const writeTo = (y) => {
+    if (container) container.scrollTop = y;
+    else window.scrollTo(0, y);
+  };
+  const computeTarget = () => {
+    const offset = Math.max(headerOffset, declaredScrollMarginTop(target));
+    const raw = container ? container.scrollTop + (target.getBoundingClientRect().top - container.getBoundingClientRect().top) - offset : target.getBoundingClientRect().top + window.scrollY - offset;
+    const adjusted = adjustTargetY ? adjustTargetY(raw) : raw;
+    const maxScroll = container ? Math.max(0, container.scrollHeight - container.clientHeight) : Math.max(0, document.documentElement.scrollHeight - window.innerHeight);
+    return Math.min(Math.max(0, adjusted), maxScroll);
+  };
+  cancelActiveScroll();
+  const prefersReduced = typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  if (behavior === "instant" || behavior === "auto" || prefersReduced) {
+    writeTo(computeTarget());
+    return;
+  }
+  let startY = null;
+  let startTime = 0;
+  const onUserGesture = () => cancelActiveScroll();
+  window.addEventListener("wheel", onUserGesture, { passive: true });
+  window.addEventListener("touchmove", onUserGesture, { passive: true });
+  teardownActive = () => {
+    window.removeEventListener("wheel", onUserGesture);
+    window.removeEventListener("touchmove", onUserGesture);
+  };
+  const step = (now) => {
+    if (startY === null) {
+      startY = readCurrent();
+      startTime = now;
+    }
+    const targetY = computeTarget();
+    const t = Math.min(1, (now - startTime) / durationMs);
+    const y = startY + (targetY - startY) * easeOutCubic(t);
+    writeTo(y);
+    if (t < 1) {
+      activeRaf = requestAnimationFrame(step);
+    } else {
+      writeTo(computeTarget());
+      activeRaf = 0;
+      if (teardownActive) {
+        teardownActive();
+        teardownActive = null;
+      }
+    }
+  };
+  activeRaf = requestAnimationFrame(step);
+}
+
+// src/utils/same-page-hash-nav.ts
+var STICKY_HEADER_OFFSET_PX = 96;
+var HUB_HEADER_OFFSET_PX = 80;
+function normalizeHashFragment(hash) {
+  if (!hash) return "";
+  const second = hash.indexOf("#", 1);
+  return second < 0 ? hash : hash.slice(0, second);
+}
+function getHashTargetElement(id) {
+  if (!id) return null;
+  const direct = document.getElementById(id);
+  if (direct) return direct;
+  let decoded = id;
+  try {
+    decoded = decodeURIComponent(id);
+    if (decoded !== id) {
+      const decodedEl = document.getElementById(decoded);
+      if (decodedEl) return decodedEl;
+    }
+  } catch {
+    decoded = id;
+  }
+  return findAnchorElementByNormalizedId(decoded, document);
+}
+var LOCATION_HASH_SYNC_EVENT = "locationhashsync";
+var ACTIVE_ANCHOR_ATTRIBUTE = "data-active-anchor";
+var HASH_SYNC_STATE_KEY = "__hashSync";
+var isRecord = (value) => typeof value === "object" && value !== null;
+function replaceLocationHash(id) {
+  if (typeof window === "undefined") return;
+  const { pathname, search, hash } = window.location;
+  const next = id ? `#${id}` : "";
+  const state = window.history.state;
+  const noted = isRecord(state) ? state[HASH_SYNC_STATE_KEY] : void 0;
+  if (hash === next && (noted === next || !next)) return;
+  window.history.replaceState(
+    { ...isRecord(state) ? state : {}, [HASH_SYNC_STATE_KEY]: next },
+    "",
+    `${pathname}${search}${next}`
+  );
+  if (hash !== next) window.dispatchEvent(new Event(LOCATION_HASH_SYNC_EVENT));
+}
+function isScrollSyncedHash() {
+  if (typeof window === "undefined" || !window.location.hash) return false;
+  const state = window.history.state;
+  return isRecord(state) && state[HASH_SYNC_STATE_KEY] === window.location.hash;
+}
+function navigateSamePageHash(target, options = {}) {
+  if (typeof window === "undefined") return false;
+  const { headerOffset = 0, history: historyMode = "push" } = options;
+  const normalizedTarget = target.startsWith("#") ? window.location.pathname + window.location.search + target : target;
+  let url;
+  try {
+    url = new URL(normalizedTarget, window.location.href);
+  } catch {
+    return false;
+  }
+  if (url.origin !== window.location.origin || url.pathname !== window.location.pathname || url.search !== window.location.search) {
+    return false;
+  }
+  const current = window.location.pathname + window.location.search + window.location.hash;
+  const normalizedHash = normalizeHashFragment(url.hash);
+  if (process.env.NODE_ENV === "development" && normalizedHash !== url.hash) {
+    console.warn(
+      `[navigateSamePageHash] malformed fragment "${url.hash}" \u2192 normalizing to "${normalizedHash}". Fix the upstream composer.`
+    );
+  }
+  const next = url.pathname + url.search + normalizedHash;
+  const id = normalizedHash && normalizedHash !== "#" ? normalizedHash.slice(1) : "";
+  if (!id && next !== current) return false;
+  if (next !== current) {
+    const oldURL = window.location.href;
+    if (historyMode === "replace") {
+      window.history.replaceState(null, "", next);
+    } else {
+      window.history.pushState(null, "", next);
+    }
+    window.dispatchEvent(
+      new HashChangeEvent("hashchange", {
+        oldURL,
+        newURL: window.location.href
+      })
+    );
+  }
+  const el = id ? getHashTargetElement(id) : null;
+  if (id && !el && process.env.NODE_ENV === "development") {
+    console.warn(`[navigateSamePageHash] anchor "#${id}" not found \u2014 scrolling to top.`);
+  }
+  scrollElementIntoView(el ?? document.documentElement, {
+    behavior: "smooth",
+    headerOffset
+  });
+  return true;
+}
+
+// src/utils/humanity-signals.ts
+var HONEYPOT_FIELD = "form_extra_note";
+var ELAPSED_MS_FIELD = "form_elapsed_ms";
+var DEFAULT_MIN_FILL_MS = 700;
+var HUMANITY_SIGNAL_KEYS = [HONEYPOT_FIELD, ELAPSED_MS_FIELD];
+var isHumanitySignalKey = (key) => HUMANITY_SIGNAL_KEYS.includes(key);
+function extractHumanitySignals(body) {
+  const b = body ?? {};
+  const rawHp = b[HONEYPOT_FIELD];
+  const honeypot = rawHp == null ? "" : typeof rawHp === "string" ? rawHp : JSON.stringify(rawHp) ?? String(rawHp);
+  const rawMs = b[ELAPSED_MS_FIELD];
+  const elapsedMs = typeof rawMs === "number" && Number.isFinite(rawMs) ? rawMs : null;
+  return { honeypot, elapsedMs };
+}
+var normalizeForCopyMatch = (s) => s.normalize("NFKC").trim().toLowerCase();
+var digitsOf = (s) => s.replace(/\D/g, "");
+var MIN_COPY_MATCH_LENGTH = 2;
+var MIN_PHONE_DIGITS = 7;
+var phoneDigitsMatch = (a, b) => a.length >= MIN_PHONE_DIGITS && b.length >= MIN_PHONE_DIGITS && (a.endsWith(b) || b.endsWith(a));
+function findHoneypotCopySource(body, honeypot) {
+  const hpNorm = normalizeForCopyMatch(honeypot);
+  const hpDigits = digitsOf(honeypot);
+  const phoneCandidate = hpDigits.length >= MIN_PHONE_DIGITS;
+  if (hpNorm.length < MIN_COPY_MATCH_LENGTH && !phoneCandidate) return null;
+  const matches = (value) => {
+    if (typeof value !== "string" || value.trim() === "") return false;
+    if (normalizeForCopyMatch(value) === hpNorm) return true;
+    return phoneCandidate && phoneDigitsMatch(digitsOf(value), hpDigits);
+  };
+  const matchInArray = (value) => Array.isArray(value) && value.some(matches);
+  const b = body ?? {};
+  for (const [key, value] of Object.entries(b)) {
+    if (isHumanitySignalKey(key)) continue;
+    if (matches(value)) return key;
+    if (matchInArray(value)) return `${key}[]`;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      for (const [nestedKey, nested] of Object.entries(value)) {
+        if (matches(nested)) return `${key}.${nestedKey}`;
+        if (matchInArray(nested)) return `${key}.${nestedKey}[]`;
+      }
+    }
+  }
+  return null;
+}
+function evaluateHumanitySignals(body, opts) {
+  const { honeypot, elapsedMs } = extractHumanitySignals(body);
+  const diagnostics = {
+    honeypotLength: honeypot.length,
+    timingAffirmed: elapsedMs !== null && elapsedMs >= opts.minFillMs
+  };
+  const filled = honeypot.trim() !== "";
+  const sourceField = filled ? findHoneypotCopySource(body, honeypot) : null;
+  if (filled && sourceField === null) return { ...diagnostics, ok: false, reason: "honeypot" };
+  if (elapsedMs !== null && elapsedMs < opts.minFillMs) return { ...diagnostics, ok: false, reason: "too_fast" };
+  return sourceField !== null ? { ...diagnostics, ok: true, note: "honeypot_autofill", sourceField } : { ...diagnostics, ok: true };
+}
+var splitCsvEnv = (s) => s?.split(",").map((t) => t.trim()).filter(Boolean) ?? [];
+
+// src/utils/form-rescue.ts
+var FORM_ID_PATTERN = /^[a-z][a-z0-9_]{1,47}$/;
+var definitions = /* @__PURE__ */ new Map();
+function defineRescueForm(definition) {
+  if (!FORM_ID_PATTERN.test(definition.id)) throw new Error(`[form-rescue] invalid form id "${definition.id}"`);
+  const existing = definitions.get(definition.id);
+  if (existing) {
+    if (existing.label !== definition.label) {
+      throw new Error(`[form-rescue] form id "${definition.id}" is already defined as "${existing.label}"`);
+    }
+    return existing;
+  }
+  const frozen = Object.freeze({ id: definition.id, label: definition.label });
+  definitions.set(frozen.id, frozen);
+  return frozen;
+}
+function getRescueForm(id) {
+  return typeof id === "string" ? definitions.get(id) ?? null : null;
+}
+function listRescueForms() {
+  return [...definitions.values()];
+}
+var RESCUE_FORMS = {
+  contact: defineRescueForm({ id: "contact", label: "Contact form" }),
+  caseStudyPitch: defineRescueForm({ id: "case_study_pitch", label: "Case study pitch" }),
+  dataRoomRequest: defineRescueForm({ id: "data_room_request", label: "Data room request" }),
+  trustCenterRequest: defineRescueForm({ id: "trust_center_request", label: "Trust Center document request" }),
+  meetingBooking: defineRescueForm({ id: "meeting_booking", label: "Meeting booking" }),
+  waitlist: defineRescueForm({ id: "waitlist", label: "Waitlist" })
+};
+var FORM_RESCUE_VALUE_FIELDS = [
+  "email",
+  "name",
+  "firstName",
+  "lastName",
+  "company",
+  "jobtitle",
+  "companySize",
+  "linkedin_url"
+];
+var EXCLUDED_FIELD_PATTERN = /pass(word|code)?|card|cvv|cvc|ssn|social.?security|iban|bank|routing|token|secret|otp|pin$/i;
+function isExcludedRescueField(name) {
+  return EXCLUDED_FIELD_PATTERN.test(name);
+}
+var FORM_RESCUE_MAX_VALUE_CHARS = 200;
+var FORM_RESCUE_DEBOUNCE_MS = 1500;
+var FORM_RESCUE_MAX_FIELDS = 40;
+var FORM_RESCUE_ATTEMPT_FIELD = "form_attempt_id";
+var FORM_RESCUE_RESUME_FIELD = "form_resume_token";
+var FORM_RESCUE_SUBMIT_KEYS = [FORM_RESCUE_ATTEMPT_FIELD, FORM_RESCUE_RESUME_FIELD];
+var FORM_RESCUE_RESUME_PARAM = "resume";
+var RESUME_TOKEN_PATTERN = /^[A-Za-z0-9_-]{16,128}$/;
+function isResumeToken(value) {
+  return typeof value === "string" && RESUME_TOKEN_PATTERN.test(value);
+}
+var FORM_DRAFT_STATUSES = ["started", "rescuable", "rescued", "submitted"];
+var FORM_RESCUE_SKIP_REASONS = {
+  finishedElsewhere: "finished_elsewhere",
+  alreadyRescued: "already_rescued",
+  internal: "internal_email"
+};
+var EMAIL_PATTERN = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
+function isRescueEmail(value) {
+  return typeof value === "string" && value.length <= FORM_RESCUE_MAX_VALUE_CHARS && EMAIL_PATTERN.test(value.trim());
+}
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isFormAttemptId(value) {
+  return typeof value === "string" && UUID_PATTERN.test(value);
+}
+function isFilled(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.values(value).some(isFilled);
+  return true;
+}
+function sanitizeRescueValues(values) {
+  const out = {};
+  if (!values || typeof values !== "object") return out;
+  for (const key of FORM_RESCUE_VALUE_FIELDS) {
+    if (isExcludedRescueField(key)) continue;
+    const raw = values[key];
+    if (typeof raw !== "string") continue;
+    const trimmed = raw.trim().slice(0, FORM_RESCUE_MAX_VALUE_CHARS);
+    if (trimmed) out[key] = trimmed;
+  }
+  return out;
+}
+function filledRescueFields(values, fieldNames) {
+  return fieldNames.filter((name) => !isExcludedRescueField(name) && isFilled(values[name])).slice(0, FORM_RESCUE_MAX_FIELDS);
+}
+function rescueCompletionPct(filledCount, totalCount) {
+  if (totalCount <= 0) return 0;
+  return Math.max(0, Math.min(100, Math.round(filledCount / totalCount * 100)));
+}
+function sanitizeRescueFieldName(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return /^[A-Za-z0-9_.-]{1,64}$/.test(trimmed) && !isExcludedRescueField(trimmed) ? trimmed : null;
+}
+var UTM_KEYS = ["source", "medium", "campaign", "content", "term"];
+var MAX_SOURCE_PATH_CHARS = 500;
+function parseFormDraftSaveRequest(body) {
+  const form = getRescueForm(body.form_id);
+  if (!isFormAttemptId(body.attempt_id) || !form) return null;
+  const rawValues = body.values && typeof body.values === "object" ? body.values : {};
+  const values = sanitizeRescueValues(rawValues);
+  const fieldsFilled = (Array.isArray(body.fields_filled) ? body.fields_filled : []).map(sanitizeRescueFieldName).filter((name) => name !== null).slice(0, FORM_RESCUE_MAX_FIELDS);
+  const path = typeof body.source_path === "string" ? body.source_path : "";
+  const utmIn = body.utm && typeof body.utm === "object" ? body.utm : {};
+  const utm = {};
+  for (const key of UTM_KEYS) {
+    const value = utmIn[key];
+    if (typeof value === "string" && value.trim()) utm[key] = value.trim().slice(0, FORM_RESCUE_MAX_VALUE_CHARS);
+  }
+  return {
+    request: {
+      attempt_id: body.attempt_id,
+      form_id: form.id,
+      values,
+      fields_filled: fieldsFilled,
+      last_field: sanitizeRescueFieldName(body.last_field),
+      completion_pct: typeof body.completion_pct === "number" ? rescueCompletionPct(body.completion_pct, 100) : 0,
+      // Same-site only: a path, never a scheme-relative or absolute URL.
+      source_path: path.startsWith("/") && !path.startsWith("//") ? path.slice(0, MAX_SOURCE_PATH_CHARS) : "",
+      ...Object.keys(utm).length ? { utm } : {},
+      ...isResumeToken(body.resume_token) ? { resume_token: body.resume_token } : {}
+    },
+    dropped: Object.keys(rawValues).filter((key) => !(key in values))
+  };
+}
+var FORM_RESCUE_EVENTS = {
+  started: "form_started",
+  progress: "form_progress",
+  leadCaptured: "form_lead_captured",
+  abandoned: "form_abandoned",
+  submitted: "form_submitted",
+  rescued: "form_rescued",
+  resumed: "form_resumed"
+};
+function captureFormRescueEvent(event, properties) {
+  try {
+    if (typeof window === "undefined") return;
+    const ph = window.posthog;
+    if (typeof ph?.capture === "function") ph.capture(event, properties);
+  } catch {
+  }
+}
+
+export {
+  useDebounce,
+  useHeaderHeight,
+  useMarqueeEngine,
+  useResetOnPageHidden,
+  useSuppressCloneFocus,
+  PREFERS_REDUCED_MOTION_QUERY,
+  usePrefersReducedMotion,
+  usePrefersReducedMotionState,
+  useInView,
+  useAutoplay,
+  DESKTOP_OSES,
+  detectVisitorOs,
+  desktopOsOf,
+  detectDesktopOs,
+  usesCommandKey,
+  shortcutLabel,
+  useVisitorOs,
+  platformIcons,
+  transformPlatformConfigsToOptions,
+  getPlatformIcon,
+  getSmallPlatformIcon,
+  getPlatformIconComponent,
+  validateAccessCode,
+  consumeAccessCode,
+  validateAndConsumeAccessCode,
+  toGoogleSheetsEmbedUrl,
+  toGoogleSheetsOriginalUrl,
+  toFigmaEmbedUrl,
+  isFigmaSlidesUrl,
+  toFigmaOriginalUrl,
+  toClaudeMirrorPath,
+  toClaudeEmbedUrl,
+  isBlankLine,
+  createFenceTracker,
+  HEADING_EMOJI_RE,
+  stripHeadingEmojis,
+  slugifyHeadingBase,
+  slugifyHeadingText,
+  scanHeadings,
+  createHeadingIdDeduper,
+  normalizeAnchorId,
+  findAnchorElementByNormalizedId,
+  getScrollableAncestor,
+  declaredScrollMarginTop,
+  scrollElementIntoView,
+  STICKY_HEADER_OFFSET_PX,
+  HUB_HEADER_OFFSET_PX,
+  normalizeHashFragment,
+  getHashTargetElement,
+  LOCATION_HASH_SYNC_EVENT,
+  ACTIVE_ANCHOR_ATTRIBUTE,
+  replaceLocationHash,
+  isScrollSyncedHash,
+  navigateSamePageHash,
+  HONEYPOT_FIELD,
+  ELAPSED_MS_FIELD,
+  DEFAULT_MIN_FILL_MS,
+  HUMANITY_SIGNAL_KEYS,
+  isHumanitySignalKey,
+  extractHumanitySignals,
+  findHoneypotCopySource,
+  evaluateHumanitySignals,
+  splitCsvEnv,
+  defineRescueForm,
+  getRescueForm,
+  listRescueForms,
+  RESCUE_FORMS,
+  FORM_RESCUE_VALUE_FIELDS,
+  isExcludedRescueField,
+  FORM_RESCUE_MAX_VALUE_CHARS,
+  FORM_RESCUE_DEBOUNCE_MS,
+  FORM_RESCUE_MAX_FIELDS,
+  FORM_RESCUE_ATTEMPT_FIELD,
+  FORM_RESCUE_RESUME_FIELD,
+  FORM_RESCUE_SUBMIT_KEYS,
+  FORM_RESCUE_RESUME_PARAM,
+  isResumeToken,
+  FORM_DRAFT_STATUSES,
+  FORM_RESCUE_SKIP_REASONS,
+  isRescueEmail,
+  isFormAttemptId,
+  sanitizeRescueValues,
+  filledRescueFields,
+  rescueCompletionPct,
+  sanitizeRescueFieldName,
+  parseFormDraftSaveRequest,
+  FORM_RESCUE_EVENTS,
+  captureFormRescueEvent
+};