@flamingo-stack/openframe-frontend-core 0.0.577 → 0.0.578-1950.5326.1

package/src/components/chat/utils/index.ts

@@ -59,7 +59,7 @@ export {
   resolveExternalNavigation,
   type ExternalNavResolution,
 } from './chat-nav-resolution';
-export { handleChatNavClick, type ChatNavClickInput } from './nav-click-handler';
+export { handleChatNavClick, type ChatNavClickInput } from './execute-navigation';
 // The unified navigation-execution primitive — single source of truth for
 // new-tab/same-tab + internal/external + embed/host + the runtime→router→window
 // fallback. Every surface routes through it (handleChatNavClick is now a wrapper).

package/src/components/chat/utils/nav-anchor-props.ts

@@ -33,11 +33,13 @@ import { decideNewTab as libDecideNewTab } from './decide-new-tab';
 /** An ABSOLUTE `http(s)` URL on the current page's origin. Relative hrefs return
  *  false (in embed mode they're hub-relative, not in-app), as do cross-origin
  *  and non-http URLs. SSR-safe: no `window` → false. */
-function isSameOriginAbsoluteHref(href: string): boolean {
+export function isSameOriginAbsoluteHref(href: string): boolean {
   if (typeof window === 'undefined') return false;
   if (!/^https?:\/\//i.test(href)) return false;
   try {
-    return new URL(href).origin === window.location.origin;
+    // Origin off `location.href`, not `location.origin`: jsdom leaves the latter
+    // undefined, which reads as "every URL is foreign" under test.
+    return new URL(href).origin === new URL(window.location.href).origin;
   } catch {
     return false;
   }

package/src/components/chat/utils/resolve-fetched-card-href.ts

@@ -31,7 +31,7 @@
  * Pure — no React, no DOM. The caller owns `safeHref` validation.
  */
 
-import type { ComposeContentUrl } from '../../../utils/content-href';
+import type { ComposeContentUrl, ComposedContentUrl } from '../../../utils/content-href';
 import { canonicalContentRefType } from '../../../utils/list-url';
 
 export interface FetchedCardHrefInput {
@@ -90,12 +90,60 @@ function readPlatforms(item: unknown, canonicalType: string): Array<{ name?: str
  * when the host wired no seam (the caller then keeps the card unlinked, which
  * is the pre-existing behavior).
  */
+/**
+ * Where a fetch-mode card's destination came from. The loader needs the source,
+ * not just the string: only the `item` branch must leave the ref's own
+ * `targetPlatform` untouched.
+ */
+export type FetchedCardHrefChoice =
+  | { source: 'hostOverride'; href: string; targetPlatform: string | null }
+  | { source: 'item'; href: string; targetPlatform?: undefined }
+  | { source: 'composed'; href: string; targetPlatform: string | null };
+
+/**
+ * Decide a fetched card's destination between the two producers that can claim
+ * it. Pure, so the precedence is testable on its own — it used to live as
+ * inline ternaries in `ChatCardLoader`.
+ *
+ *   1. an EXPLICIT host override — the host said where this type lives in its
+ *      own app, which beats everything;
+ *   2. the fetched row's own url (`registry.fallbackHref`) — minted by the
+ *      content host for ITS surface, authoritative in the absence of (1);
+ *   3. the composer's synthesized href, unless the registry opted out
+ *      (`noComposedHref`) because the synthesis would be a 404.
+ *
+ * (2) beating (3) is why `noComposedHref` exists; (1) beating (2) is what keeps
+ * a re-homed type (an embedder serving hub tickets under `/help-center/tickets`)
+ * from following the content host's path into an unrelated route of its own.
+ */
+export function pickFetchedCardHref({
+  composed,
+  itemHref,
+  allowComposed,
+}: {
+  /** Result of {@link resolveFetchedCardHref}, or null when unresolvable. */
+  composed: ComposedContentUrl | null;
+  /** `registry.fallbackHref(item)` — the fetched row's own destination. */
+  itemHref: string | null;
+  /** False for registry entries flagged `noComposedHref`. */
+  allowComposed: boolean;
+}): FetchedCardHrefChoice | null {
+  if (composed?.hostOverride) {
+    return { source: 'hostOverride', href: composed.href, targetPlatform: composed.targetPlatform };
+  }
+  if (itemHref) return { source: 'item', href: itemHref };
+  if (composed && allowComposed) {
+    return { source: 'composed', href: composed.href, targetPlatform: composed.targetPlatform };
+  }
+  return null;
+}
+
 export function resolveFetchedCardHref({
   contentRefType,
   id,
   item,
   composeContentUrl,
-}: FetchedCardHrefInput): { href: string; targetPlatform: string | null } | null {
+}: FetchedCardHrefInput): ComposedContentUrl | null {
   if (!composeContentUrl || !contentRefType || !id) return null;
   const canonicalType = canonicalContentRefType(contentRefType);
   return composeContentUrl({

package/src/utils/.content-href.md

@@ -15,7 +15,7 @@ Unified content-href authority for all embeddable surfaces — resolves content
 
 ### Functions
 
-- **`makeComposeContentUrl(opts)`** — Factory that builds the embedder's `composeContentUrl`. Resolution order: explicit `overrides` → hosted in-app route → verbatim `externalUrl` → hub-origin fallback.
+- **`makeComposeContentUrl(opts)`** — Factory that builds the embedder's `composeContentUrl`. Resolution order: explicit `overrides` → hosted in-app route → verbatim `externalUrl` → hub-origin fallback. Only the `overrides` branch returns `hostOverride: true`; fetch-mode chat cards rank that above the fetched row's own url (`pickFetchedCardHref`), and everything else below it.
 - **`buildDefaultHref(basePath, slug)`** — Fallback href when no `composeContentUrl` is wired (single-platform embedders).
 - **`resolveContentHref(composeContentUrl, args)`** — Ternary helper used by catalog/detail views: delegates to `composeContentUrl` when wired, otherwise calls `buildDefaultHref`.
 

package/src/utils/__tests__/content-href.test.ts

@@ -188,6 +188,9 @@ describe('makeComposeContentUrl (unified single-object seam)', () => {
     expect(c({ type: 'product_release', identifier: 'v2', externalUrl: `${HUB}/releases/v2` })).toEqual({
       href: '/custom/v2',
       targetPlatform: 'openframe',
+      // Only this branch is flagged — fetch-mode cards rank it above the
+      // fetched row's own url (`pickFetchedCardHref`).
+      hostOverride: true,
     });
   });
 

package/src/utils/content-href.ts

@@ -112,10 +112,34 @@ export interface ContentHrefOptions {
   overrides?: Record<string, (identifier: string) => { href: string; targetPlatform: string | null }>;
 }
 
+/** What the seam resolves a content reference to. */
+export interface ComposedContentUrl {
+  href: string;
+  targetPlatform: string | null;
+  /**
+   * Set ONLY when the href came from the host's EXPLICIT per-type `overrides`
+   * entry — i.e. the host stated where this type lives in ITS app, rather than
+   * the composer falling through to a hosted-suffix or `<origin>/<type>/<id>`
+   * synthesis.
+   *
+   * The distinction is load-bearing for fetch-mode chat cards whose fetched row
+   * already carries a destination (`refHydratedEntry`'s `item.url`, minted by
+   * the CONTENT HOST for its OWN surface). That url must beat a synthesized
+   * guess, but must NOT beat a host that has explicitly re-homed the type:
+   * a HubSpot ticket's `item.url` is the hub's `/tickets?ticket=…`, which in an
+   * embedder that serves the same ticket at `/help-center/tickets` silently
+   * resolves against the embedder's own unrelated `/tickets` route.
+   *
+   * Optional and absent by default, so a hand-written composer (the hub's
+   * cross-platform one) keeps the pre-existing "row url wins" behavior.
+   */
+  hostOverride?: boolean;
+}
+
 /** The unified `composeContentUrl` seam shape on `ChatRuntime`. ALWAYS returns
  *  a tuple (never null) — the seam type is non-nullable and callers read
  *  `.href` unconditionally. */
-export type ComposeContentUrl = (input: ComposeContentUrlInput) => { href: string; targetPlatform: string | null };
+export type ComposeContentUrl = (input: ComposeContentUrlInput) => ComposedContentUrl;
 
 /**
  * Owning platform of a content row, from the hydrated junction the list APIs
@@ -162,7 +186,8 @@ function lastPathSegment(url: string): string | null {
  * Build the embedder's `composeContentUrl` for the unified seam.
  *
  * Resolution order (the merged rule used by BOTH page views and chat cards):
- *   1. `overrides[type]` — explicit per-type href.
+ *   1. `overrides[type]` — explicit per-type href, returned with
+ *      `hostOverride: true` (the only branch that sets it).
  *   2. `hostedTypes.has(type)` → relative `/<suffix>/<slug>` (in-app, soft-nav).
  *      Chat rows carry the hub URL not the slug, so the slug is recovered from
  *      `externalUrl`; page views pass the slug as `identifier`.
@@ -184,7 +209,9 @@ export function makeComposeContentUrl(opts: ContentHrefOptions): ComposeContentU
     const type = canonicalContentRefType(rawType);
     const override =
       opts.overrides && Object.prototype.hasOwnProperty.call(opts.overrides, type) ? opts.overrides[type] : undefined;
-    if (override) return override(identifier);
+    // Flagged as an explicit host decision — see `ComposedContentUrl.hostOverride`
+    // for why a fetch-mode card has to tell this apart from the branches below.
+    if (override) return { ...override(identifier), hostOverride: true };
 
     const seg = (Object.prototype.hasOwnProperty.call(suffixes, type) ? suffixes[type] : undefined) ?? type;
 

package/src/utils/index.ts

@@ -340,6 +340,7 @@ export {
   buildDefaultHref,
   type ContentHrefOptions,
   type ComposeContentUrl,
+  type ComposedContentUrl,
 } from './content-href';
 
 // Invisible bot-protection signals (honeypot + timing) — pure + server-safe so