@flamingo-stack/openframe-frontend-core 0.0.285 → 0.0.286

package/dist/chunk-RGALV4UX.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/hooks/ui/use-auto-limit-tags.ts","../src/hooks/ui/use-debounce.ts","../src/utils/local-storage-adapter.ts","../src/utils/app-config.ts","../src/utils/embed-proxy-auth-storage.ts","../src/utils/embed-authed-fetch.ts","../src/hooks/use-near-viewport.ts","../src/hooks/use-og-placeholder.ts","../src/utils/embed-content-fetch.ts"],"sourcesContent":["\"use client\"\n\nimport { useCallback, useEffect, useRef, useState } from \"react\"\n\nexport interface UseAutoLimitTagsOptions {\n  /** Total number of tags */\n  count: number\n  /** Fixed limit or \"auto\" for DOM-based measurement. Default \"auto\" */\n  limitTags?: number | \"auto\"\n  /** Placeholder text used to reserve input width (only used in \"auto\" mode) */\n  placeholder?: string\n  /**\n   * Reserve trailing space for a text input (the autocomplete combobox). Set\n   * `false` for a pure chip row that has no input — then only the chips and the\n   * \"+N\" / \"⋯\" overflow badge compete for the available width. Default `true`.\n   */\n  reserveInputWidth?: boolean\n}\n\nexport interface UseAutoLimitTagsReturn {\n  /** How many tags to show */\n  visibleCount: number\n  /** Ref for the zone that contains tags + input (must have overflow-hidden, gap, padding) */\n  middleRef: React.RefObject<HTMLDivElement | null>\n  /** Ref for the off-screen container that holds measurement copies of ALL tags */\n  measureRef: React.RefObject<HTMLDivElement | null>\n  /** Ref for the hidden span that measures placeholder text width */\n  textMeasureRef: React.RefObject<HTMLSpanElement | null>\n  /** Ref for the \"+N\" badge element (used to measure its width) */\n  badgeRef: React.RefObject<HTMLButtonElement | null>\n  /** Ref for the input element (used to read its min-width) */\n  inputRef: React.RefObject<HTMLInputElement | null>\n}\n\n/**\n * Calculates how many tags fit in a single-line container.\n *\n * Requires three off-screen measurement elements rendered by the consumer:\n * 1. A `<div ref={measureRef}>` containing Tag copies for every item (to measure widths)\n * 2. A `<span ref={textMeasureRef}>` containing the placeholder text (to reserve input width)\n * 3. The `<button ref={badgeRef}>` for the \"+N\" badge (to measure badge width)\n *\n * The hook reads real CSS values (padding, gap) from the middleRef container,\n * so it works regardless of responsive breakpoints or custom styling.\n */\nexport function useAutoLimitTags({\n  count,\n  limitTags = \"auto\",\n  placeholder = \"\",\n  reserveInputWidth = true,\n}: UseAutoLimitTagsOptions): UseAutoLimitTagsReturn {\n  const middleRef = useRef<HTMLDivElement>(null)\n  const measureRef = useRef<HTMLDivElement>(null)\n  const textMeasureRef = useRef<HTMLSpanElement>(null)\n  const badgeRef = useRef<HTMLButtonElement>(null)\n  const inputRef = useRef<HTMLInputElement>(null)\n  const [visibleCount, setVisibleCount] = useState(count)\n\n  const recalculate = useCallback(() => {\n    // Fixed limit — skip DOM measurement\n    if (limitTags !== \"auto\") {\n      setVisibleCount(Math.min(limitTags, count))\n      return\n    }\n\n    const middle = middleRef.current\n    const measure = measureRef.current\n    if (!middle || !measure) {\n      setVisibleCount(count)\n      return\n    }\n    if (count === 0) {\n      setVisibleCount(0)\n      return\n    }\n\n    // Read real CSS metrics from the middle zone\n    const cs = getComputedStyle(middle)\n    const padL = parseFloat(cs.paddingLeft) || 0\n    const padR = parseFloat(cs.paddingRight) || 0\n    const gap = parseFloat(cs.gap) || 0\n    const middleW = middle.clientWidth\n\n    // Reserve trailing space for the input (autocomplete only). A pure chip row\n    // (`reserveInputWidth: false`) has no input, so nothing — and no gap before\n    // it — is reserved.\n    let inputReservedW = 0\n    let trailingGap = 0\n    if (reserveInputWidth) {\n      const textW = textMeasureRef.current?.offsetWidth ?? 60\n      const inputMinW = inputRef.current\n        ? parseFloat(getComputedStyle(inputRef.current).minWidth) || 60\n        : 60\n      inputReservedW = Math.max(textW + 8, inputMinW)\n      trailingGap = gap\n    }\n\n    // Available = middle zone − padding − input reserved − gap before input\n    const available = middleW - padL - padR - inputReservedW - trailingGap\n\n    // Measure every tag from the off-screen container\n    const tagEls = Array.from(measure.children) as HTMLElement[]\n    const widths = tagEls.map((el) => el.offsetWidth)\n\n    // Fast check: do ALL tags fit?\n    let total = 0\n    for (let i = 0; i < widths.length; i++) {\n      total += widths[i] + (i > 0 ? gap : 0)\n    }\n    if (total <= available) {\n      setVisibleCount(count)\n      return\n    }\n\n    // Not all fit → reserve space for the \"+N\" badge\n    const badgeW = badgeRef.current?.offsetWidth ?? 40\n    const spaceWithBadge = available - badgeW - gap\n\n    let used = 0\n    let fitCount = 0\n    for (let i = 0; i < widths.length; i++) {\n      const need = widths[i] + (i > 0 ? gap : 0)\n      if (used + need > spaceWithBadge) break\n      used += need\n      fitCount++\n    }\n\n    setVisibleCount(Math.max(0, fitCount))\n  }, [count, limitTags, placeholder, reserveInputWidth])\n\n  // Recalculate when inputs change\n  useEffect(() => {\n    recalculate()\n  }, [recalculate])\n\n  // Recalculate on container resize\n  useEffect(() => {\n    const el = middleRef.current\n    if (!el) return\n    const ro = new ResizeObserver(recalculate)\n    ro.observe(el)\n    return () => ro.disconnect()\n  }, [recalculate])\n\n  return { visibleCount, middleRef, measureRef, textMeasureRef, badgeRef, inputRef }\n}\n","\"use client\"\n\nimport { useState, useEffect } from \"react\"\n\n/**\n * Hook to debounce a value\n * @param value - Value to debounce\n * @param delay - Delay in milliseconds\n * @returns Debounced value\n */\nexport function useDebounce<T>(value: T, delay = 500): T {\n  const [debouncedValue, setDebouncedValue] = useState<T>(value)\n\n  useEffect(() => {\n    // Set up timeout to update debounced value\n    const timer = setTimeout(() => {\n      setDebouncedValue(value)\n    }, delay)\n\n    // Clean up timeout on value change or unmount\n    return () => {\n      clearTimeout(timer)\n    }\n  }, [value, delay])\n\n  return debouncedValue\n}\n","/**\n * Thin JSON-typed Web-Storage adapter (localStorage or sessionStorage).\n *\n * Centralizes the SSR-guard + try/catch + silent quota-failure pattern\n * that every per-feature storage util would otherwise re-implement.\n *\n * Optional `namespace` prefix supports platform / user partitioning —\n * the resolver runs lazily at call time so the namespace can vary across\n * the lifetime of the page (e.g. proxy-auth switches user, which switches\n * the key suffix).\n *\n * Backend selection (`backend: 'local' | 'session'`):\n *   - `'local'` (default): persists across browser sessions. Use for\n *     UI state, chat history metadata, feature-flag opt-ins.\n *   - `'session'`: cleared when the tab closes. Use for ANY auth-adjacent\n *     value (bearer tokens, act-as identity, proxy credentials). Reduces\n *     the XSS-exfiltration attack window from \"indefinite\" to \"until tab\n *     close\" without losing per-session ergonomics.\n */\n\nexport type WebStorageBackend = 'local' | 'session'\n\nexport interface LocalStorageAdapter<T> {\n  load(): T | null\n  save(value: T): void\n  clear(): void\n  /** Resolved storage key for the current call. Useful for tests. */\n  resolveKey(): string\n}\n\nexport interface LocalStorageAdapterOptions<T> {\n  /** Base storage key. Combined with `namespace()` when provided. */\n  key: string\n  /** Optional dynamic namespace prefix appended via `.` separator.\n   *  Called on EVERY read/write so the key can vary across the page\n   *  lifetime (e.g. when the platform or user identity changes). */\n  namespace?: () => string | null | undefined\n  /** Runtime shape check. Falsey return → `load()` yields null. */\n  validate?: (parsed: unknown) => parsed is T\n  /** Diagnostic prefix written to `console.warn` on parse / write\n   *  failures. Defaults to `'[local-storage]'`. */\n  logTag?: string\n  /** Which Web-Storage backend to use. Defaults to `'local'`. Pass\n   *  `'session'` for anything auth-adjacent so the value evaporates\n   *  when the tab closes. */\n  backend?: WebStorageBackend\n}\n\nfunction getStorage(backend: WebStorageBackend): Storage | null {\n  if (typeof window === 'undefined') return null\n  try {\n    return backend === 'session' ? window.sessionStorage : window.localStorage\n  } catch {\n    // Some sandboxed contexts (Safari private mode older versions,\n    // strict CSP) throw on storage access — treat as unavailable.\n    return null\n  }\n}\n\nexport function createLocalStorageAdapter<T>(\n  options: LocalStorageAdapterOptions<T>,\n): LocalStorageAdapter<T> {\n  const tag = options.logTag ?? '[local-storage]'\n  const backend: WebStorageBackend = options.backend ?? 'local'\n  const resolveKey = (): string => {\n    const ns = options.namespace?.()\n    return ns ? `${ns}.${options.key}` : options.key\n  }\n\n  return {\n    resolveKey,\n    load() {\n      const storage = getStorage(backend)\n      if (!storage) return null\n      try {\n        const raw = storage.getItem(resolveKey())\n        if (!raw) return null\n        const parsed = JSON.parse(raw) as unknown\n        if (options.validate && !options.validate(parsed)) return null\n        return parsed as T\n      } catch (err) {\n        console.warn(`${tag} parse failed for key ${resolveKey()}:`, err)\n        return null\n      }\n    },\n    save(value: T) {\n      const storage = getStorage(backend)\n      if (!storage) return\n      try {\n        storage.setItem(resolveKey(), JSON.stringify(value))\n      } catch (err) {\n        console.warn(`${tag} write failed for key ${resolveKey()}:`, err)\n      }\n    },\n    clear() {\n      const storage = getStorage(backend)\n      if (!storage) return\n      try {\n        storage.removeItem(resolveKey())\n      } catch (err) {\n        console.warn(`${tag} clear failed for key ${resolveKey()}:`, err)\n      }\n    },\n  }\n}\n","// Stub app config\nexport const APP_CONFIG = {\n  app: {\n    type: 'openmsp',\n    name: 'OpenMSP',\n    domain: 'openmsp.ai'\n  },\n  features: {\n    announcements: true,\n    notifications: true\n  }\n} as const;\n\nexport function getAppConfig() {\n  return APP_CONFIG;\n}\n\nexport function getAppType() {\n  return process.env.NEXT_PUBLIC_APP_TYPE || 'openmsp';\n}","'use client'\n\n/**\n * Client-side persistence for embed-surface proxy credentials\n * (`CHAT_PROXY_SECRET` + impersonation email). Used by every embedded\n * surface — the chat widget AND the ticket center AND any future\n * embedded React component that needs to identify itself as the\n * impersonated customer.\n *\n * When set, the surface attaches the creds as\n *   `Authorization: Bearer <secret>` + `X-Chat-Act-As: <email>`\n * on every call to `/api/docs/chat`, `/api/chat/*`, and any other route\n * gated by `requireChatAuth` — proving to the server that this session\n * is acting on behalf of <email>.\n *\n * **Naming history:** the wire-side header names are still `X-Chat-*`\n * and the env var is `CHAT_PROXY_SECRET`. Those are server contracts;\n * renaming them would require a coordinated deploy + customer-side\n * env-var migration. The CLIENT-side helpers were renamed `Embed*` so\n * non-chat surfaces (e.g. ticket center) don't have to import a\n * chat-prefixed symbol just to send the same headers.\n *\n * Persists to **`localStorage`** so the bearer token + act-as identity\n * survive tab close, new-tab opens, and browser restarts — the\n * `/debug` paste-creds UI is an admin tool and re-pasting every tab\n * cycle was rejected as a dev-experience tradeoff that wasn't worth\n * the security gain. An XSS sink on this origin can read the value\n * indefinitely (vs only-this-tab with sessionStorage), but `/debug`\n * is admin-gated behind the platform's `askAI.enabled` flag and the\n * impersonation header it sets is server-validated against\n * `CHAT_PROXY_SECRET` anyway. Explicit \"Clear\" button on the creds\n * bar is the supported logout path; closing the tab is no longer.\n *\n * Namespaced under `<platform>.chat.proxy-auth.v1` (the storage key is\n * unchanged from the old chat-prefixed helper — that's a storage\n * contract; renaming it would log everyone out).\n */\n\nimport { createLocalStorageAdapter } from './local-storage-adapter'\nimport { getAppType } from './app-config'\n\nexport interface EmbedProxyAuth {\n  secret: string\n  email: string\n  /** Optional identity passthrough — empty/omitted = not sent. Server\n   *  parses these as `X-Chat-{First,Last}-Name` / `X-Chat-Avatar-Url` and\n   *  threads them through `resolveChatProxyIdentity`'s returned user. */\n  firstName?: string\n  lastName?: string\n  avatarUrl?: string\n}\n\nfunction isValidPersistedAuth(value: unknown): value is EmbedProxyAuth {\n  if (!value || typeof value !== 'object') return false\n  const v = value as Record<string, unknown>\n  if (\n    typeof v.secret !== 'string' || v.secret.trim().length === 0 ||\n    typeof v.email !== 'string' || v.email.trim().length === 0\n  ) return false\n  // Optional fields: when present must be strings. Empty string is treated\n  // as absent later (in `getEmbedProxyAuth`).\n  if (v.firstName != null && typeof v.firstName !== 'string') return false\n  if (v.lastName != null && typeof v.lastName !== 'string') return false\n  if (v.avatarUrl != null && typeof v.avatarUrl !== 'string') return false\n  return true\n}\n\nconst adapter = createLocalStorageAdapter<EmbedProxyAuth>({\n  // Storage key unchanged from the legacy chat-prefixed helper. Renaming\n  // it would silently log every existing admin out — the key is a\n  // storage contract, not a code identifier.\n  key: 'chat.proxy-auth.v1',\n  namespace: () => getAppType(),\n  validate: isValidPersistedAuth,\n  logTag: '[embed-proxy-auth-storage]',\n  // localStorage — survives tab close, new tabs, and browser restarts.\n  // Admin re-pasting creds every tab cycle was the dev-experience\n  // tradeoff prior `sessionStorage` setup demanded — rejected. See\n  // file-level doc comment for the security tradeoff rationale.\n  backend: 'local',\n})\n\n/** Trim + null-coerce an optional identity field so consumers can do\n *  `auth.firstName ?? ''` without worrying about whitespace-only strings. */\nfunction normalizeOptional(value: string | undefined): string | undefined {\n  if (!value) return undefined\n  const trimmed = value.trim()\n  return trimmed.length > 0 ? trimmed : undefined\n}\n\n/**\n * Returns full credentials (secret + email + optional identity passthrough)\n * when secret + email are available. Returns `null` when nothing is saved —\n * callers treat that as \"fall back to cookie auth\".\n */\nexport function getEmbedProxyAuth(): EmbedProxyAuth | null {\n  const persisted = adapter.load()\n  if (!persisted) return null\n  return {\n    secret: persisted.secret,\n    email: persisted.email.trim().toLowerCase(),\n    firstName: normalizeOptional(persisted.firstName),\n    lastName: normalizeOptional(persisted.lastName),\n    avatarUrl: normalizeOptional(persisted.avatarUrl),\n  }\n}\n\n/**\n * Returns the LAST email the admin saved. The proxy creds bar reads\n * this to pre-fill the email field on mount.\n */\nexport function getPersistedProxyEmail(): string | null {\n  const persisted = adapter.load()\n  return persisted?.email.trim().toLowerCase() ?? null\n}\n\n/** Save the proxy creds. Secret + email are required; identity-passthrough\n *  fields are persisted only when non-empty. */\nexport function setEmbedProxyAuth(value: EmbedProxyAuth): void {\n  adapter.save({\n    secret: value.secret,\n    email: value.email.trim().toLowerCase(),\n    firstName: normalizeOptional(value.firstName),\n    lastName: normalizeOptional(value.lastName),\n    avatarUrl: normalizeOptional(value.avatarUrl),\n  })\n}\n\n/** Drop the persisted creds. */\nexport function clearEmbedProxyAuth(): void {\n  adapter.clear()\n}\n\n/**\n * Apply the embed-proxy auth (Bearer + X-Chat-Act-As) to a fetch call's\n * URL + headers. Used by every embedded-surface route that needs to\n * identify itself as the proxied customer (chat stream, agent-* routes,\n * ticket-center actions). When proxy auth is absent (regular\n * cookie-session users), returns the inputs unchanged so the cookie-auth\n * path still works.\n *\n * `X-Chat-Act-As` header (vs a URL query param) keeps PII out of access\n * logs, Sentry breadcrumbs, browser history, and CDN analytics.\n */\nexport function applyProxyAuth(\n  url: string,\n  baseHeaders: Record<string, string> = { 'Content-Type': 'application/json' },\n): { url: string; headers: Record<string, string> } {\n  const auth = getEmbedProxyAuth()\n  const headers = { ...baseHeaders }\n  if (auth?.secret) {\n    headers.Authorization = `Bearer ${auth.secret}`\n  }\n  if (auth?.email) {\n    headers['X-Chat-Act-As'] = auth.email\n  }\n  // Optional identity passthrough — only attached when present so the\n  // server's \"required vs optional\" header shape stays exact.\n  if (auth?.firstName) headers['X-Chat-First-Name'] = auth.firstName\n  if (auth?.lastName) headers['X-Chat-Last-Name'] = auth.lastName\n  if (auth?.avatarUrl) headers['X-Chat-Avatar-Url'] = auth.avatarUrl\n  return { url, headers }\n}\n","'use client'\n\n/**\n * Shared `fetch` wrapper for any embedded surface (chat, ticket center,\n * future widgets) that needs to carry the bearer-act-as identity\n * (proxy `Authorization` + `X-Chat-Act-As` headers from\n * `embed-proxy-auth-storage.ts`).\n *\n * Wire header names are `X-Chat-*` for historical reasons — that's a\n * server contract, not a UI namespace. The wrapper itself is generic.\n *\n * Drop-in replacement for `fetch()` — `Authorization` / `X-Chat-Act-As`\n * are merged into `init.headers` when proxy creds are stashed in\n * sessionStorage, otherwise the call falls through to the cookie-auth\n * path unchanged.\n *\n * Use this for any client-side fetch hitting `/api/chat/*`, `/api/docs/chat/*`,\n * or `/api/storage/generate-upload-url` (chat-attachment surface — shared\n * with the ticket center). Routes that do NOT need bearer-act-as\n * (e.g. `/api/profile/me`) keep using vanilla `fetch`.\n */\n\nimport { applyProxyAuth } from './embed-proxy-auth-storage'\n\n// =============================================================================\n// Host-supplied auth adapter (opt-in)\n// =============================================================================\n\n/**\n * Hosts that have their own auth model (cookie sessions, app-specific\n * JWT in localStorage, OAuth access tokens, …) can register an adapter\n * to override the lib's default `embedProxyAuth` flow. When set, the\n * adapter's `getHeaders()` result is merged onto every `embedAuthedFetch`\n * call AFTER the default proxy-auth header step (so adapter headers\n * win over both caller and proxy values), and `credentials` overrides\n * the default `'same-origin'` behaviour.\n *\n * Default (no adapter): MPH-style proxy-impersonation — bearer + act-as\n * read from localStorage, `credentials: 'same-origin'`. No consumer\n * needs to touch this unless they want a different auth model.\n *\n * Use cases:\n *   - openframe-frontend has its own JWT in `localStorage.of_access_token`\n *     and cookie-based session; register an adapter to attach the JWT\n *     and request `credentials: 'include'` so cookies travel cross-origin\n *     to the openframe gateway.\n *   - Future embed hosts with OAuth access tokens, signed URLs, etc.\n *\n * Lifetime: setter is module-level (intentionally — `embedAuthedFetch`\n * is a plain utility, not a hook, so it can't read React context). Host\n * runtime providers should call `setEmbedAuthAdapter(...)` on mount and\n * `setEmbedAuthAdapter(null)` on unmount. Multiple hosts registering at\n * once is a programming error (one chat panel per app).\n */\nexport interface EmbedAuthAdapter {\n  /** Headers merged onto every embedded-fetch call. Return `{}` to add\n   *  nothing. Called per-request so reactive token refresh sees the latest\n   *  value from your auth store / storage. Values typed as\n   *  `string | undefined` so the common narrowed shape\n   *  `{ Authorization: token ? 'Bearer …' : undefined }` (or a conditional\n   *  `token ? { Authorization: … } : {}`) assigns cleanly — `undefined`\n   *  values are filtered before being merged into the request headers. */\n  getHeaders?: () => Record<string, string | undefined>\n  /** `RequestInit.credentials` mode. Default when no adapter: callers'\n   *  `init.credentials` or `'same-origin'`. Use `'include'` for cookie\n   *  auth against a different origin (CORS + `SameSite=None` required). */\n  credentials?: RequestCredentials\n  /**\n   * Optional 401 self-heal. When a request comes back `401`,\n   * `embedAuthedFetch` calls this once, and — if it resolves `true` —\n   * retries the SAME request exactly once with freshly-recomputed\n   * headers (so a rotated bearer from `getHeaders()` is picked up).\n   * Resolve `false` to surface the 401 to the caller unchanged.\n   *\n   * This is the capability the openframe `apiClient` has had all along\n   * (refresh-the-access-token-then-retry); registering it here gives the\n   * embedded chat/ticket surfaces the same self-healing auth instead of\n   * dying on an expired token. Concurrent 401s are de-duplicated by the\n   * wrapper, so this fires at most once per refresh cycle even when a\n   * stampede of chat requests all expire together — your implementation\n   * does NOT need its own in-flight guard (though a token-refresh manager\n   * that already dedups is harmless).\n   *\n   * Keep it idempotent and side-effect-light: on failure the wrapper just\n   * returns the original 401 — logout/redirect decisions belong to the\n   * host's own auth layer, not to this fetch wrapper.\n   */\n  refresh?: () => Promise<boolean>\n}\n\n/**\n * The registered adapter is parked on `globalThis`, NOT in a module-private\n * `let`. Reason: this lib ships multiple entry points (`/utils`,\n * `/components/chat`, …) and a consumer's bundler can inline this file into\n * more than one chunk — giving each chunk its OWN module scope. If the host\n * calls `setEmbedAuthAdapter` from the `/utils` copy while the chat's\n * `embedAuthedFetch` runs from the `/components/chat` copy, a module-local\n * `let` would be set on one copy and read as `null` on the other (the exact\n * \"credentials: same-origin, no Bearer, no refresh\" symptom). A single\n * `globalThis` slot is shared across every copy, so registration always\n * reaches the fetch path.\n */\nconst ADAPTER_GLOBAL_KEY = '__embedAuthedFetchAdapter__'\n\nfunction getRegisteredAuthAdapter(): EmbedAuthAdapter | null {\n  if (typeof globalThis === 'undefined') return null\n  return (globalThis as Record<string, unknown>)[ADAPTER_GLOBAL_KEY] as EmbedAuthAdapter | null ?? null\n}\n\nfunction storeRegisteredAuthAdapter(adapter: EmbedAuthAdapter | null): void {\n  if (typeof globalThis === 'undefined') return\n  ;(globalThis as Record<string, unknown>)[ADAPTER_GLOBAL_KEY] = adapter\n}\n\n/**\n * Register a host-owned auth adapter for `embedAuthedFetch`. Pass `null`\n * to clear (typically on provider unmount).\n *\n * Module-level state — there is one chat panel per app, so a single\n * registration is sufficient. Calling this twice with different non-null\n * adapters replaces the previous one (the most recent registration wins);\n * a `console.warn` flags the overwrite so duplicate-provider mounts get\n * caught in dev.\n */\nexport function setEmbedAuthAdapter(adapter: EmbedAuthAdapter | null): void {\n  if (adapter && getRegisteredAuthAdapter() && process.env.NODE_ENV !== 'production') {\n    console.warn(\n      '[setEmbedAuthAdapter] overwriting a previously-registered auth ' +\n        'adapter. Two chat-runtime providers should not coexist — verify ' +\n        'mount order and pass `null` from the unmounting provider.',\n    )\n  }\n  storeRegisteredAuthAdapter(adapter)\n}\n\n/**\n * Whether a host auth adapter is currently registered. Lets sibling helpers\n * (e.g. `contentFetch`) route through `embedAuthedFetch` ONLY when a host has\n * opted into embedded auth, and stay a plain `fetch` otherwise — so there's a\n * single auth knob (the adapter), not a second content-fetch registration.\n */\nexport function hasEmbedAuthAdapter(): boolean {\n  return getRegisteredAuthAdapter() !== null\n}\n\n/**\n * `fetch` wrapper that attaches embed-proxy bearer headers (when\n * present in sessionStorage) and forces `credentials: 'same-origin'`\n * so Supabase auth cookies travel too.\n *\n * **Header merge direction (proxy WINS over caller):** the implementation\n * spreads `baseHeaders` first inside `applyProxyAuth`, then sets the\n * `Authorization` / `X-Chat-*` keys — so the proxy values take precedence\n * over anything the caller passed. The motivation is that the bearer +\n * act-as identity is the source of truth for embedded auth; a caller\n * accidentally passing a stale `Authorization` header should NOT override\n * the live proxy creds.\n *\n * **Cross-origin defense:** the wrapper assumes a same-origin `/api/…`\n * relative URL. Absolute URLs are accepted only when their origin matches\n * the current window's origin; cross-origin URLs throw before the bearer\n * leaves the page. This is a defense-in-depth guard for future call sites\n * — there is no legitimate cross-origin use of this fetch wrapper.\n *\n * **401 self-heal:** when a registered adapter supplies `refresh`, a `401`\n * response triggers a single token refresh + retry of the same request\n * (see `EmbedAuthAdapter.refresh`). This is the openframe `apiClient`'s\n * refresh-then-retry behaviour, lifted into the lib so embedded surfaces\n * no longer need a host-side `window.fetch` monkey-patch to survive an\n * expired access token mid-chat. With no adapter (or no `refresh`), the\n * 401 passes straight through unchanged.\n */\nexport function embedAuthedFetch(url: string, init: RequestInit = {}): Promise<Response> {\n  // Same-origin guard runs SYNCHRONOUSLY (not awaited inside the async\n  // helper below) so a bearer-leaking cross-origin URL throws before any\n  // promise is created — callers and tests rely on the synchronous throw.\n  assertSameOrigin(url)\n\n  // `applyProxyAuth` accepts `Record<string, string>`; normalize the\n  // caller's headers to that shape ONCE, up front. RequestInit accepts\n  // `HeadersInit` which is broader (Headers instance OR array of tuples).\n  // We re-derive the per-request headers from this base on every attempt\n  // (initial + post-refresh retry) so a rotated bearer is picked up.\n  //\n  // When the caller passes no headers, fall back to the same default\n  // `applyProxyAuth` uses internally — `Content-Type: application/json` —\n  // so JSON POSTs keep their content-type when only `embedAuthedFetch(url)`\n  // is used at the call site. GET callers that explicitly want no body\n  // headers can pass `init.headers = {}` to opt out.\n  let baseHeaders: Record<string, string>\n  if (init.headers === undefined) {\n    baseHeaders = { 'Content-Type': 'application/json' }\n  } else {\n    baseHeaders = {}\n    if (init.headers instanceof Headers) {\n      init.headers.forEach((v, k) => {\n        baseHeaders[k] = v\n      })\n    } else if (Array.isArray(init.headers)) {\n      for (const [k, v] of init.headers) baseHeaders[k] = v\n    } else {\n      Object.assign(baseHeaders, init.headers as Record<string, string>)\n    }\n  }\n\n  return fetchWithRefresh(url, init, baseHeaders, false)\n}\n\n/**\n * Single in-flight refresh shared across all concurrent `embedAuthedFetch`\n * callers. A stampede of chat requests that all 401 at the same moment must\n * trigger the adapter's `refresh()` ONCE, not N times — otherwise an\n * expiring session fires a thundering herd of refresh calls at the auth\n * server. Resets to `null` once settled so the next genuine expiry can\n * refresh again.\n */\n// Stored on `globalThis` rather than a module-local so the \"single refresh\"\n// guarantee survives module duplication. Bundlers can ship more than one copy\n// of this module (e.g. across chunks or a host + embedded build); a per-module\n// variable would let each copy run its own refresh cycle, re-creating the\n// thundering-herd this dedupe exists to prevent.\nconst IN_FLIGHT_REFRESH_GLOBAL_KEY = '__embedAuthedFetchInFlightRefresh__'\n\nfunction getInFlightRefresh(): Promise<boolean> | null {\n  if (typeof globalThis === 'undefined') return null\n  return (\n    ((globalThis as Record<string, unknown>)[IN_FLIGHT_REFRESH_GLOBAL_KEY] as\n      | Promise<boolean>\n      | null\n      | undefined) ?? null\n  )\n}\n\nfunction setInFlightRefresh(refresh: Promise<boolean> | null): void {\n  if (typeof globalThis === 'undefined') return\n  ;(globalThis as Record<string, unknown>)[IN_FLIGHT_REFRESH_GLOBAL_KEY] = refresh\n}\n\nfunction dedupedRefresh(): Promise<boolean> {\n  const adapter = getRegisteredAuthAdapter()\n  if (!adapter?.refresh) return Promise.resolve(false)\n  let inFlightRefresh = getInFlightRefresh()\n  if (!inFlightRefresh) {\n    // Wrap in `Promise.resolve` so an adapter that throws synchronously\n    // (rather than rejecting) still funnels through the shared slot and\n    // clears it. A rejected refresh is treated as \"could not refresh\".\n    inFlightRefresh = Promise.resolve()\n      .then(() => adapter.refresh!())\n      .catch(() => false)\n      .finally(() => {\n        setInFlightRefresh(null)\n      })\n    setInFlightRefresh(inFlightRefresh)\n  }\n  return inFlightRefresh\n}\n\n/**\n * Core fetch path: merge proxy-auth + adapter headers, issue the request,\n * and — on a `401` with a refresh-capable adapter — refresh once and retry\n * the identical request a single time. Mirrors the openframe `apiClient`'s\n * refresh-then-retry contract (`isRetry` guards against infinite loops).\n */\nasync function fetchWithRefresh(\n  url: string,\n  init: RequestInit,\n  baseHeaders: Record<string, string>,\n  isRetry: boolean,\n): Promise<Response> {\n  // Re-run the merge each attempt: `applyProxyAuth` reads the latest stored\n  // proxy creds and `getHeaders()` reads the latest bearer, so a retry after\n  // refresh carries the rotated token rather than the stale one. `{...baseHeaders}`\n  // keeps the caller's normalized headers immutable across attempts.\n  const { url: authedUrl, headers } = applyProxyAuth(url, { ...baseHeaders })\n\n  // Host-supplied auth adapter layer. Runs AFTER the proxy-auth merge so\n  // adapter headers override both caller and proxy values — the adapter\n  // is the host's explicit \"this is my auth model\" override, intentionally\n  // last-writer-wins. When no adapter is registered, this is a zero-cost\n  // no-op (object spread of `{}`).\n  const adapter = getRegisteredAuthAdapter()\n  if (adapter?.getHeaders) {\n    // Filter `undefined` values — the adapter type allows them so consumers\n    // don't have to narrow `{ Authorization: token ? '…' : undefined }`-shaped\n    // returns, but `fetch` headers must be strings.\n    for (const [k, v] of Object.entries(adapter.getHeaders())) {\n      if (v !== undefined) headers[k] = v\n    }\n  }\n  const credentials = adapter?.credentials ?? init.credentials ?? 'same-origin'\n\n  const response = await fetch(authedUrl, {\n    ...init,\n    headers,\n    // Default `same-origin` carries Supabase cookies for the MPH proxy-\n    // auth model. Hosts on different origins (openframe-frontend ↔\n    // openframe gateway) register `credentials: 'include'` via the\n    // adapter to make their own cookies travel cross-origin (CORS +\n    // `SameSite=None` must be configured server-side for that to work).\n    credentials,\n  })\n\n  // 401 self-heal: refresh the token once and retry. Only when an adapter\n  // opted into `refresh`, and only on the first attempt — a 401 on the\n  // retry means the fresh token is also unauthorized, so surface it.\n  if (response.status === 401 && !isRetry && adapter?.refresh) {\n    const refreshed = await dedupedRefresh()\n    if (refreshed) {\n      return fetchWithRefresh(url, init, baseHeaders, true)\n    }\n  }\n\n  return response\n}\n\n/**\n * Reject any URL that resolves to a cross-origin destination or to a\n * non-http(s) scheme. Every input is resolved against\n * `window.location.href` so the same rule covers path-only\n * (`/api/...`), absolute (`https://...`), protocol-relative\n * (`//host/...`), AND whitespace-prefixed forms (`\\t//evil.com/...`) —\n * the WHATWG fetch spec strips leading ASCII whitespace before\n * parsing, so any regex-based \"skip relative\" shortcut is bypassable\n * with a leading `\\t`/`\\n`/`\\r`/space. We resolve unconditionally\n * instead and compare origins.\n *\n * Also blocks `javascript:` / `data:` / `blob:` etc. — only `http(s):`\n * is allowed. This is explicit allowlisting rather than relying on\n * `origin === 'null'` to fall out wrong.\n *\n * Server-side rendering: when `typeof window === 'undefined'` we skip\n * the check — the bearer comes from sessionStorage which doesn't exist\n * on the server, so there's nothing to leak anyway.\n */\nfunction assertSameOrigin(url: string): void {\n  if (typeof window === 'undefined') return\n  let target: URL\n  let pageOrigin: string\n  try {\n    target = new URL(url, window.location.href)\n    // Derive the page origin from `href` rather than reading\n    // `window.location.origin` directly so the check works in test\n    // environments that mock `window.location` to a plain object\n    // without an `origin` field (jsdom setups do this).\n    pageOrigin = new URL(window.location.href).origin\n  } catch {\n    throw new Error(`embedAuthedFetch: refusing to fetch malformed URL (${JSON.stringify(url)})`)\n  }\n  if (target.protocol !== 'http:' && target.protocol !== 'https:') {\n    throw new Error(\n      `embedAuthedFetch: refusing non-http(s) URL (${target.protocol}) — pass a relative /api/* path instead`,\n    )\n  }\n  if (target.origin !== pageOrigin) {\n    // Dev-mode escape hatch — embedded apps (e.g. openframe-frontend)\n    // run on a different origin from their gateway during local dev,\n    // and forcing a Next.js `rewrites()` workaround is more error-prone\n    // than relaxing the guard for the dev build. In production\n    // (`NODE_ENV === 'production'`) the guard stays absolute — same\n    // defense-in-depth bearer-leak protection as before. The check is\n    // baked at build time by Next/webpack/Turbopack so prod bundles\n    // contain only the throwing branch (no dev string in the artifact).\n    if (process.env.NODE_ENV !== 'production') {\n      console.warn(\n        `[embedAuthedFetch] cross-origin fetch to ${target.origin} ` +\n          `allowed in dev (NODE_ENV !== 'production'). Production builds ` +\n          `will reject this — wire a same-origin proxy before shipping.`,\n      )\n      return\n    }\n    throw new Error(\n      `embedAuthedFetch: refusing cross-origin fetch to ${target.origin} — pass a relative /api/* path instead`,\n    )\n  }\n}\n","/**\n * useNearViewport — module-level shared IntersectionObserver in hook form.\n *\n * Single IO instance per `rootMargin` value, shared across every component\n * that mounts the hook. Reduces overhead vs. one IO per component on\n * grid/list pages where many subscribers observe the viewport with the same\n * margin. Promoted from the inline singleton at\n * `multi-platform-hub/components/shared/video-bites-display.tsx:21-43`,\n * which is the only IO pattern in either repo today.\n *\n * Usage:\n * ```tsx\n * function MyCard() {\n *   const { ref, isNear } = useNearViewport('500px');\n *   return <div ref={ref}>{isNear ? <HeavyChild /> : <Placeholder />}</div>;\n * }\n * ```\n *\n * StrictMode safety: cleanup uses an identity check on the registered\n * callback so React's dev double-mount (mount → cleanup → re-mount) does\n * not drop the second mount's freshly-set subscription. The IO callback\n * also checks `subscribers.get(target)` before invoking so a fire that\n * races with unmount cannot crash on a torn-down component.\n *\n * The hook fires once — on first intersection it sets `isNear=true` and\n * unobserves the element. Callers that need re-observation should\n * unmount and remount (or fork the hook for two-way behavior).\n */\n\nimport { useEffect, useRef, useState, useCallback } from 'react';\n\n// Per-rootMargin IO map. Multiple call sites with different margins each\n// get their own singleton observer.\nconst observers = new Map<string, IntersectionObserver>();\nconst subscribers = new WeakMap<Element, () => void>();\n\nfunction getObserverFor(rootMargin: string): IntersectionObserver {\n  const existing = observers.get(rootMargin);\n  if (existing) return existing;\n\n  const io = new IntersectionObserver(\n    (entries) => {\n      entries.forEach((entry) => {\n        if (!entry.isIntersecting) return;\n        // Race-safe: re-read the callback at fire time. A late IO firing\n        // after cleanup must not invoke a stale callback.\n        const cb = subscribers.get(entry.target);\n        if (cb) {\n          cb();\n          io.unobserve(entry.target);\n          subscribers.delete(entry.target);\n        }\n      });\n    },\n    { rootMargin }\n  );\n  observers.set(rootMargin, io);\n  return io;\n}\n\nexport interface UseNearViewportResult<T extends Element = HTMLElement> {\n  /** Ref to attach to the element you want to gate on visibility. */\n  ref: (node: T | null) => void;\n  /** Flips to `true` once the element enters within `rootMargin` of the viewport. Never flips back. */\n  isNear: boolean;\n}\n\n/**\n * @param rootMargin Margin around the viewport (CSS-style string).\n *                   '500px' = element starts mounting 500px before scroll-in.\n *                   '1000px' = a full viewport's worth of lookahead.\n *                   '0px' = strict on-screen detection.\n */\nexport function useNearViewport<T extends Element = HTMLElement>(\n  rootMargin: string = '500px'\n): UseNearViewportResult<T> {\n  const [isNear, setIsNear] = useState(false);\n  const elRef = useRef<T | null>(null);\n\n  // Subscribe/unsubscribe on element change.\n  const ref = useCallback(\n    (node: T | null) => {\n      const prev = elRef.current;\n\n      // Unsubscribe previous, if any. Identity-check the callback so a\n      // StrictMode re-mount that has already re-registered keeps its sub.\n      if (prev) {\n        const stillOurs = subscribers.get(prev);\n        if (stillOurs) {\n          subscribers.delete(prev);\n          observers.get(rootMargin)?.unobserve(prev);\n        }\n      }\n\n      elRef.current = node;\n      if (!node) return;\n\n      const cb = () => setIsNear(true);\n      subscribers.set(node, cb);\n      getObserverFor(rootMargin).observe(node);\n    },\n    [rootMargin]\n  );\n\n  // Unsubscribe on unmount. Identity check guards the StrictMode race.\n  useEffect(() => {\n    return () => {\n      const el = elRef.current;\n      if (!el) return;\n      if (subscribers.get(el)) {\n        subscribers.delete(el);\n        observers.get(rootMargin)?.unobserve(el);\n      }\n    };\n  }, [rootMargin]);\n\n  return { ref, isNear };\n}\n","'use client'\n\nimport { useMemo } from 'react'\n\n/**\n * Hook that generates a branded placeholder image URL using the\n * host's `/api/og-placeholder` server-side image generator (or any\n * builder the caller supplies).\n *\n * THIS HOOK IS A THIN CLIENT-SIDE WRAPPER. The hub-side wrapper\n * (`hooks/use-og-placeholder.ts` in multi-platform-hub) injects its\n * canonical `buildOgPlaceholderUrl` from `lib/utils/entity-image.ts`.\n * The lib version takes the builder as an argument so the lib has no\n * hub dependency.\n *\n * @param buildUrl - Function that builds the placeholder URL from a\n *                   title + options object (`{ site?, aspect? }`).\n *                   Hub passes `buildOgPlaceholderUrl` from\n *                   `lib/utils/entity-image.ts`. Embedded apps can\n *                   wire any equivalent that hits their own placeholder\n *                   route.\n * @param title    - Text to display on the placeholder\n * @param siteName - Site name shown below the title (optional —\n *                   defaults to empty)\n * @param enabled  - Whether to generate the URL (default: true)\n * @param aspect   - `'wide'` (1200×630 social-card; default) or `'square'`\n *                   (1024×1024 — used by compact chat-inline card slots\n *                   so `object-cover` doesn't crop the title off).\n * @returns Placeholder image URL or null if disabled / no title\n */\nexport function useOgPlaceholder(\n  buildUrl: (title: string, options: { site?: string; aspect?: 'wide' | 'square' }) => string,\n  title: string | undefined | null,\n  siteName: string = '',\n  enabled: boolean = true,\n  aspect: 'wide' | 'square' = 'wide',\n): string | null {\n  return useMemo(() => {\n    if (!enabled || !title) return null\n    const options: { site?: string; aspect?: 'wide' | 'square' } = {}\n    if (siteName) options.site = siteName\n    if (aspect === 'square') options.aspect = 'square'\n    return buildUrl(title, options)\n  }, [buildUrl, title, siteName, enabled, aspect])\n}\n","'use client'\n\n/**\n * `contentFetch` — the fetch the lib's SELF-FETCHING content surfaces use:\n * roadmap (list + vote + per-task refresh), delivery, product releases,\n * onboarding guides (catalog + detail), legal docs, and the release-detail\n * injected roadmap/delivery sections.\n *\n * It deliberately reuses the SINGLE embed-auth knob — the registered\n * `EmbedAuthAdapter` — instead of introducing a second registration:\n *   - adapter registered (host opted into embedded auth, e.g. openframe-frontend\n *     for its embedded chat) → route through `embedAuthedFetch`, so content GETs/\n *     POSTs carry the SAME bearer/cookie + 401-refresh as the chat.\n *   - no adapter (the public hub, or the embedding example whose proxy injects\n *     auth server-side) → a plain, byte-for-byte unchanged `fetch`.\n *\n * So a host wires auth ONCE (the chat adapter) and content inherits it; there is\n * no content-specific fetcher to configure.\n */\n\nimport { embedAuthedFetch, hasEmbedAuthAdapter } from './embed-authed-fetch'\n\nexport const contentFetch: typeof fetch = (input, init) => {\n  if (!hasEmbedAuthAdapter()) return fetch(input, init)\n  // embedAuthedFetch takes a string url; coerce the broader `fetch` input shape\n  // (content surfaces always pass strings, but handle URL/Request defensively).\n  const url =\n    typeof input === 'string' ? input : input instanceof URL ? input.href : (input as Request).url\n  return embedAuthedFetch(url, init)\n}\n"],"mappings":"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","names":["useState","useEffect","adapter","useEffect","useRef","useState","useCallback"]}

