@flamingo-stack/openframe-frontend-core 0.0.699 → 0.0.700

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   SoftwareInfo,
   SoftwareSourceBadge,
   ToolBadge
-} from "./chunk-SWXXLZLZ.js";
+} from "./chunk-N7HMUQRV.js";
 import {
   AppHeader,
   AppLayout,
@@ -29,14 +29,14 @@ import {
   SlidingSidebar,
   TicketAlertsButton,
   TopNavigation
-} from "./chunk-KXRUQCHZ.js";
+} from "./chunk-PNWIVND4.js";
 import {
   MobileNavigationDropdown,
   MultiLevelNavigation,
   StickySectionNav,
   useSectionNavigation
-} from "./chunk-WYLVP5OC.js";
-import "./chunk-LGEGOCU7.js";
+} from "./chunk-DJLZXJYB.js";
+import "./chunk-S4ADN25W.js";
 import {
   AIEnrichButton,
   AIEnrichSection,
@@ -655,7 +655,7 @@ import {
   withFirstTouchAttribution,
   withWalkthroughOpenParam,
   writeDismissCookie
-} from "./chunk-U473T27Y.js";
+} from "./chunk-B7M6QEEM.js";
 import "./chunk-LQYXMEYF.js";
 import "./chunk-4JPLYOS6.js";
 import {
@@ -1131,6 +1131,7 @@ import {
   processHistoricalMessages,
   processHistoricalMessagesWithErrors,
   ratioToCategory,
+  readFetchedCardPath,
   readFetchedCardTitle,
   rebaseCaptionsUrl,
   recordCountLabel,
@@ -1139,6 +1140,7 @@ import {
   remarkMentionChips,
   renderChatInlineEntityCard,
   renderQuickActionIcon,
+  resolveCardDestination,
   resolveExternalNavigation,
   resolveFetchedCardHref,
   resolveIcon,
@@ -1188,7 +1190,7 @@ import {
   useVideoOriginPreconnect,
   useVideoWarmup,
   usesCanonicalStatusStyle
-} from "./chunk-Z6R7GE5L.js";
+} from "./chunk-6JPQDYYY.js";
 import {
   HEADING_EMOJI_RE,
   HUB_HEADER_OFFSET_PX,
@@ -3337,6 +3339,7 @@ export {
   progressColorByVariant,
   ratioToCategory,
   readDismissCookie,
+  readFetchedCardPath,
   readFetchedCardTitle,
   readLeadingDecisionFrame,
   rebaseCaptionsUrl,
@@ -3354,6 +3357,7 @@ export {
   renderTicketStatusOption,
   rescueCompletionPct,
   resolutionToStatus,
+  resolveCardDestination,
   resolveContentFetchPath,
   resolveExternalNavigation,
   resolveFetchedCardHref,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flamingo-stack/openframe-frontend-core",
-  "version": "0.0.699",
+  "version": "0.0.700",
   "description": "Shared design system and components for all Flamingo platforms",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/chat/entity-cards/dispatch.tsx

@@ -29,7 +29,8 @@
  *     fetch-mode entries.
  */
 
-import React, { type ReactNode } from 'react';
+import type React from 'react';
+import type { ReactNode } from 'react';
 import { useRequiredChatRuntime } from '../../../contexts/chat-runtime-context';
 import Image from '../../../embed-shims/next-image';
 import { useRouter } from '../../../embed-shims/next-navigation';
@@ -106,15 +107,15 @@ import type { PrReviewState, GitHubActivityKind } from '../types/entities/github
 import { formatInvestorUpdatePeriod } from '../types/entities/investor-update';
 import type { BaseProgramItem, ProgramConfig } from '../types/entities/program-types';
 import { getStatusColorScheme } from '../utils/agent-status-message';
+import { resolveCardDestination } from '../utils/card-destination';
 import { resolveHrefForRuntime } from '../utils/chat-nav-resolution';
-import { safeHref } from '../utils/compact-card-classes';
 import { executeNavigation } from '../utils/execute-navigation';
 import { clickupTaskUrl } from '../utils/external-app-urls';
 import { resolveIcon } from '../utils/icon-library';
 import { computeIsNewTab, buildAnchorProps } from '../utils/nav-anchor-props';
-import { resolveFetchedCardHref, pickFetchedCardHref, readFetchedCardTitle } from '../utils/resolve-fetched-card-href';
+import { readFetchedCardTitle } from '../utils/resolve-fetched-card-href';
 import { getSourceLabel } from '../utils/source-icons';
-import { resolveSourceRowCTA, resolveSourceIcon, sourceRowCtxFromRuntime } from '../utils/source-row-cta';
+import { resolveSourceIcon, sourceRowCtxFromRuntime } from '../utils/source-row-cta';
 import { BlockCard } from './block-card';
 import { BlogCardSkeleton } from './blog-card';
 import { CampaignCardAdminSkeleton } from './campaign-card-admin';
@@ -1629,7 +1630,8 @@ function roadmapRegistryEntries(): Record<string, ChatCardRegistryEntry> {
   }));
 }
 
-const CHAT_CARD_REGISTRY: Record<string, ChatCardRegistryEntry> = {
+/** Exported for the destination test, which walks every registered type. */
+export const CHAT_CARD_REGISTRY: Record<string, ChatCardRegistryEntry> = {
   // ───────── ref-shaped types: hydrated via /api/chat/entity-refs ─────────
   ...githubRegistryEntries(),
   // Generic TOMBSTONE for entities a chat action deleted (ClickUp task
@@ -2002,28 +2004,7 @@ export function ChatCardLoader({
   extras,
 }: ChatCardLoaderProps) {
   const runtime = useRequiredChatRuntime();
-  const resolvedChatRef = React.useMemo<ChatRef>(() => {
-    const cta = resolveSourceRowCTA(
-      {
-        sourceRepo: chatRef.sourceRepo,
-        documentType: chatRef.type,
-        id: chatRef.id,
-        title: chatRef.title,
-        externalUrl: chatRef.url,
-        targetPlatform: chatRef.targetPlatform,
-        path: typeof chatRef.metadata?.path === 'string' ? chatRef.metadata.path : null,
-      },
-      sourceRowCtxFromRuntime(runtime, { baseRoute, chipBasePlatform }),
-    );
-    const finalHref = cta.href ? resolveHrefForRuntime(cta.href, runtime) : null;
-    return {
-      ...chatRef,
-      url: finalHref ?? chatRef.url,
-      targetPlatform: cta.targetPlatform ?? chatRef.targetPlatform ?? null,
-    };
-  }, [chatRef, runtime, baseRoute, chipBasePlatform]);
-
-  const entry = CHAT_CARD_REGISTRY[resolvedChatRef.type];
+  const entry = CHAT_CARD_REGISTRY[chatRef.type];
   // Hook order MUST be stable across renders — call the data hook
   // unconditionally regardless of entry mode. For non-fetch types the
   // `contentRefType` is empty so the hook returns `isLoading=false` and
@@ -2031,55 +2012,30 @@ export function ChatCardLoader({
   const fetchEntry = entry && entry.contentRefType ? entry : null;
   const { item, isLoading, isError, isFetched } = useChatCardItem<ChatCardItem>(
     fetchEntry?.contentRefType ?? '',
-    fetchEntry ? resolvedChatRef.id : '',
+    fetchEntry ? chatRef.id : '',
   );
   if (!entry) return null;
 
-  // Apply the post-fetch URL fallback (the ref carried no `externalUrl`).
-  // We mutate `resolvedChatRef.url` BEFORE computing isNewTab so the
-  // wrapper's interceptor sees the destination the user will actually
-  // visit. `safeHref` blocks `javascript:` / `data:` payloads even
-  // though the registry callers compose hub-internal strings today.
-  //
-  // Two producers, ranked by `pickFetchedCardHref` (which owns the
-  // precedence and its rationale):
-  //   1. the registry's per-type `fallbackHref` — an explicit non-content
-  //      destination (marketing campaign → `/admin/...`, or a ref-hydrated
-  //      row's own `item.url`);
-  //   2. the host's `composeContentUrl` seam via `resolveFetchedCardHref` —
-  //      the SAME resolver page cards go through. This is what makes cards
-  //      clickable on every transport: the wire ships bare
-  //      `[card://type:id]` markers with no metadata, so the ref reaches
-  //      us with `url: null` and `resolveSourceRowCTA` has nothing to route.
-  // …except an EXPLICIT host override outranks both: the seam is asked
-  // even for `fallbackHref` / `noComposedHref` types now, and its answer is
-  // taken only when the host actually re-homed the type (never when the
-  // composer merely synthesized one) — the case those two flags guard against.
-  const composedHref =
-    fetchEntry?.contentRefType && !resolvedChatRef.url && item
-      ? resolveFetchedCardHref({
-          contentRefType: fetchEntry.contentRefType,
-          id: resolvedChatRef.id,
-          item,
-          composeContentUrl: runtime.composeContentUrl,
-        })
-      : null;
-  const hrefChoice =
-    fetchEntry && !resolvedChatRef.url && item
-      ? pickFetchedCardHref({
-          composed: composedHref,
-          itemHref: fetchEntry.fallbackHref?.(item) ?? null,
-          allowComposed: !fetchEntry.noComposedHref,
-        })
-      : null;
-  const hrefResolvedChatRef: ChatRef = hrefChoice
-    ? {
-        ...resolvedChatRef,
-        url: safeHref(hrefChoice.href),
-        // The `item` branch carries no platform of its own — keep the ref's.
-        targetPlatform: hrefChoice.targetPlatform ?? resolvedChatRef.targetPlatform ?? null,
-      }
-    : resolvedChatRef;
+  // THE card's destination, decided in one place (`resolveCardDestination`):
+  // the source chip's resolver with the row as far as it is known (the ref's
+  // fields, plus the fetched row's doc path when a bare `[card://type:id]`
+  // marker carried none), else the fetched row's own destination. Computed
+  // BEFORE `isNewTab` so the click wrapper sees the page the user will visit.
+  const destination = resolveCardDestination({
+    chatRef,
+    item: fetchEntry ? item : undefined,
+    entry: fetchEntry,
+    ctx: sourceRowCtxFromRuntime(runtime, { baseRoute, chipBasePlatform }),
+    composeContentUrl: runtime.composeContentUrl,
+    resolveHref: href => resolveHrefForRuntime(href, runtime),
+  });
+  const hrefResolvedChatRef: ChatRef = {
+    ...chatRef,
+    url: destination.url,
+    targetPlatform: destination.targetPlatform,
+    // The nav wrapper reads the path off the ref for in-app doc navigation.
+    ...(destination.path ? { metadata: { ...(chatRef.metadata ?? {}), path: destination.path } } : {}),
+  };
 
   // Title enrichment, same synthetic-ref gap as the href above: a Mingo
   // `[card://type:id]` marker produces `title: <id>` because the transport

package/src/components/chat/utils/card-destination.ts

@@ -0,0 +1,103 @@
+/**
+ * Where an inline chat card goes when clicked: THE one decision, pure.
+ *
+ * A card and the source chip for the same row must land on the same page. The
+ * chip always has its row (`externalUrl`, `path`); a card may arrive as a bare
+ * `[card://type:id]` marker and learn the rest only when its row loads. So the
+ * card asks the chip's resolver (`resolveSourceRowCTA`) with everything known
+ * at that moment, the marker's fields first and the fetched row's `path` when
+ * the marker had none, and falls back to the fetched row's own destination
+ * (`pickFetchedCardHref`) only when that resolver has nothing to route.
+ *
+ * `ChatCardLoader` calls this once per render; nothing else decides a card's
+ * href. No React, no DOM.
+ */
+
+import type { ComposeContentUrl } from '../../../utils/content-href';
+import type { ChatRef } from '../chat-ref.types';
+import { safeHref } from './compact-card-classes';
+import { pickFetchedCardHref, readFetchedCardPath, resolveFetchedCardHref } from './resolve-fetched-card-href';
+import { resolveSourceRowCTA, type SourceRowContext } from './source-row-cta';
+
+/** Which rule produced the destination (for tests and debugging). */
+export type CardDestinationSource = 'row' | 'hostOverride' | 'item' | 'composed' | 'none';
+
+export interface CardDestination {
+  url: string | null;
+  targetPlatform: string | null;
+  /** Doc-tree path, from the ref or the fetched row. The click router uses it for in-app doc navigation. */
+  path: string | null;
+  source: CardDestinationSource;
+}
+
+/** The routing fields of a card registry entry, generic over the row type the entry reads. */
+export interface CardDestinationEntry<Item> {
+  contentRefType?: string;
+  fallbackHref?: (item: Item) => string | null;
+  noComposedHref?: boolean;
+}
+
+export interface CardDestinationInput<Item = unknown> {
+  /** The ref the card was mounted with: a full ref, or a bare marker (`url: null`, no metadata). */
+  chatRef: ChatRef;
+  /** The row the card fetched; undefined while loading and for ref-only types. */
+  item?: Item;
+  /** The registry entry's routing fields. */
+  entry?: CardDestinationEntry<Item> | null;
+  /** `sourceRowCtxFromRuntime(runtime, surface)`, the same context a source chip is resolved with. */
+  ctx: SourceRowContext;
+  /** The host's content-href seam (`runtime.composeContentUrl`). */
+  composeContentUrl?: ComposeContentUrl;
+  /** Embed-mode origin prefix (`resolveHrefForRuntime`), applied to a row-resolved href. */
+  resolveHref?: (href: string) => string;
+}
+
+export function resolveCardDestination<Item = unknown>({
+  chatRef,
+  item,
+  entry,
+  ctx,
+  composeContentUrl,
+  resolveHref = href => href,
+}: CardDestinationInput<Item>): CardDestination {
+  const refPath = typeof chatRef.metadata?.path === 'string' && chatRef.metadata.path ? chatRef.metadata.path : null;
+  const path = refPath ?? (item ? readFetchedCardPath(item) : null);
+
+  // 1. The chip's resolver, with the row as far as it is known.
+  const cta = resolveSourceRowCTA(
+    {
+      sourceRepo: chatRef.sourceRepo,
+      documentType: chatRef.type,
+      id: chatRef.id,
+      title: chatRef.title,
+      externalUrl: chatRef.url,
+      targetPlatform: chatRef.targetPlatform,
+      path,
+    },
+    ctx,
+  );
+  const rowUrl = cta.href ? resolveHref(cta.href) : (chatRef.url ?? null);
+  const rowPlatform = cta.targetPlatform ?? chatRef.targetPlatform ?? null;
+  if (rowUrl) return { url: rowUrl, targetPlatform: rowPlatform, path, source: 'row' };
+
+  // 2. The fetched row's own destination: an explicit host override, else the
+  //    registry's `fallbackHref`, else the host seam's composed href.
+  if (entry?.contentRefType && item) {
+    const choice = pickFetchedCardHref({
+      composed: resolveFetchedCardHref({
+        contentRefType: entry.contentRefType,
+        id: chatRef.id,
+        item,
+        composeContentUrl,
+      }),
+      itemHref: entry.fallbackHref?.(item) ?? null,
+      allowComposed: !entry.noComposedHref,
+    });
+    const url = choice ? (safeHref(choice.href) ?? null) : null;
+    if (choice && url) {
+      // The `item` branch carries no platform of its own: keep the ref's.
+      return { url, targetPlatform: choice.targetPlatform ?? rowPlatform, path, source: choice.source };
+    }
+  }
+  return { url: null, targetPlatform: rowPlatform, path, source: 'none' };
+}

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

@@ -176,7 +176,19 @@ export {
 
 // Post-fetch enrichment for the minimal ChatRef descriptor a
 // `[card://type:id]` marker produces (the wire ships no card metadata).
-export { resolveFetchedCardHref, readFetchedCardTitle, type FetchedCardHrefInput } from './resolve-fetched-card-href';
+export {
+  resolveCardDestination,
+  type CardDestination,
+  type CardDestinationEntry,
+  type CardDestinationInput,
+  type CardDestinationSource,
+} from './card-destination';
+export {
+  resolveFetchedCardHref,
+  readFetchedCardPath,
+  readFetchedCardTitle,
+  type FetchedCardHrefInput,
+} from './resolve-fetched-card-href';
 
 // The ONE "Ask Mingo" prompt builder — shared by the SSE adapter, the NATS
 // adapter, and hosts that inject their own Mingo state (openframe-frontend).

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

@@ -70,6 +70,23 @@ export function readFetchedCardTitle(item: unknown): string | null {
   return null;
 }
 
+/**
+ * Doc-tree path of a fetched row (`metadata.path`), or null.
+ *
+ * A doc card (`markdown`, `data_room_doc`) has no public url: its destination
+ * is its viewer plus this path, the route `resolveSourceRowCTA` composes for a
+ * source chip. A bare `[card://type:id]` marker carries no path, so the loader
+ * reads it from the row once it loads and resolves the card the way the chip
+ * was resolved.
+ */
+export function readFetchedCardPath(item: unknown): string | null {
+  if (!item || typeof item !== 'object') return null;
+  const metadata = (item as { metadata?: unknown }).metadata;
+  if (!metadata || typeof metadata !== 'object') return null;
+  const path = (metadata as { path?: unknown }).path;
+  return typeof path === 'string' && path.trim() ? path.trim() : null;
+}
+
 /** Read the row's platform-association array — the hub composer keys its
  *  cross-platform topology off it; the embedder default ignores it. Hub
  *  list-API rows carry the array under the registry arrayKey