@flamingo-stack/openframe-frontend-core 0.0.690 → 0.0.691-2504.7650.1

package/dist/chunk-YCKGUQA2.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/openframe-oss-lib/openframe-oss-lib/openframe-frontend-core/dist/chunk-YCKGUQA2.cjs","../src/hooks/ui/use-image-edge-color.ts","../src/utils/platform-identity.ts","../src/utils/app-config.ts","../src/utils/local-storage-adapter.ts","../src/utils/embed-proxy-auth-storage.ts","../src/utils/embed-authed-fetch.ts","../src/hooks/use-authed-asset-src.ts","../src/hooks/use-authed-image-src.ts","../src/utils/og-placeholder.ts","../src/hooks/use-og-placeholder-url.ts"],"names":["r","g","b","adapter"],"mappings":"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AA;AACG,QAAA;AACX,MAAA;AACF,IAAA;AAEc,IAAA;AACR,MAAA;AACK,MAAA;AACX,IAAA;AAEU,IAAA;AAEG,IAAA;AACC,MAAA;AACd,IAAA;AACY,EAAA;AAEP,EAAA;AACT;ADhDmB;AACA;AEpEN;AACF,EAAA;AACE,EAAA;AACD,EAAA;AACV,EAAA;AACiB,EAAA;AACF,EAAA;AACA,EAAA;AACD,EAAA;AACC,EAAA;AACT,EAAA;AACD,EAAA;AACM,EAAA;AACb;AAMa;AACN,EAAA;AACP;AAEa;AAET,EAAA;AACS,EAAA;AAET,EAAA;AACF,EAAA;AACM,EAAA;AACD,EAAA;AACM,EAAA;AACb;AAEa;AACF,EAAA;AACE,EAAA;AACD,EAAA;AACV,EAAA;AACM,EAAA;AACD,EAAA;AACM,EAAA;AACb;AAEa;AACF,EAAA;AACE,EAAA;AACD,EAAA;AACC,EAAA;AACX,EAAA;AACiB,EAAA;AACF,EAAA;AACA,EAAA;AACD,EAAA;AACC,EAAA;AACT,EAAA;AACD,EAAA;AACP;AAEgB;AACP,EAAA;AACT;AAGgB;AACP,EAAA;AACT;AAEgB;AACP,EAAA;AACT;AAEgB;AACP,EAAA;AACT;AAEgB;AACP,EAAA;AACT;AAYa;AACM,EAAA;AACA,EAAA;AACF,EAAA;AACN,EAAA;AACA,EAAA;AACF,EAAA;AACP,EAAA;AACF;AAOa;AAEQ,EAAA;AACT,IAAA;AACF,IAAA;AACI,IAAA;AACI,IAAA;AACd,EAAA;AACiB,EAAA;AACT,IAAA;AACF,IAAA;AACI,IAAA;AACI,IAAA;AACd,EAAA;AACe,EAAA;AACP,IAAA;AACF,IAAA;AACI,IAAA;AACI,IAAA;AACd,EAAA;AACS,EAAA;AACD,IAAA;AACF,IAAA;AACI,IAAA;AACI,IAAA;AACd,EAAA;AACS,EAAA;AACD,IAAA;AACF,IAAA;AACI,IAAA;AACI,IAAA;AACd,EAAA;AACO,EAAA;AACC,IAAA;AACF,IAAA;AACI,IAAA;AACI,IAAA;AACd,EAAA;AACA,EAAA;AACQ,IAAA;AACF,IAAA;AACI,IAAA;AACI,IAAA;AACd,E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lBH;AACP,EAAA;AACT;AAOa;ARylBM;AACA;AS5jBb;AAIG;AACQ,EAAA;AACT,EAAA;AACU,EAAA;AAIR,IAAA;AACF,IAAA;AACN,EAAA;AACO,EAAA;AACT;AAYgB;AAKD,EAAA;AACE,EAAA;AACF,EAAA;AACE,EAAA;AAEJ,EAAA;AACO,EAAA;AAKJ,EAAA;AACC,EAAA;AAGJ,EAAA;AACA,EAAA;AAEG,EAAA;AAChB;ATiiBmB;AACA;AUxoBV;AA+BO;AACd,EAAA;AACW,EAAA;AACF,EAAA;AACC,EAAA;AAC+B;AACnC,EAAA;AAES,EAAA;AACR,IAAA;AACE,IAAA;AACM,EAAA;AACjB;AV2mBmB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/openframe-oss-lib/openframe-oss-lib/openframe-frontend-core/dist/chunk-YCKGUQA2.cjs","sourcesContent":[null,"'use client';\n\nimport { useState, useEffect } from 'react';\n\n/**\n * Extract the dominant edge color from an image using color bucketing.\n * Samples pixels along left and right edges (the visible letterbox areas),\n * groups them into color buckets, and returns the most common bucket.\n * This avoids muddy averages when edges have mixed colors (e.g., sky + sand).\n */\nfunction extractEdgeColor(img: HTMLImageElement): string {\n  const canvas = document.createElement('canvas');\n  const ctx = canvas.getContext('2d');\n  if (!ctx) return '#000000';\n\n  const maxSize = 100;\n  const scale = Math.min(maxSize / img.naturalWidth, maxSize / img.naturalHeight);\n  const w = Math.round(img.naturalWidth * scale);\n  const h = Math.round(img.naturalHeight * scale);\n  canvas.width = w;\n  canvas.height = h;\n\n  ctx.drawImage(img, 0, 0, w, h);\n\n  const data = ctx.getImageData(0, 0, w, h).data;\n\n  // Sample left edge, right edge, top edge, bottom edge (15% band)\n  const edgeW = Math.max(2, Math.round(w * 0.15));\n  const edgeH = Math.max(2, Math.round(h * 0.15));\n\n  // Color bucketing: quantize to 32-step buckets for grouping similar colors\n  const bucketSize = 32;\n  const buckets = new Map<string, { r: number; g: number; b: number; count: number }>();\n\n  for (let y = 0; y < h; y++) {\n    for (let x = 0; x < w; x++) {\n      const isEdge = x < edgeW || x >= w - edgeW || y < edgeH || y >= h - edgeH;\n\n      if (!isEdge) continue;\n\n      const i = (y * w + x) * 4;\n      const a = data[i + 3];\n      if (a < 128) continue;\n\n      const r = data[i];\n      const g = data[i + 1];\n      const b = data[i + 2];\n\n      // Quantize to bucket\n      const br = Math.floor(r / bucketSize) * bucketSize;\n      const bg = Math.floor(g / bucketSize) * bucketSize;\n      const bb = Math.floor(b / bucketSize) * bucketSize;\n      const key = `${br},${bg},${bb}`;\n\n      const existing = buckets.get(key);\n      if (existing) {\n        existing.r += r;\n        existing.g += g;\n        existing.b += b;\n        existing.count++;\n      } else {\n        buckets.set(key, { r, g, b, count: 1 });\n      }\n    }\n  }\n\n  if (buckets.size === 0) return '#000000';\n\n  // Find the most common color bucket\n  let bestBucket: { r: number; g: number; b: number; count: number } | null = null;\n  for (const bucket of buckets.values()) {\n    if (!bestBucket || bucket.count > bestBucket.count) {\n      bestBucket = bucket;\n    }\n  }\n\n  if (!bestBucket || bestBucket.count === 0) return '#000000';\n\n  // Return average color within the winning bucket\n  const r = Math.round(bestBucket.r / bestBucket.count);\n  const g = Math.round(bestBucket.g / bestBucket.count);\n  const b = Math.round(bestBucket.b / bestBucket.count);\n\n  return `rgb(${r}, ${g}, ${b})`;\n}\n\n/**\n * Hook that extracts the dominant edge color from an image URL.\n * Returns a CSS color string for use as a background behind object-contain images.\n *\n * Always sets crossOrigin='anonymous' — required for canvas pixel access.\n * Most CDNs (Supabase, Cloudflare, our image proxy) return CORS headers.\n * If the server doesn't support CORS, onerror fires and we use the fallback.\n *\n * @param imageUrl - URL of the image to analyze\n * @param fallback - Fallback color if extraction fails (default: '#000000')\n * @returns CSS color string (e.g., 'rgb(34, 28, 22)')\n */\nexport function useImageEdgeColor(imageUrl: string | undefined | null, fallback = '#000000'): string {\n  const [color, setColor] = useState(fallback);\n\n  // Losing the url (or being given a different fallback) is a prop-driven\n  // reset, so it happens while rendering — React's documented alternative to a\n  // sync-from-props effect. From the effect it would commit one frame with the\n  // departed image's colour still painted behind an image that is already gone.\n  const [resetFor, setResetFor] = useState({ imageUrl, fallback });\n  if (resetFor.imageUrl !== imageUrl || resetFor.fallback !== fallback) {\n    setResetFor({ imageUrl, fallback });\n    if (!imageUrl) setColor(fallback);\n  }\n\n  useEffect(() => {\n    if (!imageUrl) return undefined;\n\n    let cancelled = false;\n    const img = new Image();\n    img.crossOrigin = 'anonymous';\n\n    img.onload = () => {\n      if (cancelled) return;\n      try {\n        setColor(extractEdgeColor(img));\n      } catch {\n        setColor(fallback);\n      }\n    };\n\n    img.onerror = () => {\n      if (cancelled) return;\n      setColor(fallback);\n    };\n\n    img.src = imageUrl;\n\n    return () => {\n      cancelled = true;\n    };\n  }, [imageUrl, fallback]);\n\n  return color;\n}\n","/**\n * Platform identity + brand SSOT (single source of truth).\n *\n * ONE module owns every per-platform STRING (display/short/long name, description,\n * slogan, icon name) and every per-platform COLOUR DECISION (the accent/secondary\n * \"stem\", the theme, the surface). Everything downstream DERIVES from here:\n * `platform-config.tsx`'s icon + colour maps, `PlatformBadge`, `getPlatformConfig`,\n * the hub's `AppConfig.brandColors`, the hub's manifest generator and `theme-color`.\n *\n * JSX-FREE + zero-dependency ON PURPOSE: it carries its own tsup entry and\n * `exports` subpath (`@flamingo-stack/openframe-frontend-core/utils/platform-identity`)\n * so hub SCRIPTS and `server-only` modules can import it without dragging React,\n * the icon components, or the utils barrel into their graph.\n *\n * TWO accepted by-construction copies of the colour decision remain, both LOCKED\n * by `src/__tests__/mlg-platform-leaves.test.ts` in this package:\n *   1. `platformHexColors` below (hand-typed hex mirror of each accent token).\n *   2. The `[data-app-type='…']` blocks in `src/styles/ods-colors.css`.\n */\n\nimport type { PlatformName } from '../types/platform';\n\n// ── Strings ─────────────────────────────────────────────────────────────────\n\n/** Human-readable platform names. THE naming source for lib-side presentation. */\nexport const platformDisplayNames = {\n  openmsp: 'OpenMSP',\n  openframe: 'OpenFrame',\n  flamingo: 'Flamingo',\n  'flamingo-teaser': 'Flamingo Teaser',\n  'marketing-hub': 'Flamingo Marketing Hub',\n  'product-hub': 'Flamingo Product Hub',\n  'revenue-hub': 'Flamingo Revenue Hub',\n  'people-hub': 'Flamingo People Hub',\n  'company-hub': 'Flamingo Company Hub',\n  tmcg: 'TMCG',\n  mlg: 'Major League GitHub',\n  universal: 'Universal',\n};\n\n/**\n * Short-name OVERRIDES only. A platform without a row falls back to its display\n * name, so this map never lists a name that equals `platformDisplayNames`.\n */\nexport const platformShortNames: Partial<Record<PlatformName, string>> = {\n  mlg: 'MLG',\n};\n\nexport const platformDescriptions = {\n  openmsp:\n    'Comprehensive directory and comparison platform for managed service providers (MSPs) and technology vendors. Reduce vendor costs and discover open-source alternatives.',\n  openframe: 'AI-driven open-source security operations center (SOC) and endpoint detection platform for MSPs.',\n  flamingo:\n    'AI-driven open-source OS for MSPs. Swap bloated vendor tools for open ones. Automate the boring crap. Take your margin back.',\n  'flamingo-teaser': 'Preview of Flamingo - the AI-driven open-source OS for MSPs.',\n  tmcg: 'The Miami Cyber Gang - A cybersecurity community focused on education and collaboration.',\n  mlg: 'Scouting report for US open-source talent. Rank GitHub contributors by programming language, city, state, region, and nearest Major League Soccer club.',\n  universal: 'Cross-platform universal content.',\n};\n\nexport const platformSlogans = {\n  openmsp: 'Find Your Perfect MSP Partner',\n  openframe: 'Open-Source Security Operations',\n  flamingo: 'Open-Source OS for MSPs',\n  'flamingo-teaser': 'Coming Soon: Open-Source OS for MSPs',\n  tmcg: 'Miami Cyber Community',\n  mlg: 'GitHub Scouting Report: Major League Edition',\n  universal: 'Universal Platform',\n};\n\nexport const platformIconNames = {\n  openmsp: 'openmsp-logo',\n  openframe: 'openframe-logo',\n  flamingo: 'flamingo-logo',\n  universal: 'globe',\n  'flamingo-teaser': 'flamingo-logo',\n  'marketing-hub': 'flamingo-logo',\n  'product-hub': 'flamingo-logo',\n  'revenue-hub': 'flamingo-logo',\n  'people-hub': 'flamingo-logo',\n  'company-hub': 'flamingo-logo',\n  tmcg: 'tmcg-logo',\n  mlg: 'mlg-logo',\n};\n\nexport function getPlatformDisplayName(platformName: string): string {\n  return platformDisplayNames[platformName as keyof typeof platformDisplayNames] || platformName;\n}\n\n/** Compact label (nav chips, manifest `short_name`, JSON-LD `alternateName`). */\nexport function getPlatformShortName(platformName: string): string {\n  return platformShortNames[platformName as PlatformName] ?? getPlatformDisplayName(platformName);\n}\n\nexport function getPlatformDescription(platformName: string): string {\n  return platformDescriptions[platformName as keyof typeof platformDescriptions] || platformName;\n}\n\nexport function getPlatformSlogan(platformName: string): string {\n  return platformSlogans[platformName as keyof typeof platformSlogans] || platformName;\n}\n\nexport function getDefaultIconForPlatform(platformName: string): string {\n  return platformIconNames[platformName as keyof typeof platformIconNames] || platformIconNames.universal;\n}\n\n// ── Colour stems ────────────────────────────────────────────────────────────\n\n/**\n * The six brand/attention colours (plus the neutral) a platform may adopt, named\n * by STEM rather than by token so the token spelling has exactly one home below.\n */\nexport type OdsColorStem =\n  'flamingo-pink' | 'flamingo-cyan' | 'open-yellow' | 'success' | 'warning' | 'error' | 'text-secondary';\n\n/** Stem → ODS token name (without the `--ods-` prefix). THE token spelling. */\nexport const ODS_STEM_TOKENS: Record<OdsColorStem, string> = {\n  'flamingo-pink': 'flamingo-pink-base',\n  'flamingo-cyan': 'flamingo-cyan-base',\n  'open-yellow': 'open-yellow-base',\n  success: 'attention-green-success',\n  warning: 'attention-yellow-warning',\n  error: 'attention-red-error',\n  'text-secondary': 'system-greys-grey',\n};\n\n/**\n * Stem → Tailwind class strings. STATIC LITERALS on purpose: the Tailwind\n * scanner reads source text, so a template-built class would be purged.\n * This is the ONLY place a stem-to-class literal exists.\n */\nexport const ODS_STEM_CLASSES: Record<OdsColorStem, { text: string; bg: string; bgSoft: string; borderSoft: string }> =\n  {\n    'flamingo-pink': {\n      text: 'text-ods-flamingo-pink',\n      bg: 'bg-ods-flamingo-pink',\n      bgSoft: 'bg-ods-flamingo-pink/10',\n      borderSoft: 'border-ods-flamingo-pink/30',\n    },\n    'flamingo-cyan': {\n      text: 'text-ods-flamingo-cyan',\n      bg: 'bg-ods-flamingo-cyan',\n      bgSoft: 'bg-ods-flamingo-cyan/10',\n      borderSoft: 'border-ods-flamingo-cyan/30',\n    },\n    'open-yellow': {\n      text: 'text-ods-open-yellow',\n      bg: 'bg-ods-open-yellow',\n      bgSoft: 'bg-ods-open-yellow/10',\n      borderSoft: 'border-ods-open-yellow/30',\n    },\n    success: {\n      text: 'text-ods-success',\n      bg: 'bg-ods-success',\n      bgSoft: 'bg-ods-success/10',\n      borderSoft: 'border-ods-success/30',\n    },\n    warning: {\n      text: 'text-ods-warning',\n      bg: 'bg-ods-warning',\n      bgSoft: 'bg-ods-warning/10',\n      borderSoft: 'border-ods-warning/30',\n    },\n    error: {\n      text: 'text-ods-error',\n      bg: 'bg-ods-error',\n      bgSoft: 'bg-ods-error/10',\n      borderSoft: 'border-ods-error/30',\n    },\n    'text-secondary': {\n      text: 'text-ods-text-secondary',\n      bg: 'bg-ods-text-secondary',\n      bgSoft: 'bg-ods-text-secondary/10',\n      borderSoft: 'border-ods-text-secondary/30',\n    },\n  };\n\n// ── Theme + surface ─────────────────────────────────────────────────────────\n\n/**\n * Every platform ships the dark theme today (the hub's flamingo config says so\n * explicitly, and every `[data-app-type]` block inherits the dark `:root`).\n * ONE constant instead of a per-platform field: reintroduce the field only when\n * a platform actually differs.\n */\nexport const PLATFORM_THEME = 'dark' as const;\n\n/** The dark surface's tokens, consumed by config `brandColors` and the manifest. */\nexport const PLATFORM_SURFACE = {\n  background: 'system-greys-background',\n  text: 'system-greys-white',\n} as const;\n\nexport const getPlatformBackgroundVarName = (): string => `--ods-${PLATFORM_SURFACE.background}`;\nexport const getPlatformTextVarName = (): string => `--ods-${PLATFORM_SURFACE.text}`;\n\n// ── Brand record ────────────────────────────────────────────────────────────\n\nexport interface PlatformBrand {\n  /** Primary brand colour (`--color-accent-primary` in the platform's CSS block). */\n  accentStem: OdsColorStem;\n  /** Link colour (`--color-link`). Equals `accentStem` for most platforms. */\n  secondaryStem: OdsColorStem;\n}\n\n/**\n * THE accent/link table. Every row is verified against that platform's\n * `[data-app-type='…']` block in `ods-colors.css` by the hub's parity test.\n */\nexport const PLATFORM_BRAND: Record<PlatformName, PlatformBrand> = {\n  openframe: { accentStem: 'open-yellow', secondaryStem: 'flamingo-cyan' },\n  openmsp: { accentStem: 'open-yellow', secondaryStem: 'open-yellow' },\n  flamingo: { accentStem: 'flamingo-pink', secondaryStem: 'flamingo-pink' },\n  'flamingo-teaser': { accentStem: 'flamingo-pink', secondaryStem: 'flamingo-pink' },\n  tmcg: { accentStem: 'flamingo-pink', secondaryStem: 'flamingo-pink' },\n  'marketing-hub': { accentStem: 'flamingo-pink', secondaryStem: 'flamingo-pink' },\n  'product-hub': { accentStem: 'success', secondaryStem: 'success' },\n  'revenue-hub': { accentStem: 'warning', secondaryStem: 'warning' },\n  'people-hub': { accentStem: 'flamingo-cyan', secondaryStem: 'flamingo-cyan' },\n  'company-hub': { accentStem: 'error', secondaryStem: 'error' },\n  mlg: { accentStem: 'flamingo-pink', secondaryStem: 'flamingo-cyan' },\n  universal: { accentStem: 'text-secondary', secondaryStem: 'text-secondary' },\n};\n\n/** The brand row for a platform, falling back to `universal` for anything unknown. */\nexport function getPlatformBrand(platformName: string): PlatformBrand {\n  return PLATFORM_BRAND[platformName as PlatformName] ?? PLATFORM_BRAND.universal;\n}\n\nexport function platformAccentToken(platformName: string): string {\n  return ODS_STEM_TOKENS[getPlatformBrand(platformName).accentStem];\n}\n\nexport function platformSecondaryToken(platformName: string): string {\n  return ODS_STEM_TOKENS[getPlatformBrand(platformName).secondaryStem];\n}\n\n/** `--ods-…` CSS variable NAME for a platform's accent (input to `resolveOdsColor`). */\nexport function platformAccentVarName(platformName: string): string {\n  return `--ods-${platformAccentToken(platformName)}`;\n}\n\nexport function platformSecondaryVarName(platformName: string): string {\n  return `--ods-${platformSecondaryToken(platformName)}`;\n}\n\n/** `var(--ods-…)` VALUE for a platform's accent (config `brandColors` data). */\nexport function getPlatformAccentColor(platformName: string): string {\n  return `var(${platformAccentVarName(platformName)})`;\n}\n\nexport function getPlatformSecondaryColor(platformName: string): string {\n  return `var(${platformSecondaryVarName(platformName)})`;\n}\n\n/** Tailwind classes for a platform, DERIVED from its stems. */\nexport function getPlatformBrandClasses(platformName: string): {\n  accentText: string;\n  accentBg: string;\n  accentBgSoft: string;\n  accentBorderSoft: string;\n  secondaryText: string;\n} {\n  const brand = getPlatformBrand(platformName);\n  const accent = ODS_STEM_CLASSES[brand.accentStem];\n  const secondary = ODS_STEM_CLASSES[brand.secondaryStem];\n  return {\n    accentText: accent.text,\n    accentBg: accent.bg,\n    accentBgSoft: accent.bgSoft,\n    accentBorderSoft: accent.borderSoft,\n    secondaryText: secondary.text,\n  };\n}\n\n/** Platform background classes, DERIVED (was a hand-typed hex map). */\nexport const platformColors: Record<PlatformName, string> = Object.fromEntries(\n  (Object.keys(PLATFORM_BRAND) as PlatformName[]).map(p => [p, getPlatformBrandClasses(p).accentBg]),\n) as Record<PlatformName, string>;\n\nexport function getPlatformColor(platformName: string) {\n  return platformColors[platformName as PlatformName] || platformColors.universal;\n}\n\n/**\n * Hand-typed hex mirror of each platform's accent token (the DB `default_color`\n * and other JS-value consumers). Accepted copy #1 — locked by\n * `src/__tests__/mlg-platform-leaves.test.ts` in this package, which asserts\n * every row against the `[data-app-type]` blocks in `ods-colors.css`.\n * (The hub has its OWN parity test, but it holds different copies: the asset\n * generator's map and the generated manifests.)\n */\nexport const platformHexColors: Record<PlatformName, string> = {\n  openmsp: '#ffc008',\n  openframe: '#ffc008',\n  flamingo: '#f357bb',\n  universal: '#888888',\n  'flamingo-teaser': '#f357bb',\n  'marketing-hub': '#f357bb',\n  'product-hub': '#5ea62e',\n  'revenue-hub': '#e1b32f',\n  'people-hub': '#5efaf0',\n  'company-hub': '#f36666',\n  tmcg: '#f357bb',\n  mlg: '#f357bb',\n};\n\nexport function getDefaultColorForPlatform(platformName: string): string {\n  return platformHexColors[platformName as PlatformName] || platformHexColors.universal;\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  // The exact `process.env.NEXT_PUBLIC_APP_TYPE` member expression is kept so\n  // Next/webpack can statically inline it. The try/catch makes the call safe\n  // in non-Next React hosts (Vite/CRA embeds) where `process` does not exist\n  // at runtime — those hosts get the 'openmsp' fallback, which is fine for\n  // embeds: dismissal cookies are domain-scoped and an embed domain serves\n  // one platform's announcements.\n  try {\n    return process.env.NEXT_PUBLIC_APP_TYPE || 'openmsp';\n  } catch {\n    return 'openmsp';\n  }\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>(options: LocalStorageAdapterOptions<T>): 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","'use client';\n\n/**\n * Client-side persistence for embed-surface proxy credentials (a\n * PLATFORM API KEY + 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 <platform API key>` + `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>. The key is minted in the hub's\n * `/admin/api-keys` and is platform-bound (`fpk_<platform>_…`): a\n * SERVICE key may act as any email; a PERSONAL key only as its owner.\n *\n * **Naming history:** the stored field is still named `secret` and the\n * wire-side header names are `X-Chat-*`. Those are client/server\n * contracts predating the per-platform key migration (the old shared\n * `CHAT_PROXY_SECRET` env is removed hub-side); renaming them would\n * break persisted state + the wire shape for zero behavior change. The\n * CLIENT-side helpers were renamed `Embed*` so non-chat surfaces (e.g.\n * ticket center) don't have to import a chat-prefixed symbol just to\n * 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, the key\n * is server-verified (hash-at-rest, platform-bound, revocable in\n * `/admin/api-keys`), and the act-as reach is bounded by the key's\n * tier. Explicit \"Clear\" button on the creds bar is the supported\n * 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 { getAppType } from './app-config';\nimport { createLocalStorageAdapter } from './local-storage-adapter';\n\n/**\n * Every OPTIONAL header of the chat-proxy contract, with the field it is stored\n * in: the ONE list storage, validation and `applyProxyAuth` all loop over, so a\n * new header is one row. `identity` rows are the acting user's display identity\n * (the hub threads them through `resolveChatProxyIdentity`); `visitor` rows are\n * the visitor context a gateway forwards (honoured hub-side only from a SERVICE\n * key). Empty or omitted = not sent.\n */\nexport const EMBED_PROXY_OPTIONAL_HEADERS = [\n  { field: 'firstName', group: 'identity', header: 'X-Chat-First-Name' },\n  { field: 'lastName', group: 'identity', header: 'X-Chat-Last-Name' },\n  { field: 'avatarUrl', group: 'identity', header: 'X-Chat-Avatar-Url' },\n  { field: 'originUrl', group: 'visitor', header: 'X-Chat-Origin-Url' },\n  { field: 'ip', group: 'visitor', header: 'X-Chat-Ip' },\n  { field: 'country', group: 'visitor', header: 'X-Chat-Country' },\n  { field: 'visitorId', group: 'visitor', header: 'X-Chat-User-Id' },\n] as const;\n\nexport type EmbedProxyOptionalField = (typeof EMBED_PROXY_OPTIONAL_HEADERS)[number]['field'];\n\nexport type EmbedProxyAuth = {\n  secret: string;\n  email: string;\n} & Partial<Record<EmbedProxyOptionalField, string>>;\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' ||\n    v.secret.trim().length === 0 ||\n    typeof v.email !== 'string' ||\n    v.email.trim().length === 0\n  )\n    return false;\n  // Optional fields: when present must be strings. Empty string is treated\n  // as absent later (in `getEmbedProxyAuth`).\n  return EMBED_PROXY_OPTIONAL_HEADERS.every(({ field }) => v[field] == null || typeof v[field] === 'string');\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/** Every optional field of `value`, trimmed, blank ones dropped. */\nfunction normalizedOptionalFields(value: Partial<Record<EmbedProxyOptionalField, string>>) {\n  const out: Partial<Record<EmbedProxyOptionalField, string>> = {};\n  for (const { field } of EMBED_PROXY_OPTIONAL_HEADERS) {\n    const normalized = normalizeOptional(value[field]);\n    if (normalized) out[field] = normalized;\n  }\n  return out;\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    ...normalizedOptionalFields(persisted),\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    ...normalizedOptionalFields(value),\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 headers — only attached when present so the server's\n  // \"required vs optional\" header shape stays exact.\n  for (const { field, header } of EMBED_PROXY_OPTIONAL_HEADERS) {\n    const value = auth?.[field];\n    if (value) headers[header] = value;\n  }\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   * Exact extra origins (`scheme://host[:port]`, as produced by `URL.origin`)\n   * the same-origin guard additionally accepts. The guard normally rejects\n   * every cross-origin URL in production — but native-shell hosts serve the\n   * page from a local pseudo-origin (`capacitor://localhost`,\n   * `tauri://localhost`) with NO server behind it, so the gateway their\n   * bearer already belongs to is unavoidably cross-origin. Listing it here\n   * is the host's explicit sanction to send the adapter's credentials there.\n   * Compared AFTER the http(s)-protocol check, so non-http(s) schemes can\n   * never be allowlisted. Omit (or leave empty) everywhere else — same-origin\n   * remains the rule, this is the narrow exception.\n   */\n  allowedOrigins?: string[];\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 * Whether `url` is an asset the browser CANNOT load natively because its\n * auth rides in request headers.\n *\n * Native asset loads (`<img src>`, `<track src>`, CSS `background-image`)\n * can't carry custom headers, so a URL this returns `true` for must go\n * through `embedAuthedFetch` → blob object-URL instead (see\n * `useAuthedAssetSrc` / `useAuthedImageSrc`).\n *\n * The single signal is the registered adapter: when it supplies an\n * `Authorization` header, the host authenticates by HEADER, so nothing the\n * browser fetches on its own is authenticated. That holds for BOTH shapes a\n * header-auth host takes:\n *\n *   - a cross-origin gateway URL — sanctioned via `allowedOrigins` (native\n *     shells, whose page origin is `capacitor://` / `tauri://`);\n *   - a same-origin / relative reverse-proxy path (`/content/api/...`) —\n *     dev-ticket web, where the token lives in localStorage and there is NO\n *     session cookie to fall back on. This case used to be excluded on the\n *     assumption that same-origin implies \"cookies work\"; true for a cookie\n *     session, false for every header-auth host, which is exactly when this\n *     predicate is consulted at all.\n *\n * Everything else loads natively, unchanged: cookie-auth web (the adapter\n * supplies no `Authorization`), no adapter at all (the hub), and third-party\n * origins the bearer does NOT belong to (public images) — those stay out of\n * reach of the token by the same origin rules `embedAuthedFetch` enforces.\n */\nexport function needsBearerAssetFetch(url: string): boolean {\n  if (typeof window === 'undefined') return false;\n  const adapter = getRegisteredAuthAdapter();\n  if (!adapter || adapter.getHeaders?.().Authorization === undefined) return false;\n  let target: URL;\n  let pageOrigin: string;\n  try {\n    target = new URL(url, window.location.href);\n    // Same reason `assertSameOrigin` derives it this way: test environments\n    // mock `window.location` as a plain object with no `origin` field.\n    pageOrigin = new URL(window.location.href).origin;\n  } catch {\n    return false;\n  }\n  if (target.protocol !== 'http:' && target.protocol !== 'https:') return false;\n  if (target.origin === pageOrigin) return true;\n  return adapter.allowedOrigins?.includes(target.origin) ?? false;\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 — or appears in the registered adapter's\n * `allowedOrigins` (the native-shell hatch; see that field's doc) — and\n * cross-origin URLs otherwise throw before the bearer leaves the page.\n * This is a defense-in-depth guard for future call sites — outside the\n * allowlisted-shell case there is no legitimate cross-origin use of this\n * 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);\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 Promise<boolean> | null | undefined) ??\n    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  // Bound and captured BEFORE the closure below. `refresh` is an optional\n  // property, so TypeScript drops the `if (!adapter?.refresh)` narrowing inside\n  // the `.then()` callback — the property could in principle be reassigned\n  // between the guard and the call. `bind` keeps the adapter as the receiver.\n  const refresh = adapter?.refresh?.bind(adapter);\n  if (!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(() => 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    // Host-sanctioned cross-origin target (`EmbedAuthAdapter.allowedOrigins`).\n    // Native shells serve the page from a local pseudo-origin with no server\n    // behind it, so their gateway — the same backend the host already trusts\n    // with this bearer — is unavoidably cross-origin. Exact `URL.origin`\n    // match, and only reachable for http(s) targets (checked above).\n    if (getRegisteredAuthAdapter()?.allowedOrigins?.includes(target.origin)) {\n      return;\n    }\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","'use client';\n\nimport { useEffect, useReducer } from 'react';\nimport { embedAuthedFetch, needsBearerAssetFetch } from '../utils/embed-authed-fetch';\n\n/**\n * Resolve ANY asset URL the browser would load natively — `<img src>`,\n * `<track src>`, a font, a poster — for hosts whose auth rides in request\n * HEADERS instead of cookies: native shells (`capacitor://`, `tauri://`) and\n * dev-ticket web, both in bearer mode. A native subresource load can't carry\n * an `Authorization` header, so a gateway URL that works on the cookie-auth\n * web 401s there.\n *\n * When `needsBearerAssetFetch` says the URL is bearer-authed, this hook\n * fetches it through `embedAuthedFetch` (bearer + deduped 401-refresh-retry +\n * the adapter's cross-origin guard — the SAME single auth knob every embedded\n * `fetch` in the lib rides) and returns a blob object-URL. Every other URL is\n * returned unchanged, so on the cookie-auth web the hook is a pass-through.\n *\n * Returns `undefined` while the fetch is in flight OR after it fails, so\n * callers show their existing placeholder / \"no captions\" branch instead of a\n * broken asset; a failed fetch retries on the next mount.\n *\n * Cache: module-level, session-lifetime, keyed by full URL — so the two\n * `<track>` URLs of one player, or the same avatar in twenty rows, cost one\n * request. Gateway URLs carry a `?v=<content-hash>` cache-buster, so changed\n * content is a new key; entries are never revoked (a VTT / avatar is a few KB\n * — refcount churn isn't worth it) and are dropped wholesale at session end\n * via `clearAuthedAssetCache`.\n */\n\nconst resolvedCache = new Map<string, string>();\nconst inFlight = new Map<string, Promise<void>>();\nlet cacheGeneration = 0;\n\n/**\n * Drop every cached blob and revoke its object URL. Hosts call this at\n * session end (logout / forced re-login) so a follow-on login as a\n * different identity cannot be served blobs fetched under the previous\n * one's bearer. Fetches still in flight when the clear happens are fenced\n * by a generation counter — their results are revoked instead of cached.\n */\nexport function clearAuthedAssetCache(): void {\n  cacheGeneration++;\n  for (const url of resolvedCache.values()) URL.revokeObjectURL(url);\n  resolvedCache.clear();\n  inFlight.clear();\n}\n\nfunction fetchAsBlobUrl(src: string, accept: string): Promise<void> {\n  let pending = inFlight.get(src);\n  if (!pending) {\n    const startedGeneration = cacheGeneration;\n    pending = embedAuthedFetch(src, { headers: { Accept: accept } })\n      .then(async response => {\n        if (!response.ok) throw new Error(`asset fetch failed: ${response.status}`);\n        const blobUrl = URL.createObjectURL(await response.blob());\n        if (startedGeneration === cacheGeneration) {\n          resolvedCache.set(src, blobUrl);\n        } else {\n          URL.revokeObjectURL(blobUrl);\n        }\n      })\n      .finally(() => {\n        if (inFlight.get(src) === pending) inFlight.delete(src);\n      });\n    inFlight.set(src, pending);\n  }\n  return pending;\n}\n\n/**\n * @param src    the asset URL (relative or absolute), or null/undefined\n * @param accept `Accept` header for the authed fetch — narrow it to what the\n *               consumer renders (`image/*`, `text/vtt`); it also replaces\n *               `embedAuthedFetch`'s default JSON `Content-Type` on the GET.\n */\nexport function useAuthedAssetSrc(src?: string | null, accept = '*/*'): string | undefined {\n  const bearerSrc = src && needsBearerAssetFetch(src) ? src : null;\n  const [, rerender] = useReducer((c: number) => c + 1, 0);\n\n  useEffect(() => {\n    if (!bearerSrc || resolvedCache.has(bearerSrc)) return undefined;\n    let cancelled = false;\n    fetchAsBlobUrl(bearerSrc, accept)\n      .catch(() => {})\n      .finally(() => {\n        if (!cancelled) rerender();\n      });\n    return () => {\n      cancelled = true;\n    };\n  }, [bearerSrc, accept]);\n\n  if (!src) return undefined;\n  if (!bearerSrc) return src;\n  return resolvedCache.get(bearerSrc);\n}\n","'use client';\n\nimport { clearAuthedAssetCache, useAuthedAssetSrc } from './use-authed-asset-src';\n\n/**\n * Image flavor of `useAuthedAssetSrc` — see that hook for the full contract.\n * Kept as its own export because it is the lib's most-used consumer (avatars,\n * entity images, markdown `<img>`) and because hosts already import this name.\n *\n * Distinct from the legacy `useAuthenticatedImage`, which ALWAYS blob-fetches\n * with `credentials: 'include'` and its own global config. This hook is\n * pass-through-first and keys off the single auth knob the lib already has:\n * the registered `EmbedAuthAdapter`.\n */\nexport function useAuthedImageSrc(src?: string | null): string | undefined {\n  return useAuthedAssetSrc(src, 'image/*');\n}\n\n/**\n * Session-end cache drop. Now an alias of `clearAuthedAssetCache` — one cache\n * backs every authed asset (images AND caption tracks), so hosts keep calling\n * this single function on logout / forced re-login.\n */\nexport const clearAuthedImageCache = clearAuthedAssetCache;\n","/**\n * Branded OG-placeholder URL construction — the DEFAULT cover-image fallback\n * for entity cards (onboarding guides, blog/case-study/release/etc.) that have\n * no image.\n *\n * ALL of the logic lives here, in the lib. A consumer hands over its runtime\n * `endpoints` object and NOTHING else — base resolution AND the `?title=…`\n * concatenation happen inside `buildOgPlaceholderUrl`. For the entity-card +\n * onboarding-detail surfaces this is the single entry point — no card builds an\n * og-placeholder URL itself (that was the bug this replaced: each embedder\n * wired a per-surface callback that concatenated the URL, and a host that\n * forgot it rendered a blank slot with no request). (Other server-side OG paths\n * such as the hub's blog og:image generator construct their own URLs and are\n * out of this module's scope.)\n *\n * The base API URL is taken from the endpoints the host already configures:\n *   1. explicit `endpoints.ogPlaceholderUrl`\n *   2. derived from the sibling `endpoints.imageProxyUrlPrefix` (same API base)\n *   3. same-origin relative `/api/og-placeholder`\n * The base may already carry pre-existing query params; they're preserved and\n * `title` (+ dimensions) are layered on top. Per-platform brand colors are NOT\n * baked into this URL — the `/api/og-placeholder` route resolves them\n * server-side from the platform. Most hosts leave `ogPlaceholderUrl` unset and\n * let the base derive from `imageProxyUrlPrefix`.\n */\n\n/** The slice of `ChatRuntime.endpoints` this module needs. */\nexport interface OgPlaceholderEndpoints {\n  /** Explicit base URL for the og-placeholder route. May already carry query\n   *  params — they're preserved. Per-platform colors are NOT baked here; the\n   *  route resolves them server-side from the platform. */\n  ogPlaceholderUrl?: string;\n  /** Sibling image route under the SAME API base. When `ogPlaceholderUrl` is\n   *  unset, the base is derived from this by swapping the trailing\n   *  `/image-proxy` segment for `/og-placeholder` — so a host that already\n   *  proxies images gets the placeholder for free, with zero extra wiring. */\n  imageProxyUrlPrefix?: string;\n}\n\nexport interface BuildOgPlaceholderOptions {\n  /** Site name shown under the title. Skipped when empty. */\n  site?: string;\n  /** `'wide'` (1200×630, the route default — no `w`/`h` emitted) or\n   *  `'square'` (1024×1024, for compact 56×56 chat-inline slots). */\n  aspect?: 'wide' | 'square';\n  /** Explicit pixel overrides (win over `aspect`). */\n  width?: number;\n  height?: number;\n}\n\n/** Same-origin default — for hosts that serve the route themselves (the hub).\n *  Cross-origin embedders override via `ogPlaceholderUrl` or inherit it from\n *  `imageProxyUrlPrefix`. */\nconst DEFAULT_OG_PLACEHOLDER_PATH = '/api/og-placeholder';\n\n/** Resolve the og-placeholder route base from the host's endpoints.\n *  Internal — callers go through `buildOgPlaceholderUrl(endpoints, …)`. */\nfunction resolveOgPlaceholderBase(endpoints?: OgPlaceholderEndpoints | null): string {\n  if (endpoints?.ogPlaceholderUrl) return endpoints.ogPlaceholderUrl;\n  const imageProxy = endpoints?.imageProxyUrlPrefix;\n  if (imageProxy) {\n    // `/image-proxy` and `/og-placeholder` are sibling API routes under one\n    // base. Anchor to a path-segment boundary so we only rewrite the route\n    // name, never an incidental substring.\n    const derived = imageProxy.replace(/\\/image-proxy(?=$|[?/])/, '/og-placeholder');\n    if (derived !== imageProxy) return derived;\n  }\n  return DEFAULT_OG_PLACEHOLDER_PATH;\n}\n\n/**\n * Build the branded og-placeholder image URL from the host's `endpoints` + a\n * title. This is the single entry point for entity-card + onboarding-detail\n * cover fallbacks: it resolves the route base from `endpoints` AND concatenates\n * `title` (+ dimensions), so those consumers never construct a URL themselves.\n *\n * Pure string construction — SSR- and browser-safe. Always returns a usable\n * URL (relative default at worst), so a missing/unknown image degrades\n * gracefully via the `<img onError>` recovery in the card components.\n */\nexport function buildOgPlaceholderUrl(\n  endpoints: OgPlaceholderEndpoints | null | undefined,\n  title: string,\n  options: BuildOgPlaceholderOptions = {},\n): string {\n  const base = resolveOgPlaceholderBase(endpoints);\n  const qIndex = base.indexOf('?');\n  const path = qIndex === -1 ? base : base.slice(0, qIndex);\n  const params = new URLSearchParams(qIndex === -1 ? '' : base.slice(qIndex + 1));\n\n  params.set('title', title);\n  if (options.site) params.set('site', options.site);\n\n  // Square aspect → request a 1024×1024 image so `object-cover` doesn't crop\n  // the title off in compact slots. Wide leaves dimensions to the route\n  // default (1200×630). Explicit width/height always win.\n  const width = options.width ?? (options.aspect === 'square' ? 1024 : undefined);\n  const height = options.height ?? (options.aspect === 'square' ? 1024 : undefined);\n  // `Number.isFinite` does not coerce, so it already rejects `undefined` — no\n  // separate `typeof === 'number'` guard needed.\n  if (Number.isFinite(width)) params.set('w', String(width));\n  if (Number.isFinite(height)) params.set('h', String(height));\n\n  return `${path}?${params.toString()}`;\n}\n","'use client';\n\nimport { useMemo } from 'react';\n\nimport { useChatRuntime } from '../contexts/chat-runtime-context';\nimport { buildOgPlaceholderUrl } from '../utils/og-placeholder';\n\n/**\n * Resolve a branded og-placeholder image URL for a title, driven entirely by\n * the runtime `endpoints` (no injected builder).\n *\n * THE one og-placeholder hook. It reads the host's `endpoints` from\n * `ChatRuntime` and hands them to `buildOgPlaceholderUrl`, which resolves the\n * route base (explicit `ogPlaceholderUrl` → derived from `imageProxyUrlPrefix`\n * → same-origin `/api/og-placeholder`) and appends `?title=…`. Per-platform\n * brand colors are resolved SERVER-SIDE by the route — nothing is baked here.\n *\n * Replaces the old builder-injection `useOgPlaceholder(buildUrl, …)`: callers\n * no longer pass a URL builder. `useEntityCardPlaceholder` delegates here too,\n * so every surface shares one memo + one code path.\n */\nexport interface UseOgPlaceholderUrlArgs {\n  /** Text to display on the placeholder. */\n  title: string | undefined | null;\n  /** Site name shown below the title (optional). */\n  siteName?: string;\n  /** `'wide'` (1200×630 social-card; default) or `'square'` (1024×1024 — for\n   *  compact chat-inline slots so `object-cover` doesn't crop the title off). */\n  aspect?: 'wide' | 'square';\n  /** When `false`, returns `null` instead of a URL. */\n  enabled?: boolean;\n}\n\nexport function useOgPlaceholderUrl({\n  title,\n  siteName = '',\n  aspect = 'wide',\n  enabled = true,\n}: UseOgPlaceholderUrlArgs): string | null {\n  const endpoints = useChatRuntime()?.endpoints;\n\n  return useMemo(() => {\n    if (!enabled || !title) return null;\n    return buildOgPlaceholderUrl(endpoints, title, { site: siteName || undefined, aspect });\n  }, [endpoints, title, siteName, aspect, enabled]);\n}\n"]}

package/dist/chunk-ZBQZJAC7.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/openframe-oss-lib/openframe-oss-lib/openframe-frontend-core/dist/chunk-ZBQZJAC7.cjs","../src/components/tickets/ticket-live-provider.tsx","../src/components/tickets/types.ts"],"names":[],"mappings":"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","file":"/home/runner/work/openframe-oss-lib/openframe-oss-lib/openframe-frontend-core/dist/chunk-ZBQZJAC7.cjs","sourcesContent":[null,"'use client';\n\n/**\n * TicketLiveProvider — the ONE client home for support-ticket realtime.\n *\n * DOMAIN logic only — connection lifecycle (subscribed-confirm, server\n * retry grace, failed-reconnect pacing, hidden-tab suspend/resume) is\n * owned entirely by the common SSE client (`createSseSubscription`);\n * this provider consumes its consolidated `onConnectedChange` signal.\n *\n * Owns:\n *   - the unread summary — delivered EXCLUSIVELY by the stream\n *     (`ticket-summary` frames on connect + debounced after events) and\n *     by `ticket-read` responses. The client holds NO summary fetch\n *     path: resync-on-(re)connect is served by the SERVER (every\n *     connect pushes a fresh summary);\n *   - query invalidation on events (list + open drawer refresh live);\n *   - `markRead` with local write-through zeroing for 0-latency,\n *     reconciled by the response's server-computed summary;\n *   - the ticket-contract `no-stream` (204) retry policy.\n *\n * There is NO polling anywhere and NO summary endpoint. Hosts whose\n * stream endpoint 404s (terminal) or is absent get no unread indication\n * — the indication IS a realtime feature.\n *\n * Invalidation semantics on events — deliberately `invalidateQueries`,\n * NOT `setQueryData` patches: the ticket hooks run `gcTime: 0`, so\n * there is usually no cache entry to patch, and `TicketsCacheSlot`\n * shape rules apply when there is.\n */\n\nimport { useQueryClient } from '@tanstack/react-query';\nimport React from 'react';\nimport { useChatRuntime } from '../../contexts/chat-runtime-context';\nimport { embedAuthedFetch } from '../../utils/embed-authed-fetch';\nimport { createSseSubscription, type SseSubscription, type SseTransportStatus } from '../../utils/sse-subscription';\nimport { useChatIdentity } from '../chat/hooks/use-chat-identity';\nimport type { TicketMessageStreamData, TicketStreamEvent, TicketUnreadSummary } from './types';\n\n// Ticket realtime is its OWN api surface — deliberately NOT under\n// `/api/chat/agent/*` (that prefix is the chat agent's tool surface;\n// ticket streaming/read-receipts are unrelated to chat).\nconst TICKET_STREAM_ENDPOINT = '/api/tickets/stream';\nconst TICKET_READ_ENDPOINT = '/api/tickets/read';\n\nconst EMPTY_SUMMARY: TicketUnreadSummary = { totalUnread: 0, tickets: {}, latestUnreadAt: {} };\n\n/** ISO stamps can carry mixed timezone offsets (server `+00:00` vs an\n *  optimistic local `Z`) — lexicographic string comparison mis-orders\n *  those, so every stamp comparison goes through parsed epoch ms.\n *  Missing/unparseable stamps sort oldest. */\nconst stampMs = (stamp: string | null | undefined): number => {\n  if (!stamp) return 0;\n  const ms = Date.parse(stamp);\n  return Number.isNaN(ms) ? 0 : ms;\n};\n\n/** Trailing debounce for event-burst invalidations (an agent pasting 5\n *  messages must not fire 5 list refetches). */\nconst INVALIDATE_DEBOUNCE_MS = 1_500;\n\nexport interface TicketLiveContextValue {\n  /** Viewer has a resolved, non-anon chat identity. Surfaces (e.g. the\n   *  header cell) hide themselves when false — computed here so they\n   *  don't each spin up their own identity resolution. */\n  authed: boolean;\n  /** Realtime-subscribed (server-confirmed), not merely HTTP-open. */\n  connected: boolean;\n  /** Unread total across tickets — drives the header count badge. */\n  unreadTotal: number;\n  /** Per-ticket unread counts (missing key = 0) — drives row dots.\n   *  The currently-open ticket is masked to 0. */\n  unreadByTicket: Record<string, number>;\n  /** The ticket with the NEWEST unread reply (open ticket excluded) —\n   *  the header cell routes to it via the SSOT deep link\n   *  (`buildTicketOpenHref`). Null when nothing is unread. */\n  nextUnreadTicketId: string | null;\n  /** Mark a ticket read: POSTs the receipt, zeroes the ticket locally\n   *  (0-latency), then applies the response's server-computed summary. */\n  markRead: (ticketExternalId: string) => Promise<void>;\n  /** Drawer open/close registration — suppresses unread bumps for the\n   *  open ticket and masks it in the derived map. */\n  setOpenTicketId: (ticketExternalId: string | null) => void;\n  /** Hint that the viewer just created a ticket — reconnects the stream\n   *  (fresh ownership set + fresh server-pushed summary). */\n  notifyTicketCreated: () => void;\n}\n\nconst TicketLiveContext = React.createContext<TicketLiveContextValue | null>(null);\n\nexport function useOptionalTicketLive(): TicketLiveContextValue | null {\n  return React.useContext(TicketLiveContext);\n}\n\nexport function useTicketLive(): TicketLiveContextValue {\n  const ctx = React.useContext(TicketLiveContext);\n  if (!ctx) {\n    throw new Error('useTicketLive must be used within <TicketLiveProvider>');\n  }\n  return ctx;\n}\n\nfunction isTicketMessageData(value: unknown): value is TicketMessageStreamData {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as TicketMessageStreamData).ticket_external_id === 'string'\n  );\n}\n\nfunction isSummaryData(value: unknown): value is TicketUnreadSummary {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as TicketUnreadSummary).totalUnread === 'number' &&\n    typeof (value as TicketUnreadSummary).tickets === 'object'\n  );\n}\n\nexport interface TicketLiveProviderProps {\n  children: React.ReactNode;\n  /**\n   * Whether ticket realtime is available to this host at all (feature flag,\n   * session, entitlement). `false` provides NO context — `useOptionalTicketLive()`\n   * reads `null`, `useTicketLive()` throws, and no identity or stream request is\n   * made: byte-for-byte what a host got by not mounting this at all.\n   *\n   * It exists so a host never has to mount this CONDITIONALLY. A host that writes\n   * `enabled ? <TicketLiveProvider>{children}</TicketLiveProvider> : <>{children}</>`\n   * changes the element TYPE at that position the moment its flag answers, and React\n   * tears down and remounts everything below. In openframe-frontend that wrapper sat\n   * around the whole `AppLayout`, so every cold load remounted the app shell and the\n   * page under it — visibly, as a chat drawer opened by a deep link replaying its\n   * open animation. Mount it always and pass the answer here instead.\n   *\n   * One consequence of mounting it always: a `ChatRuntime` must be above it even\n   * while disabled. The identity resolver reads one unconditionally (Rules of\n   * Hooks) and throws without it; `enabled` gates the request, not the read.\n   */\n  enabled?: boolean;\n}\n\nexport function TicketLiveProvider({ children, enabled = true }: TicketLiveProviderProps) {\n  const runtime = useChatRuntime();\n  const identity = useChatIdentity(enabled);\n  const queryClient = useQueryClient();\n\n  const streamUrl = runtime?.endpoints.ticketStreamUrl ?? TICKET_STREAM_ENDPOINT;\n  const readUrl = runtime?.endpoints.ticketReadUrl ?? TICKET_READ_ENDPOINT;\n\n  // Gates the stream below (via `streamEnabled`) as well as every surface that\n  // reads `authed` — one predicate, so a disabled provider is also a silent one.\n  const authed = enabled && identity.authTier !== 'anon' && !!identity.user?.email;\n\n  const [connected, setConnected] = React.useState(false);\n  // The SINGLE unread source — written ONLY from server-computed\n  // summaries (stream frames + markRead responses) plus the two\n  // 0-latency optimistic writes (event bump, markRead zero), both\n  // reconciled by the next server summary.\n  const [summary, setSummary] = React.useState<TicketUnreadSummary>(EMPTY_SUMMARY);\n  // State + ref for the open drawer: state drives the derived map,\n  // the ref lets stream callbacks read it without re-subscribing.\n  const [openTicketIdState, setOpenTicketIdState] = React.useState<string | null>(null);\n  const openTicketIdRef = React.useRef<string | null>(null);\n\n  // ---- Debounced (trailing) invalidation of ticket queries on events ----\n  const pendingTicketIdsRef = React.useRef<Set<string>>(new Set());\n  const invalidateTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);\n  const flushInvalidations = React.useCallback(() => {\n    invalidateTimerRef.current = null;\n    const ids = Array.from(pendingTicketIdsRef.current);\n    pendingTicketIdsRef.current.clear();\n    void queryClient.invalidateQueries({ queryKey: ['tickets'] });\n    for (const id of ids) {\n      void queryClient.invalidateQueries({ queryKey: ['ticket-engagements', id] });\n    }\n  }, [queryClient]);\n  const scheduleInvalidation = React.useCallback(\n    (ticketId?: string) => {\n      if (ticketId) pendingTicketIdsRef.current.add(ticketId);\n      if (invalidateTimerRef.current) return;\n      invalidateTimerRef.current = setTimeout(flushInvalidations, INVALIDATE_DEBOUNCE_MS);\n    },\n    [flushInvalidations],\n  );\n\n  // ---- Optimistic unread writes (reconciled by server summaries) ----\n  const bumpUnread = React.useCallback((ticketId: string, createdAt?: string | null) => {\n    setSummary(prev => {\n      const stamp = createdAt ?? new Date().toISOString();\n      const existing = prev.latestUnreadAt[ticketId];\n      return {\n        totalUnread: prev.totalUnread + 1,\n        tickets: { ...prev.tickets, [ticketId]: (prev.tickets[ticketId] ?? 0) + 1 },\n        latestUnreadAt: {\n          ...prev.latestUnreadAt,\n          [ticketId]: existing && stampMs(existing) > stampMs(stamp) ? existing : stamp,\n        },\n      };\n    });\n  }, []);\n\n  const zeroUnread = React.useCallback((ticketId: string) => {\n    setSummary(prev => {\n      const current = prev.tickets[ticketId] ?? 0;\n      if (current === 0) return prev;\n      const tickets = { ...prev.tickets };\n      delete tickets[ticketId];\n      const latestUnreadAt = { ...prev.latestUnreadAt };\n      delete latestUnreadAt[ticketId];\n      return { totalUnread: Math.max(0, prev.totalUnread - current), tickets, latestUnreadAt };\n    });\n  }, []);\n\n  // ---- Stream lifecycle (owned by the SSE CLIENT — the provider only\n  // consumes its consolidated signals) ----\n  const subscriptionRef = React.useRef<SseSubscription | null>(null);\n  const noStreamRef = React.useRef(false);\n\n  // Stable handler refs so the subscription effect doesn't churn.\n  const handlersRef = React.useRef<{\n    onEvent: (eventName: string, data: unknown) => void;\n    onStatus: (status: SseTransportStatus) => void;\n    onConnected: (connected: boolean) => void;\n  }>({ onEvent: () => {}, onStatus: () => {}, onConnected: () => {} });\n\n  const handleConnected = (isConnected: boolean) => {\n    setConnected(isConnected);\n    if (isConnected) {\n      // Event-gap healing on every (re)connect: the SERVER pushes a\n      // fresh summary; the open drawer refetches through the ACL'd path.\n      const openId = openTicketIdRef.current;\n      if (openId) {\n        void queryClient.invalidateQueries({ queryKey: ['ticket-engagements', openId] });\n      }\n    }\n  };\n\n  const handleEvent = (eventName: string, data: unknown) => {\n    if (eventName === 'ticket-summary') {\n      const frame = data as TicketStreamEvent | null;\n      if (isSummaryData(frame?.data)) {\n        setSummary({\n          totalUnread: frame.data.totalUnread,\n          tickets: frame.data.tickets ?? {},\n          latestUnreadAt: frame.data.latestUnreadAt ?? {},\n        });\n      }\n      return;\n    }\n\n    if (eventName === 'ticket-resync') {\n      // Ownership gained / degraded payload — a fresh ticket-summary\n      // frame follows from the server; refresh the query surfaces.\n      scheduleInvalidation();\n      return;\n    }\n\n    if (eventName === 'ticket-status') {\n      // Meaningful ticket-row change (close/reopen/pipeline move). The\n      // server pushes an updated summary right after (closures count as\n      // unread server-side); here we just refresh the query surfaces so\n      // the status badge flips live.\n      const frame = data as TicketStreamEvent | null;\n      const ticketId = (frame?.data as { ticket_external_id?: string } | undefined)?.ticket_external_id;\n      scheduleInvalidation(ticketId);\n      return;\n    }\n\n    if (eventName === 'ticket-message') {\n      const frame = data as TicketStreamEvent | null;\n      const payload = frame?.data;\n      if (!isTicketMessageData(payload)) {\n        scheduleInvalidation();\n        return;\n      }\n      // Always invalidate (own replies from another tab render live);\n      // bump unread ONLY on the server-stamped predicate, and never for\n      // the ticket whose drawer is open. The server's debounced summary\n      // push reconciles moments later.\n      scheduleInvalidation(payload.ticket_external_id);\n      if (payload.countsAsUnread && payload.ticket_external_id !== openTicketIdRef.current) {\n        bumpUnread(payload.ticket_external_id, payload.hubspot_created_at);\n      }\n    }\n  };\n\n  const handleStatus = (status: SseTransportStatus) => {\n    // The client owns connection lifecycle (confirm timeout, server\n    // retry grace, failed-reconnect pacing, hidden-suspend). The only\n    // transport status with DOMAIN meaning is the ticket contract's\n    // `no-stream` (204 = zero owned tickets): remember it so a domain\n    // signal (own create_ticket, window focus) can retry.\n    if (status === 'open') noStreamRef.current = false;\n    if (status === 'no-stream') noStreamRef.current = true;\n  };\n\n  // Publish the three handlers into the stable ref. In an unconditional effect\n  // rather than in the render body: every caller is an SSE transport callback,\n  // which can only fire after a commit, and a render attempt React discards\n  // must not be able to leave a handler behind that closes over state the user\n  // never saw. Declared BEFORE the subscription effect so it is filled first\n  // in the same flush.\n  React.useEffect(() => {\n    handlersRef.current.onConnected = handleConnected;\n    handlersRef.current.onEvent = handleEvent;\n    handlersRef.current.onStatus = handleStatus;\n  });\n\n  // Mount/unmount of the subscription — gated on auth + a usable URL.\n  const streamEnabled = authed && !!streamUrl;\n  React.useEffect(() => {\n    if (!streamEnabled) return undefined;\n    if (typeof window === 'undefined') return undefined;\n\n    subscriptionRef.current = createSseSubscription({\n      url: streamUrl,\n      onEvent: (name, data) => handlersRef.current.onEvent(name, data),\n      onStatusChange: status => handlersRef.current.onStatus(status),\n      onConnectedChange: isConnected => handlersRef.current.onConnected(isConnected),\n      // Long-lived per-user stream: suspend while hidden (scale relief),\n      // resume + reconnect on visible/online — all inside the client.\n      pauseWhenHidden: true,\n    });\n\n    const retryIfIdle = () => {\n      // After a 204 (no-stream), a focus signal is the retry trigger.\n      if (noStreamRef.current) {\n        noStreamRef.current = false;\n        subscriptionRef.current?.reconnectNow();\n      }\n    };\n    window.addEventListener('focus', retryIfIdle);\n\n    return () => {\n      window.removeEventListener('focus', retryIfIdle);\n      if (invalidateTimerRef.current) {\n        clearTimeout(invalidateTimerRef.current);\n        invalidateTimerRef.current = null;\n      }\n      subscriptionRef.current?.close();\n      subscriptionRef.current = null;\n      setConnected(false);\n      setSummary(EMPTY_SUMMARY);\n    };\n    // handlersRef is stable; streamUrl/auth changes remount the stream.\n  }, [streamEnabled, streamUrl]);\n\n  // ---- Public API ----\n  const markRead = React.useCallback(\n    async (ticketExternalId: string) => {\n      try {\n        const response = await embedAuthedFetch(readUrl, {\n          method: 'POST',\n          body: JSON.stringify({ ticket_id: ticketExternalId }),\n        });\n        if (!response.ok) return;\n        // 0-latency local zero, then reconcile with the response's\n        // server-computed summary (THE truth — includes closure\n        // accounting and other tickets).\n        zeroUnread(ticketExternalId);\n        const body = (await response.json().catch(() => null)) as { summary?: TicketUnreadSummary } | null;\n        if (isSummaryData(body?.summary)) {\n          setSummary({\n            totalUnread: body.summary.totalUnread,\n            tickets: body.summary.tickets ?? {},\n            latestUnreadAt: body.summary.latestUnreadAt ?? {},\n          });\n        }\n      } catch {\n        // Non-fatal — the receipt lands on the next markRead; unread\n        // state reconciles via the next server summary push.\n      }\n    },\n    [readUrl, zeroUnread],\n  );\n\n  const setOpenTicketId = React.useCallback((ticketExternalId: string | null) => {\n    openTicketIdRef.current = ticketExternalId;\n    setOpenTicketIdState(ticketExternalId);\n  }, []);\n\n  const notifyTicketCreated = React.useCallback(() => {\n    // Fresh connect → fresh ownership set + fresh server summary\n    // (covers both the no-stream 204 wait state and an already-live\n    // stream whose set predates the new ticket).\n    noStreamRef.current = false;\n    subscriptionRef.current?.reconnectNow();\n  }, []);\n\n  // Derived unread map — open ticket masked to 0 so a server summary\n  // landing inside the markRead debounce window can't transiently\n  // re-badge it.\n  const value = React.useMemo<TicketLiveContextValue>(() => {\n    let unreadByTicket = summary.tickets;\n    let unreadTotal = summary.totalUnread;\n    if (openTicketIdState && unreadByTicket[openTicketIdState]) {\n      const masked = unreadByTicket[openTicketIdState];\n      unreadByTicket = { ...unreadByTicket };\n      delete unreadByTicket[openTicketIdState];\n      unreadTotal = Math.max(0, unreadTotal - masked);\n    }\n    // Ticket with the NEWEST unread reply (compared as parsed epoch ms\n    // via `stampMs` — mixed timezone offsets break string ordering) —\n    // header cell routes there. Falls back to any unread key if a\n    // timestamp is missing.\n    let nextUnreadTicketId: string | null = null;\n    let nextStampMs = 0;\n    for (const id of Object.keys(unreadByTicket)) {\n      const ms = stampMs(summary.latestUnreadAt[id]);\n      if (nextUnreadTicketId === null || ms > nextStampMs) {\n        nextUnreadTicketId = id;\n        nextStampMs = ms;\n      }\n    }\n    return {\n      authed,\n      connected,\n      unreadTotal,\n      unreadByTicket,\n      nextUnreadTicketId,\n      markRead,\n      setOpenTicketId,\n      notifyTicketCreated,\n    };\n  }, [summary, authed, connected, openTicketIdState, markRead, setOpenTicketId, notifyTicketCreated]);\n\n  return <TicketLiveContext.Provider value={enabled ? value : null}>{children}</TicketLiveContext.Provider>;\n}\n","/**\n * Wire shape of a row returned by `POST /api/chat/agent/find-ticket`.\n * Mirrors the executor's projection at `lib/data/hubspot-tools.ts`\n * (`FIND_TICKET_SELECT` / `FindTicketResult`).\n *\n * Cross-repo duplication is INTENTIONAL: this lib ships independently\n * of the hub, so we can't import `FindTicketResult` from\n * `hubspot-tools.ts` directly. If the server adds a column to\n * `FIND_TICKET_SELECT`, also add it here. The smoke test in §F of the\n * plan covers the happy path; a wire-contract test belongs in the hub.\n *\n * `find-ticket` returns `customer_emails: string[]` (jsonb array), NOT\n * a single `customer_email`. The list is server-self-scoped to the\n * caller's session email; the array is exposed for admin/staff\n * surfaces, which the ticket center doesn't render.\n */\nexport interface TicketData {\n  id: string;\n  /** HubSpot ticket id (display number, e.g. \"1234\"). */\n  external_id: string;\n  subject: string | null;\n  /** Short (≤400 char) HTML-stripped preview of the ticket body —\n   *  used for the list-card subtitle when needed. */\n  preview: string | null;\n  /** Longer (≤4k char) sanitized body. INCLUDES every appended\n   *  `content_addendum` comment because the `update_ticket` executor\n   *  reads + re-writes the `content` property server-side with a\n   *  `---` separator. Render this in the drawer's description block\n   *  and the user sees both the original message + every comment they\n   *  (or staff) added. */\n  body: string | null;\n  /** Canonical OPEN | CLOSED (HubSpot pipeline derived). */\n  status: string | null;\n  /** Human label like \"New\" / \"Working on it\" / \"Waiting on contact\" /\n   *  \"Closed\". Drives the badge text; canonical status drives color. */\n  pipeline_stage_label: string | null;\n  clickup_task_id: string | null;\n  /** Snapshot of the linked ClickUp delivery task — populated server-side\n   *  via the `clickup_tasks` mirror when `clickup_task_id` is set. Drives\n   *  the \"Linked delivery\" card surface on the ticket drawer (status\n   *  badge + ClickUp deep link). `null` when no link OR the ClickUp row\n   *  was deleted / not yet synced. */\n  clickup: TicketClickupSummary | null;\n  priority: string | null;\n  customer_emails: string[];\n  customer_company: string | null;\n  /** HubSpot contact's display name. Drives the customer attribution\n   *  on the drawer when the viewer is NOT the customer themselves\n   *  (admin browsing / multi-contact second viewer). Conversations\n   *  API messages don't carry per-message sender info on Custom\n   *  Channels, so this is the only reliable source for \"what's the\n   *  customer's name.\" */\n  customer_name: string | null;\n  /** HubSpot owner id of the agent assigned to this ticket. Carried as\n   *  raw id for debugging; rendering goes through `assignedOwner`. Null\n   *  when unassigned. */\n  assigned_to: string | null;\n  /** Resolved assigned-owner profile — name + email + avatar. Populated\n   *  server-side via `attachOwnerProfiles` which joins through the\n   *  `hubspot_owners` mirror to `profiles` by email. Drives the\n   *  \"Assigned to\" attribution in the drawer header. Null when\n   *  unassigned OR the owner couldn't be resolved (rare — only when\n   *  the agent was deleted from HubSpot between the ticket update and\n   *  the next owners reconcile). */\n  assignedOwner: TicketAssignedOwner | null;\n  hubspot_updated_at: string;\n}\n\n/** Resolved profile of a ticket's assigned agent — surfaced in the\n *  drawer header. Subset of the server's `MirroredOwnerProfile`\n *  trimmed to just the rendering fields. */\nexport interface TicketAssignedOwner {\n  name: string | null;\n  email: string | null;\n  avatarUrl: string | null;\n}\n\n/** Compact projection of a linked ClickUp task — matches the server's\n *  `ClickupSummary` and aligns with `DeliveryItem` so the linked-card\n *  on a ticket can render through the same `DeliveryRow` primitive used\n *  on `/bug-fixes-and-enhancements`. */\nexport interface TicketClickupSummary {\n  /** ClickUp task external_id (e.g. \"86ad4e022\"). Used as the\n   *  `?focus=<id>` URL param to scroll the public delivery page to\n   *  this row. */\n  external_id: string;\n  title: string | null;\n  description: string | null;\n  /** ClickUp status name — e.g. \"complete\" / \"working\" / \"design approved\"\n   *  / \"waiting for release\". Used as the badge label. */\n  status: string | null;\n  /** ClickUp's per-status hex color (e.g. \"#008844\"). Forwarded to the\n   *  badge so colors match the ClickUp board exactly. */\n  status_color: string | null;\n  /** Bucket — `'backlog' | 'working' | 'complete' | 'unknown'`. Used as\n   *  a fallback when status_color is missing. */\n  status_category: string | null;\n  /** ClickUp custom item label (`'Bug'` / `'Request'`) — drives the\n   *  type badge (\"BUG-FIX\" / \"ENHANCEMENT\"). */\n  task_type: string | null;\n  custom_item_id: number | null;\n  /** Every ClickUp list the task is associated with. UI joins with \", \". */\n  list_names: string[];\n  /** Unix-ms timestamps so the row's \"ACTIVE X ago\" subtitle uses the\n   *  shared `getRelativeTime()` helper. */\n  date_opened: number | null;\n  date_updated: number | null;\n  date_closed: number | null;\n  /** Direct https://app.clickup.com/t/<id> deep link. Kept on the wire\n   *  for admin surfaces; the customer-facing linked card navigates\n   *  internally instead. */\n  clickup_url: string | null;\n  /** Composed server-side via the SAME `buildDevSectionUrl` helper the\n   *  chat-inline delivery card uses. Carries `?search=<id>` so the\n   *  delivery list filters to that single task on landing. */\n  delivery_href: string;\n  /** Target platform name for the host's `useNavLink` to decide\n   *  same-tab vs new-tab on cross-platform links. */\n  delivery_target_platform: string;\n  /** Release version label set by the delivery team, e.g. \"0.9\" / \"1.0\".\n   *  Shown beside the status when present. */\n  target_version: string | null;\n}\n\n/**\n * Optimistic placeholder a `submitTicket` call prepends to the list\n * BEFORE the server roundtrip resolves. Drawer is hidden until the\n * real id arrives. The wrapper destructures `_optimistic` before\n * forwarding to `<ChatTicketItem>` so the DOM doesn't see an unknown\n * prop.\n */\nexport interface OptimisticTicket extends TicketData {\n  _optimistic: true;\n}\n\nexport type AnyTicket = TicketData | OptimisticTicket;\n\nexport function isOptimistic(t: AnyTicket): t is OptimisticTicket {\n  return (t as OptimisticTicket)._optimistic === true;\n}\n\n/**\n * Shape of a single `['tickets', …]` TanStack-Query cache slot.\n * Mirrors `FindTicketResponse` in `hooks/use-tickets-list.ts` — kept\n * here because the cache-mutation call sites in `useTicketActions` and\n * `<HelpCenterList>` would otherwise have to redeclare the shape inline.\n *\n * A 2026-05-29 prod regression (`t.map is not a function` on\n * close/reopen) was caused by assuming the cache held a bare\n * `TicketData[]` instead of this wrapper — every helper that calls\n * `queryClient.setQueriesData` / `getQueriesData` on `['tickets']`\n * MUST type the value through this shape and project / reassemble\n * `tickets` explicitly.\n */\nexport interface TicketsCacheSlot {\n  tickets?: TicketData[];\n  count?: number;\n  totalCount?: number;\n  page?: number;\n  pageSize?: number;\n  totalPages?: number;\n  scope?: 'self' | 'all';\n}\n\n/**\n * Stable server-side error codes the ticket-action helpers route\n * through `mapTicketActionError`. Anything else is treated as a generic\n * server error.\n *\n * Reply-specific codes (`HUBSPOT_5XX` / `HUBSPOT_400_VALIDATION` /\n * `HUBSPOT_404_THREAD` / `HUBSPOT_REPLY_UNKNOWN`) drive the drawer\n * banner that appears above the composer when a customer reply fails.\n * Distinct from `HUBSPOT_DISCONNECTED` (whole-system) and\n * `TICKET_NOT_FOUND` (terminal-row) — the reply codes are per-attempt\n * + retryable except for `HUBSPOT_404_THREAD`.\n */\nexport type TicketActionErrorCode =\n  | 'PROPOSAL_NOT_CLAIMABLE'\n  | 'TICKET_NOT_FOUND'\n  | 'TICKET_OWNERSHIP_DENIED'\n  | 'HUBSPOT_DISCONNECTED'\n  | 'RATE_LIMITED'\n  | 'INVALID_TOOL_ARGS'\n  | 'HUBSPOT_5XX'\n  | 'HUBSPOT_400_VALIDATION'\n  | 'HUBSPOT_404_THREAD'\n  | 'HUBSPOT_REPLY_UNKNOWN'\n  | 'UNKNOWN';\n\nexport interface MappedTicketActionError {\n  code: TicketActionErrorCode;\n  /** Human-readable copy safe to show in a toast. */\n  message: string;\n  /** When true, the form should disable submit + show the\n   *  support-down banner. Set only for HUBSPOT_DISCONNECTED. */\n  supportSystemDown: boolean;\n  /** When true, the helper should remove the affected row optimistically\n   *  (TICKET_NOT_FOUND). */\n  removeRowFromCache: boolean;\n  /** Retry hint surfaced from a 429 response. Caller decides whether\n   *  to mention it in the toast. */\n  retryAfterSeconds?: number;\n}\n\n/**\n * Defensive client-side cap on ticket text (initial content + comment\n * addendums). HubSpot Note engagements accept more, but a 100KB paste\n * should fail fast at the UI rather than burning a server round-trip.\n * Both the open-ticket form and the per-row comment textarea import\n * this so a future server-side hardening only touches one place.\n */\nexport const TICKET_TEXT_MAX_CHARS = 5000;\n\n/**\n * Wire contract of the ticket live stream (`GET /api/chat/agent/\n * ticket-stream`, SSE). Producer (the hub route's `mapEvent`) imports\n * THIS type — same producer/consumer SSOT pattern as\n * `ConversationEngagementWire = TicketEngagement`. A schema drift here\n * would be a silent serialization bug; keep one named contract.\n *\n * Frames carry METADATA ONLY — never message bodies. Content is always\n * refetched through the ACL'd `list-engagements` path (one read path).\n *\n * Event names (`eventType`):\n *   - `ticket-message` — a message row landed in the mirror for one of\n *     the viewer's tickets. `data` carries the metadata.\n *   - `ticket-status`  — a MEANINGFUL ticket-row change (status /\n *     pipeline stage / closure) landed in the mirror. Server-side\n *     old-vs-new diffing drops no-op writes (sync stamps). Clients\n *     invalidate + refetch the summary (closures count as unread\n *     server-side via `closed_at` vs the read receipt).\n *   - `ticket-summary` — the server-computed `TicketUnreadSummary`.\n *     THE stream is the summary webservice: pushed on connect (server-\n *     side resync-on-reconnect) and re-pushed (debounced) after every\n *     delivered event. Clients hold NO summary fetch path.\n *   - `ticket-resync`  — degraded frame: something happened that the\n *     server couldn't fully describe (truncated Realtime payload, or\n *     the connection's ownership set just gained tickets). A fresh\n *     `ticket-summary` follows it; clients invalidate queries.\n *\n * The server also emits `status` frames (`subscribed` / `retrying` /\n * `reconnect_failed`) from the shared SSE utility — clients derive\n * `connected` from those, NOT from the HTTP stream being open.\n */\nexport type TicketStreamEventType = 'ticket-message' | 'ticket-status' | 'ticket-summary' | 'ticket-resync';\n\n/** Metadata payload of a `ticket-message` frame. */\nexport type TicketMessageStreamData = {\n  ticket_external_id: string;\n  /** Mirror row's HubSpot message id. */\n  message_id: string;\n  /** Server-stamped via the same direction predicate the wire mapper\n   *  uses. Clients never re-derive author classification. */\n  authorRole: 'customer' | 'support';\n  /** Server-stamped via the visibility+direction unread predicate\n   *  (`countsAsUnread` in the hub's conversations DAL). ONLY frames\n   *  with `true` may bump client-side unread state. */\n  countsAsUnread: boolean;\n  hubspot_created_at: string | null;\n};\n\n/** Metadata payload of a `ticket-status` frame. */\nexport type TicketStatusStreamData = {\n  ticket_external_id: string;\n  /** Canonical OPEN | CLOSED after the change. */\n  status: string | null;\n  pipeline_stage_label: string | null;\n  closed_at: string | null;\n};\n\nexport interface TicketStreamEvent {\n  eventType: TicketStreamEventType;\n  /** Human-readable label (SSE envelope compat) — clients ignore it. */\n  message: string;\n  /** `ticket-message` → TicketMessageStreamData; `ticket-status` →\n   *  TicketStatusStreamData; `ticket-summary` → TicketUnreadSummary;\n   *  absent on `ticket-resync`. */\n  data?: TicketMessageStreamData | TicketStatusStreamData | TicketUnreadSummary;\n}\n\n/**\n * The SINGLE unread source, delivered EXCLUSIVELY over the stream\n * (`ticket-summary` frames on connect + after events) and in\n * `ticket-read` responses. There is no summary fetch endpoint. Header\n * badge total AND per-row dots both read this via the\n * `TicketLiveProvider` map; missing keys mean 0.\n */\nexport type TicketUnreadSummary = {\n  totalUnread: number;\n  tickets: Record<string, number>;\n  /** ISO timestamp of the NEWEST unread message per ticket (same keys as\n   *  `tickets`). Drives \"route to the most recent update\" on the header\n   *  cell: the ticket with the max value here is `nextUnreadTicketId`. */\n  latestUnreadAt: Record<string, string>;\n};\n\n/**\n * Trailing debounce for `markRead` while the drawer is open and new\n * messages stream in — flushed on drawer close so a fast open/close\n * still persists the receipt. Named beside its sibling cadences so\n * every timing knob lives in one file.\n */\nexport const TICKET_MARK_READ_DEBOUNCE_MS = 2000;\n\n/**\n * Ticket deep-link SSOT — DEFINED in the server-safe param-keys module\n * (`utils/dev-sections/dev-section-param-keys.ts`, beside its sibling\n * `devSectionAnchorId`) because producers span both worlds: the hub's\n * SERVER-side chat-ref builder and the client header cell. Re-exported\n * here so ticket-surface consumers keep one import home.\n */\nexport { TICKET_OPEN_PARAM, buildTicketOpenHref } from '../../utils/dev-sections/dev-section-param-keys';\n\n/**\n * Centralized toast copy. Keep all wording here so QA / localization\n * can find every user-visible string in one file.\n */\nexport const TOAST_COPY = {\n  open_success: { title: 'Ticket opened', description: 'We received your message and will follow up shortly.' },\n  open_mirror_pending: { title: 'Ticket opened', description: 'Syncing — your ticket will appear momentarily.' },\n  close_success: { title: 'Ticket closed' },\n  reopen_success: { title: 'Ticket reopened' },\n  comment_success: { title: 'Comment added' },\n  attach_success: { title: 'Files attached' },\n  // Failure variants are constructed dynamically from MappedTicketActionError.\n} as const;\n"]}