package/dist/chunk-RJUGNL2A.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/openframe-oss-lib/openframe-oss-lib/openframe-frontend-core/dist/chunk-RJUGNL2A.cjs","../src/components/faq/faq-section.tsx","../src/components/faq-accordion.tsx","../src/components/faq/json-ld.ts","../src/components/faq/faq-document-page.tsx"],"names":["jsx","jsxs"],"mappings":"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","file":"/home/runner/work/openframe-oss-lib/openframe-oss-lib/openframe-frontend-core/dist/chunk-RJUGNL2A.cjs","sourcesContent":[null,"\"use client\"\n\nimport React, { useCallback, useEffect, useMemo, useState } from 'react'\nimport type { Faq } from '../../types/faq'\nimport { FaqAccordion, type FaqItem } from '../faq-accordion'\nimport { useSelfFetch } from '../../hooks/use-self-fetch'\nimport { buildSuggestionUrl } from '../../utils/suggestion-url'\nimport { serializeJsonLd } from '../../utils/common'\nimport { scrollElementIntoView } from '../../utils/scroll-into-view'\nimport { cn } from '../../utils/cn'\nimport { buildFaqJsonLdFromFaqs, type FaqSchemaOptions } from './json-ld'\nimport { SECTION_HEADING_CLASS } from '../layout/page-heading'\n\nexport interface FaqSectionProps {\n  /**\n   * SSR hydrate. When provided, the hook skips the first client fetch (per\n   * useSelfFetch contract). The consuming server page resolves FAQs then drills\n   * them into this prop — the lib never re-fetches what the host already gated on.\n   */\n  initialFaqs?: Faq[]\n  /** Both required together for entity-attached FAQs; partial → bare /api/faqs. */\n  entityType?: string\n  entityId?: number | string\n  /**\n   * Heading node above the grouped list. `undefined` → default\n   * `<h2>`\"Frequently Asked Questions\". `null` → no heading (the host page\n   * owns the `<h1>`, as the standalone /faqs surface does). A React node lets a\n   * platform drill its own <PageHeading> without the lib referencing platform\n   * state. Also drives category nesting so the document outline stays correct:\n   * `null` → categories render `<h2>` (directly under the page `<h1>`);\n   * otherwise categories render `<h3>` beneath this heading.\n   */\n  heading?: React.ReactNode | null\n  /** Inject FAQPage schema.org JSON-LD as a <script>. Off by default so embeds\n   *  don't emit duplicate schema. */\n  emitJsonLd?: boolean\n  /** Overrides for the JSON-LD's name/description/url. */\n  jsonLd?: FaqSchemaOptions\n  className?: string\n  /** Maps to /api/faqs `?count=` (the 5-tier fill target). Absent → param\n   *  not sent (server default applies). */\n  minResults?: number\n  /** Fetch-URL prefix for third-party embeds / reverse proxies\n   *  ('' = same-origin relative). */\n  apiBaseUrl?: string\n}\n\nconst DEFAULT_HEADING_TEXT = 'Frequently Asked Questions'\n\n/** URL composition shared with RelatedContentSection (`buildSuggestionUrl`)\n *  — byte-identical to the historical `buildFaqsUrl` output when\n *  `minResults`/`apiBaseUrl` are absent. */\nfunction buildFaqsUrl(\n  entityType?: string,\n  entityId?: number | string,\n  minResults?: number,\n  apiBaseUrl = '',\n): string {\n  return buildSuggestionUrl('/api/faqs', { apiBaseUrl, entityType, entityId, count: minResults })\n}\n\n/** Stable, URL-safe anchor id for a category. Prefixed so it can't collide\n *  with other in-page ids, and so a bare numeric/blank section still yields a\n *  valid id. */\nfunction sectionSlug(section: string): string {\n  return (\n    'faq-' +\n    section\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/^-+|-+$/g, '')\n  )\n}\n\ninterface FaqGroup {\n  /** null → the uncategorized bucket: no heading, no jump pill, rendered last. */\n  section: string | null\n  slug: string | null\n  items: FaqItem[]\n}\n\n/** Group FAQs by `faq.section`, preserving the server's first-seen\n *  (display_order) order for BOTH the section order and the rows within each\n *  section. The uncategorized bucket (blank/missing section) sinks to the end\n *  since it renders without a heading. Items carry NO badge here — the `<h2>`\n *  IS the category, so a per-row chip would be redundant. */\nfunction groupFaqsBySection(faqs: Faq[]): FaqGroup[] {\n  const order: string[] = []\n  const byName = new Map<string, FaqGroup>()\n  let uncategorized: FaqGroup | null = null\n  for (const faq of faqs) {\n    const item: FaqItem = { id: faq.id, question: faq.question, answer: faq.answer }\n    const name = faq.section?.trim()\n    if (!name) {\n      if (!uncategorized) uncategorized = { section: null, slug: null, items: [] }\n      uncategorized.items.push(item)\n      continue\n    }\n    let group = byName.get(name)\n    if (!group) {\n      group = { section: name, slug: sectionSlug(name), items: [] }\n      byName.set(name, group)\n      order.push(name)\n    }\n    group.items.push(item)\n  }\n  const groups = order.map((name) => byName.get(name)!)\n  if (uncategorized) groups.push(uncategorized)\n  return groups\n}\n\n/** The standard hub sticky-header height — same offset `useNavLink`'s hash\n *  scroll uses, so a category jump lands below the header, not under it. */\nconst FAQ_NAV_HEADER_OFFSET = 96\n\n/**\n * Grouped FAQ layout: a category jump-nav above stacked `<h2>` category\n * sections (each its own accordion). Isolated into its own component so the\n * scroll-spy hooks only mount in grouped mode — `FaqSection`'s own hooks stay\n * unconditional.\n *\n * The pills are real `<a href=\"#slug\">` anchors (crawlable in-page links,\n * deep-linkable, work without JS); the click handler upgrades the jump to the\n * cancellation-proof `scrollElementIntoView` tween and syncs the URL hash.\n */\nfunction GroupedFaqList({\n  groups,\n  categoryHeadingAs,\n}: {\n  groups: FaqGroup[]\n  /** Heading tag for each category, so the document outline nests correctly\n   *  under whatever owns the heading above this block: `h2` on the standalone\n   *  page (the page owns the `<h1>`), `h3` beneath an embed's `<h2>` title.\n   *  The VISUAL is `SECTION_HEADING_CLASS` either way, so categories look\n   *  identical on every surface. */\n  categoryHeadingAs: 'h2' | 'h3'\n}) {\n  const CategoryHeading = categoryHeadingAs\n  const navGroups = useMemo(() => groups.filter((g) => g.slug), [groups])\n  const [activeSlug, setActiveSlug] = useState<string | null>(navGroups[0]?.slug ?? null)\n  // Identity-stable key for the section set so the observer re-binds only when\n  // the categories actually change (not on every parent re-render).\n  const slugKey = navGroups.map((g) => g.slug).join('|')\n\n  // Scroll-spy: mark the pill for the category currently at the top of the\n  // viewport. rootMargin drops the trigger line just below the sticky header\n  // and ignores the bottom ~55% so \"active\" is the section being read, not the\n  // next one peeking in.\n  useEffect(() => {\n    if (navGroups.length < 2) return\n    const tops = new Map<string, number>()\n    const observer = new IntersectionObserver(\n      (entries) => {\n        for (const entry of entries) {\n          const id = (entry.target as HTMLElement).id\n          if (entry.isIntersecting) tops.set(id, entry.boundingClientRect.top)\n          else tops.delete(id)\n        }\n        let bestId: string | null = null\n        let bestTop = Number.POSITIVE_INFINITY\n        for (const [id, top] of tops) {\n          if (top < bestTop) {\n            bestTop = top\n            bestId = id\n          }\n        }\n        if (bestId) setActiveSlug(bestId)\n      },\n      { rootMargin: `-${FAQ_NAV_HEADER_OFFSET}px 0px -55% 0px`, threshold: 0 },\n    )\n    for (const group of navGroups) {\n      const el = group.slug ? document.getElementById(group.slug) : null\n      if (el) observer.observe(el)\n    }\n    return () => observer.disconnect()\n    // slugKey encodes the section set; re-observe only when it changes.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [slugKey])\n\n  const handleJump = useCallback(\n    (e: React.MouseEvent<HTMLAnchorElement>, slug: string) => {\n      e.preventDefault()\n      setActiveSlug(slug)\n      scrollElementIntoView(document.getElementById(slug), {\n        headerOffset: FAQ_NAV_HEADER_OFFSET,\n      })\n      if (typeof history !== 'undefined') history.replaceState(null, '', `#${slug}`)\n    },\n    [],\n  )\n\n  return (\n    <div className=\"space-y-8\">\n      {navGroups.length > 1 && (\n        <nav aria-label=\"FAQ categories\" className=\"flex flex-wrap gap-2\">\n          {navGroups.map((group) => {\n            const isActive = group.slug === activeSlug\n            return (\n              <a\n                key={group.slug}\n                href={`#${group.slug}`}\n                aria-current={isActive ? 'true' : undefined}\n                onClick={(e) => handleJump(e, group.slug as string)}\n                className={cn(\n                  \"rounded-full border px-4 py-2 text-sm font-medium font-['DM_Sans'] transition-colors\",\n                  isActive\n                    ? 'border-ods-text-primary bg-ods-card text-ods-text-primary'\n                    : 'border-ods-border bg-ods-card text-ods-text-secondary hover:border-ods-text-secondary hover:text-ods-text-primary',\n                )}\n              >\n                {group.section}\n              </a>\n            )\n          })}\n        </nav>\n      )}\n      <div className=\"space-y-10\">\n        {groups.map((group) => (\n          <section\n            key={group.slug ?? 'faq-uncategorized'}\n            id={group.slug ?? undefined}\n            className=\"scroll-mt-24 space-y-4\"\n          >\n            {group.section && (\n              <CategoryHeading className={SECTION_HEADING_CLASS}>{group.section}</CategoryHeading>\n            )}\n            <FaqAccordion items={group.items} />\n          </section>\n        ))}\n      </div>\n    </div>\n  )\n}\n\nfunction FaqSkeleton() {\n  return (\n    <div className=\"space-y-8 animate-pulse\">\n      <div className=\"h-12 md:h-14 w-2/3 rounded bg-ods-border\" />\n      <div className=\"rounded-3xl border border-ods-border overflow-hidden bg-ods-card divide-y divide-ods-border w-full\">\n        {Array.from({ length: 8 }).map((_, idx) => (\n          <div key={idx} className=\"flex items-center justify-between px-6 md:px-8 py-6\">\n            <div className=\"h-6 w-5/6 rounded bg-ods-border\" />\n            <div className=\"h-10 w-10 rounded-md bg-ods-border\" />\n          </div>\n        ))}\n      </div>\n    </div>\n  )\n}\n\ninterface FaqsResponse {\n  faqs: Faq[]\n}\n\n/**\n * The FAQ display surface — ONE rendering on every host: the list grouped by\n * `faq.section` (each category a heading + its own accordion, with a category\n * jump-nav once there are 2+ categories). There is no flat/ungrouped mode and\n * no page-vs-embedded shell fork; the standalone /faqs page and every embed\n * render through this single path, so they cannot drift.\n *\n * - Standalone /faqs page: pass `initialFaqs` (SSR) + `heading={null}` (the\n *   page owns the <h1>) + `emitJsonLd` with `jsonLd` overrides for SEO.\n * - Per-entity embed: pass `entityType` + `entityId` (no `initialFaqs`); the\n *   hook self-fetches `GET /api/faqs`, and `heading` is this block's own <h2>.\n *\n * CONTRACT: the consuming app MUST implement `GET /api/faqs`. On a fetch error\n * (or zero FAQs) the component renders nothing so the host page isn't\n * disfigured. The host always supplies the page shell — this renders a bare\n * <section>.\n */\nexport function FaqSection({\n  initialFaqs,\n  entityType,\n  entityId,\n  heading,\n  emitJsonLd = false,\n  jsonLd,\n  className,\n  minResults,\n  apiBaseUrl = '',\n}: FaqSectionProps) {\n  const url = buildFaqsUrl(entityType, entityId, minResults, apiBaseUrl)\n  // Memoized — useSelfFetch re-syncs on [initialData]; a fresh per-render\n  // wrapper object would setState-loop under re-rendering parents.\n  const initialData = useMemo<FaqsResponse | undefined>(\n    () => (initialFaqs ? { faqs: initialFaqs } : undefined),\n    [initialFaqs],\n  )\n  const { data, isLoading, error } = useSelfFetch<FaqsResponse>(url, { initialData })\n\n  const faqs = data?.faqs ?? []\n  // Grouped before the early returns so the hook order stays stable.\n  const groups = useMemo(() => (faqs.length > 0 ? groupFaqsBySection(faqs) : []), [faqs])\n\n  // `undefined` → default <h2> title; `null` → the host page owns the <h1>, so\n  // no title renders here. `heading === null` also makes the category headings\n  // <h2> (directly under the page <h1>); otherwise they nest as <h3>.\n  const headingNode =\n    heading === undefined ? <h2 className={SECTION_HEADING_CLASS}>{DEFAULT_HEADING_TEXT}</h2> : heading\n\n  // Degrade silently — never show an error banner or an empty section shell\n  // where FAQs would be (host pages and the standalone surface both rely on it).\n  if (error) return null\n  if (!isLoading && faqs.length === 0) return null\n  if (isLoading && faqs.length === 0) {\n    return (\n      <div className={className}>\n        <FaqSkeleton />\n      </div>\n    )\n  }\n\n  const schema = emitJsonLd ? buildFaqJsonLdFromFaqs(faqs, jsonLd) : null\n\n  return (\n    <>\n      <section className={className ?? 'space-y-10'}>\n        {headingNode}\n        <GroupedFaqList groups={groups} categoryHeadingAs={heading === null ? 'h2' : 'h3'} />\n      </section>\n      {schema && (\n        <script\n          type=\"application/ld+json\"\n          // eslint-disable-next-line react/no-danger\n          // serializeJsonLd, NOT raw JSON.stringify — FAQ answers are\n          // admin-entered; an embedded \"</script>\" must not break the tag.\n          dangerouslySetInnerHTML={{ __html: serializeJsonLd(schema) }}\n        />\n      )}\n    </>\n  )\n}\n","\"use client\"\n\nimport React, { useRef, useState, useEffect, useCallback } from 'react'\nimport { ChevronButton } from './ui/chevron-button'\nimport { cn } from \"../utils/cn\"\n\nexport interface FaqItem {\n  id: number | string\n  question: string\n  answer: string\n}\n\ninterface FaqAccordionProps {\n  items: FaqItem[]\n  defaultOpenIds?: (number | string)[]\n}\n\n// Utility to measure scrollHeight outside render cycle\nconst useMeasuredHeight = (isOpen: boolean) => {\n  const ref = useRef<HTMLDivElement | null>(null)\n  const [maxHeight, setMaxHeight] = useState<string>('0px')\n\n  const measure = useCallback(() => {\n    if (ref.current) {\n      const height = ref.current.scrollHeight\n      setMaxHeight(`${height}px`)\n    }\n  }, [])\n\n  // Update height only when section is open\n  useEffect(() => {\n    if (isOpen) {\n      measure()\n    } else {\n      setMaxHeight('0px')\n    }\n  }, [isOpen, measure])\n\n  return { ref, maxHeight }\n}\n\nexport function FaqAccordion({ items, defaultOpenIds = [] }: FaqAccordionProps) {\n  const [openSet, setOpenSet] = useState<Set<string | number>>(new Set(defaultOpenIds))\n\n  const toggle = (id: string | number) => {\n    setOpenSet(prev => {\n      const next = new Set(prev)\n      if (next.has(id)) next.delete(id)\n      else next.add(id)\n      return next\n    })\n  }\n\n  return (\n    <div className=\"rounded-3xl border border-ods-border divide-y divide-ods-border bg-ods-card overflow-hidden\">\n      {items.map(item => {\n        const isOpen = openSet.has(item.id)\n        const { ref, maxHeight } = useMeasuredHeight(isOpen)\n\n        return (\n          <div\n            key={item.id}\n            className={cn('group transition-colors hover:bg-[#1E1E1E]', isOpen ? 'bg-ods-bg' : 'bg-transparent')}\n          >\n            {/* Header */}\n            <div\n              role=\"button\"\n              tabIndex={0}\n              onClick={() => toggle(item.id)}\n              onKeyDown={(e) => {\n                if (e.key === 'Enter' || e.key === ' ') {\n                  e.preventDefault();\n                  toggle(item.id);\n                }\n              }}\n              aria-expanded={isOpen}\n              className=\"flex w-full items-center justify-between px-6 md:px-8 py-6 text-left focus:outline-none transition-colors cursor-pointer\"\n            >\n              <div className=\"min-w-0 pr-4\">\n                <h3>\n                  {item.question}\n                </h3>\n              </div>\n              <div className=\"flex-shrink-0\">\n                <ChevronButton\n                  aria-label={isOpen ? 'Collapse question' : 'Expand question'}\n                  size=\"md\"\n                  isExpanded={isOpen}\n                  backgroundColor=\"transparent\"\n                  borderColor=\"#3A3A3A\"\n                />\n              </div>\n            </div>\n            {/* Content wrapper with max-height animation */}\n            <div\n              style={{ maxHeight, transition: 'max-height 0.35s ease-in-out, opacity 0.35s ease-in-out', opacity: isOpen ? 1 : 0 }}\n              className=\"overflow-hidden group-hover:bg-[#1E1E1E]/30\"\n            >\n              <div ref={ref} className=\"px-6 md:px-8 pb-6 text-ods-text-primary text-h4\">\n                {item.answer}\n              </div>\n            </div>\n          </div>\n        )\n      })}\n    </div>\n  )\n} ","/**\n * Pure FAQ JSON-LD builder. No React, no client-only deps — safe to import from\n * Server Components via the `./components/faq` subpath export. (Do NOT import\n * through the root `./components` barrel — that barrel is `\"use client\"` and\n * dragging it into a Server Component would force the client graph into the\n * server.)\n *\n * The hub used to harcode `name`/`description` here for OpenMSP; in the lib we\n * accept overrides so every embedder can supply its own platform branding.\n */\nimport type { Faq } from '../../types/faq'\n\nexport interface FaqSchemaOptions {\n  name?: string\n  description?: string\n  url?: string\n}\n\nconst DEFAULT_NAME = 'Frequently Asked Questions'\nconst DEFAULT_DESCRIPTION =\n  'Answers to common questions.'\n\nexport function baseFaqSchema(opts: FaqSchemaOptions = {}) {\n  return {\n    '@context': 'https://schema.org',\n    '@type': 'FAQPage',\n    name: opts.name ?? DEFAULT_NAME,\n    description: opts.description ?? DEFAULT_DESCRIPTION,\n    ...(opts.url ? { url: opts.url } : {}),\n  } as const\n}\n\nexport function buildFaqJsonLdFromFaqs(faqs: Faq[], opts: FaqSchemaOptions = {}) {\n  return {\n    ...baseFaqSchema(opts),\n    mainEntity: faqs.map((faq) => ({\n      '@type': 'Question',\n      name: faq.question,\n      acceptedAnswer: {\n        '@type': 'Answer',\n        text: faq.answer,\n      },\n    })),\n  } as const\n}\n","'use client';\n\n/**\n * FaqDocumentPage — the full `/faqs` page with chrome, so embedders drop in\n * ONE component instead of hand-assembling `PageShell` + `PageLayout` around the\n * bare `<FaqSection>`. Mirrors `LegalDocumentPage` / `DevSectionPage`: the\n * page-level layout lives in the lib, the host passes only config + a back button.\n *\n * `<FaqSection heading={null}>` lets `PageLayout`'s `TitleBlock` own the heading +\n * back button; it self-fetches `${apiBaseUrl}/api/faqs` via the authed\n * `useSelfFetch`, and renders nothing on a fetch error or zero FAQs.\n */\n\nimport { PageShell, PageLayout } from '../ui';\nimport { useRouter } from '../../embed-shims/next-navigation';\nimport { FaqSection } from './faq-section';\n\nexport interface FaqDocumentPageProps {\n  /** Page title (PageLayout TitleBlock). Default \"FAQs\". */\n  title?: string;\n  /** Subtitle under the title. */\n  subtitle?: string;\n  /** Back-button config — same pattern as `DevSectionPage` / `LegalDocumentPage`.\n   *  Pass `false` to hide. Default `{ label: 'Back to home', href: '/' }`. */\n  backButton?: { label?: string; href?: string } | false;\n  /** Base URL `FaqSection` appends `/api/faqs` to (reverse-proxy embedders). */\n  apiBaseUrl?: string;\n  /** Optional entity scoping forwarded to `FaqSection`. */\n  entityType?: string;\n  entityId?: number | string;\n  /** Minimum FAQ count before the section renders (forwarded to `FaqSection`). */\n  minResults?: number;\n}\n\nexport function FaqDocumentPage({\n  title = 'FAQs',\n  subtitle,\n  backButton,\n  apiBaseUrl,\n  entityType,\n  entityId,\n  minResults,\n}: FaqDocumentPageProps) {\n  const router = useRouter();\n\n  // Back-button config — mirrors LegalDocumentPage/DevSectionPage. Hide entirely\n  // when the caller passes `false` (embed-mode where the host owns nav chrome).\n  const backCfg =\n    backButton === false\n      ? undefined\n      : {\n          label: backButton?.label ?? 'Back to home',\n          onClick: () => router.push(backButton?.href ?? '/'),\n        };\n\n  return (\n    <PageShell>\n      <PageLayout title={title} subtitle={subtitle} backButton={backCfg}>\n        <FaqSection\n          heading={null}\n          apiBaseUrl={apiBaseUrl}\n          entityType={entityType}\n          entityId={entityId}\n          minResults={minResults}\n        />\n      </PageLayout>\n    </PageShell>\n  );\n}\n"]}