@mcp-b/react-components 0.14.2 → 0.16.1

package/dist/WorkspaceLink-DIPbXrUM.js

@@ -0,0 +1,337 @@
+import { t as cx } from "./class-names-9UtZwb0J.js";
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/_internal/workspace-navigation-context.tsx
+const WorkspaceNavigationContext = React.createContext(null);
+function useWorkspaceNavigationContext() {
+	return React.use(WorkspaceNavigationContext);
+}
+//#endregion
+//#region src/components/_internal/workspace-navigation-restoration.tsx
+const WorkspaceNavigationRestorationContext = React.createContext(null);
+/**
+* Owns entry-keyed presentation state unless an ancestor already provides it.
+* This lets a full application share restoration between chat and files while
+* keeping a standalone WorkspaceExplorer self-contained.
+*/
+function WorkspaceNavigationRestorationBoundary({ children }) {
+	const parent = React.use(WorkspaceNavigationRestorationContext);
+	const restorationsRef = React.useRef(/* @__PURE__ */ new Map());
+	const localValue = React.useMemo(() => ({
+		get: (entryKey) => restorationsRef.current.get(entryKey),
+		recordFocus: (entryKey, destination, scope) => {
+			const current = restorationsRef.current.get(entryKey);
+			restorationsRef.current.set(entryKey, {
+				...current,
+				focusDestination: destination,
+				focusScope: scope
+			});
+		},
+		recordScroll: (entryKey, scrollTop) => {
+			const current = restorationsRef.current.get(entryKey);
+			restorationsRef.current.set(entryKey, {
+				...current,
+				scrollTop
+			});
+		}
+	}), []);
+	if (parent) return children;
+	return /* @__PURE__ */ jsx(WorkspaceNavigationRestorationContext, {
+		value: localValue,
+		children
+	});
+}
+function findDestinationLink(root, destination) {
+	if (destination.kind !== "file") return null;
+	return [...root.querySelectorAll("[data-workspace-link=\"file\"]")].find((candidate) => candidate.dataset.workspacePath === destination.path && (candidate.dataset.workspaceDestinationFragment || null) === destination.fragment) ?? null;
+}
+/** Restores a link in a named surface, including when that surface renders asynchronously. */
+function WorkspaceNavigationFocusRestorer({ entryKey, rootRef, scope }) {
+	const restoration = useWorkspaceNavigationRestoration();
+	const handledEntryRef = React.useRef(null);
+	React.useEffect(() => {
+		if (handledEntryRef.current !== entryKey) handledEntryRef.current = null;
+		if (handledEntryRef.current === entryKey) return;
+		const saved = restoration?.get(entryKey);
+		if (!saved?.focusDestination || saved.focusScope !== scope) return;
+		const focusDestination = saved.focusDestination;
+		const root = rootRef.current;
+		if (!root) return;
+		const restore = () => {
+			const surface = [...root.matches("[data-workspace-restoration-scope]") ? [root] : [], ...root.querySelectorAll("[data-workspace-restoration-scope]")].find((candidate) => candidate.dataset.workspaceRestorationScope === scope);
+			const target = surface ? findDestinationLink(surface, focusDestination) : null;
+			if (!target) return false;
+			target.focus({ preventScroll: true });
+			handledEntryRef.current = entryKey;
+			return true;
+		};
+		if (restore()) return;
+		const observer = new MutationObserver(() => {
+			if (restore()) observer.disconnect();
+		});
+		observer.observe(root, {
+			childList: true,
+			subtree: true
+		});
+		return () => observer.disconnect();
+	}, [
+		entryKey,
+		restoration,
+		rootRef,
+		scope
+	]);
+	return null;
+}
+function useWorkspaceNavigationRestoration() {
+	return React.use(WorkspaceNavigationRestorationContext);
+}
+function useRequiredWorkspaceNavigationRestoration() {
+	const restoration = useWorkspaceNavigationRestoration();
+	if (!restoration) throw new Error("Workspace navigation restoration is unavailable outside its boundary.");
+	return restoration;
+}
+//#endregion
+//#region src/components/WorkspaceLink.tsx
+const WORKSPACE_URL_ORIGIN = "https://workspace.invalid";
+const EXTERNAL_PROTOCOLS = /* @__PURE__ */ new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"tel:"
+]);
+const UNSAFE_PROTOCOLS = /* @__PURE__ */ new Set([
+	"data:",
+	"file:",
+	"javascript:",
+	"vbscript:"
+]);
+const URL_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+function hasInvalidPathCharacter(value) {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		if (character === "\\" || codePoint <= 31 || codePoint === 127) return true;
+	}
+	return false;
+}
+function decodeUrlPart(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return null;
+	}
+}
+function canonicalizeAbsolutePath(path) {
+	if (!path.startsWith("/") || hasInvalidPathCharacter(path)) return null;
+	const segments = [];
+	for (const segment of path.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") segments.pop();
+		else segments.push(segment);
+	}
+	return `/${segments.join("/")}`;
+}
+function normalizeRoot(root) {
+	if (!root || hasInvalidPathCharacter(root)) return null;
+	const pathname = canonicalizeAbsolutePath(root);
+	if (!pathname) return null;
+	return pathname === "/" ? pathname : pathname.replace(/\/+$/, "");
+}
+function isWithinRoot(path, root) {
+	return root === "/" || path === root || path.startsWith(`${root}/`);
+}
+function getPathSegments(path) {
+	return path === "/" ? [] : path.slice(1).split("/");
+}
+function resolveLocalPath(rawPath, root, base, normalizedBase) {
+	const decodedPath = decodeUrlPart(rawPath);
+	if (decodedPath === null || hasInvalidPathCharacter(decodedPath)) return { reason: "invalid-path" };
+	if (decodedPath === "") return { path: normalizedBase };
+	const rootSegments = getPathSegments(root);
+	let segments;
+	let remainingPath;
+	if (decodedPath.startsWith("/")) {
+		segments = [...rootSegments];
+		remainingPath = root !== "/" && (decodedPath === root || decodedPath.startsWith(`${root}/`)) ? decodedPath.slice(root.length) : decodedPath.slice(1);
+	} else {
+		segments = getPathSegments(base.kind === "directory" ? normalizedBase : normalizedBase.slice(0, normalizedBase.lastIndexOf("/")) || "/");
+		remainingPath = decodedPath;
+	}
+	for (const segment of remainingPath.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (segments.length <= rootSegments.length) return { reason: "outside-workspace" };
+			segments.pop();
+			continue;
+		}
+		segments.push(segment);
+	}
+	return { path: `/${segments.join("/")}` };
+}
+function invalid(href, reason) {
+	return {
+		kind: "invalid",
+		href,
+		reason
+	};
+}
+function getExternalDestination(href) {
+	try {
+		const protocol = new URL(href.startsWith("//") ? `https:${href}` : href).protocol.toLowerCase();
+		if (UNSAFE_PROTOCOLS.has(protocol) || !EXTERNAL_PROTOCOLS.has(protocol)) return invalid(href, "unsafe-protocol");
+		return {
+			kind: "external",
+			href
+		};
+	} catch {
+		return invalid(href, "invalid-path");
+	}
+}
+/** Resolve a Markdown link to a validated workspace file, external URL, or unavailable target. */
+function resolveWorkspaceLink({ href, root, base }) {
+	const normalizedRoot = normalizeRoot(root);
+	const normalizedBase = canonicalizeAbsolutePath(base.path);
+	const trimmedHref = href.trim();
+	if (!normalizedRoot || !normalizedBase || !isWithinRoot(normalizedBase, normalizedRoot) || !trimmedHref || hasInvalidPathCharacter(href)) return invalid(href, "invalid-path");
+	if (trimmedHref.startsWith("//")) return getExternalDestination(trimmedHref);
+	if (URL_SCHEME.test(trimmedHref)) return getExternalDestination(trimmedHref);
+	if (trimmedHref.startsWith("#") && base.kind === "directory") return invalid(href, "fragment-without-file");
+	const fragmentIndex = trimmedHref.indexOf("#");
+	const pathAndQuery = fragmentIndex === -1 ? trimmedHref : trimmedHref.slice(0, fragmentIndex);
+	if (pathAndQuery.includes("?")) return invalid(href, "unsupported-query");
+	const rawPath = pathAndQuery;
+	const rawFragment = fragmentIndex === -1 ? null : trimmedHref.slice(fragmentIndex + 1);
+	const fragment = rawFragment === null || rawFragment === "" ? null : decodeUrlPart(rawFragment);
+	if (rawFragment !== null && rawFragment !== "" && fragment === null || fragment !== null && hasInvalidPathCharacter(fragment)) return invalid(href, "invalid-path");
+	const localPath = resolveLocalPath(rawPath, normalizedRoot, base, normalizedBase);
+	if ("reason" in localPath) return invalid(href, localPath.reason);
+	if (!isWithinRoot(localPath.path, normalizedRoot)) return invalid(href, "outside-workspace");
+	return {
+		kind: "file",
+		path: localPath.path,
+		fragment
+	};
+}
+function getAdapterHref(navigation, destination) {
+	try {
+		const rawHref = navigation.createHref(destination);
+		if (hasInvalidPathCharacter(rawHref)) return null;
+		const href = rawHref.trim();
+		if (!href) return null;
+		const protocol = new URL(href, WORKSPACE_URL_ORIGIN).protocol.toLowerCase();
+		if (UNSAFE_PROTOCOLS.has(protocol)) return null;
+		return href;
+	} catch {
+		return null;
+	}
+}
+function WorkspaceNavigationProvider({ children, root, base, navigation }) {
+	return /* @__PURE__ */ jsx(WorkspaceNavigationContext, {
+		value: React.useMemo(() => ({
+			root,
+			base,
+			navigation
+		}), [
+			base.kind,
+			base.path,
+			navigation,
+			root
+		]),
+		children
+	});
+}
+function UnavailableWorkspaceLink({ children, className }) {
+	return /* @__PURE__ */ jsxs("span", {
+		className: cx("workspace-link workspace-link--invalid", className),
+		"data-workspace-link": "invalid",
+		children: [
+			children,
+			/* @__PURE__ */ jsx("span", {
+				className: "workspace-link__invalid-mark",
+				"aria-hidden": "true",
+				children: "↛"
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "workspace-link__visually-hidden",
+				children: " (link unavailable)"
+			})
+		]
+	});
+}
+/**
+* Markdown-compatible anchor that resolves local files through the nearest
+* workspace navigation provider while preserving native link behavior.
+*/
+function WorkspaceFileLink({ children, className, download, href = "", node: _node, onClick, rel, target, ...props }) {
+	const workspace = useWorkspaceNavigationContext();
+	const restoration = useWorkspaceNavigationRestoration();
+	if (!workspace) return /* @__PURE__ */ jsx("a", {
+		className,
+		download,
+		href,
+		onClick,
+		rel,
+		target,
+		...props,
+		children
+	});
+	const resolved = resolveWorkspaceLink({
+		href,
+		root: workspace.root,
+		base: workspace.base
+	});
+	if (resolved.kind === "invalid") return /* @__PURE__ */ jsx(UnavailableWorkspaceLink, {
+		className,
+		children
+	});
+	if (resolved.kind === "external") {
+		const externalTarget = target ?? "_blank";
+		return /* @__PURE__ */ jsxs("a", {
+			className: cx("workspace-link workspace-link--external", className),
+			"data-streamdown": "link",
+			download,
+			href: resolved.href,
+			onClick,
+			rel: rel ?? (externalTarget === "_blank" ? "noopener noreferrer" : void 0),
+			target: externalTarget,
+			...props,
+			children: [children, externalTarget === "_blank" ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+				className: "workspace-link__external-mark",
+				"aria-hidden": "true",
+				children: "↗"
+			}), /* @__PURE__ */ jsx("span", {
+				className: "workspace-link__visually-hidden",
+				children: " (opens in a new tab)"
+			})] }) : null]
+		});
+	}
+	const adapterHref = getAdapterHref(workspace.navigation, resolved);
+	if (!adapterHref) return /* @__PURE__ */ jsx(UnavailableWorkspaceLink, {
+		className,
+		children
+	});
+	const handleClick = (event) => {
+		onClick?.(event);
+		const actualTarget = event.currentTarget.target.toLowerCase();
+		if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.currentTarget.hasAttribute("download") || actualTarget !== "" && actualTarget !== "_self") return;
+		event.preventDefault();
+		const focusScope = event.currentTarget.closest("[data-workspace-restoration-scope]")?.dataset.workspaceRestorationScope;
+		restoration?.recordFocus(workspace.navigation.current.key, resolved, focusScope);
+		workspace.navigation.navigate(resolved);
+	};
+	return /* @__PURE__ */ jsx("a", {
+		className: cx("workspace-link workspace-link--file", className),
+		"data-streamdown": "link",
+		"data-workspace-link": "file",
+		"data-workspace-destination-fragment": resolved.fragment ?? "",
+		"data-workspace-path": resolved.path,
+		download,
+		href: adapterHref,
+		onClick: handleClick,
+		rel,
+		target,
+		...props,
+		children
+	});
+}
+//#endregion
+export { WorkspaceNavigationRestorationBoundary as a, useWorkspaceNavigationContext as c, WorkspaceNavigationFocusRestorer as i, WorkspaceNavigationProvider as n, useRequiredWorkspaceNavigationRestoration as o, resolveWorkspaceLink as r, useWorkspaceNavigationRestoration as s, WorkspaceFileLink as t };

package/dist/WorkspaceLink-DK1DWMHe.d.ts

@@ -0,0 +1,89 @@
+import * as React from "react";
+
+//#region src/components/WorkspaceLink.d.ts
+type WorkspaceDestination = {
+  kind: "files";
+} | {
+  kind: "file";
+  path: string;
+  fragment: string | null;
+};
+interface WorkspaceNavigationEntry {
+  key: string;
+  destination: WorkspaceDestination;
+}
+interface WorkspaceNavigationAdapter {
+  current: WorkspaceNavigationEntry;
+  createHref(destination: WorkspaceDestination): string;
+  navigate(destination: WorkspaceDestination, options?: {
+    replace?: boolean;
+  }): void;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  goBack(): void;
+  goForward(): void;
+}
+type WorkspaceLinkBase = {
+  kind: "directory";
+  path: string;
+} | {
+  kind: "file";
+  path: string;
+};
+interface WorkspaceExternalDestination {
+  kind: "external";
+  href: string;
+}
+interface WorkspaceInvalidDestination {
+  kind: "invalid";
+  href: string;
+  reason: "fragment-without-file" | "invalid-adapter-href" | "invalid-path" | "outside-workspace" | "unsafe-protocol" | "unsupported-query";
+}
+type WorkspaceLinkResolution = Extract<WorkspaceDestination, {
+  kind: "file";
+}> | WorkspaceExternalDestination | WorkspaceInvalidDestination;
+interface ResolveWorkspaceLinkOptions {
+  href: string;
+  /** Workspace boundary. A leading `/` resolves from this root. */
+  root: string;
+  /** Directory for chat links or containing file for file-preview links. */
+  base: WorkspaceLinkBase;
+}
+interface WorkspaceNavigationProviderProps {
+  children: React.ReactNode;
+  root: string;
+  base: WorkspaceLinkBase;
+  navigation: WorkspaceNavigationAdapter;
+}
+/** Resolve a Markdown link to a validated workspace file, external URL, or unavailable target. */
+declare function resolveWorkspaceLink({
+  href,
+  root,
+  base
+}: ResolveWorkspaceLinkOptions): WorkspaceLinkResolution;
+declare function WorkspaceNavigationProvider({
+  children,
+  root,
+  base,
+  navigation
+}: WorkspaceNavigationProviderProps): React.JSX.Element;
+interface WorkspaceFileLinkProps extends React.ComponentProps<"a"> {
+  node?: unknown;
+}
+/**
+ * Markdown-compatible anchor that resolves local files through the nearest
+ * workspace navigation provider while preserving native link behavior.
+ */
+declare function WorkspaceFileLink({
+  children,
+  className,
+  download,
+  href,
+  node: _node,
+  onClick,
+  rel,
+  target,
+  ...props
+}: WorkspaceFileLinkProps): React.JSX.Element;
+//#endregion
+export { WorkspaceFileLinkProps as a, WorkspaceLinkResolution as c, WorkspaceNavigationProvider as d, WorkspaceNavigationProviderProps as f, WorkspaceFileLink as i, WorkspaceNavigationAdapter as l, WorkspaceDestination as n, WorkspaceInvalidDestination as o, resolveWorkspaceLink as p, WorkspaceExternalDestination as r, WorkspaceLinkBase as s, ResolveWorkspaceLinkOptions as t, WorkspaceNavigationEntry as u };

package/dist/components/Activity.d.ts

@@ -43,6 +43,32 @@ interface ActivityTriggerProps extends Omit<React.ComponentProps<typeof Collapsi
   /** Optional leading icon for the header. */
   icon?: React.ReactNode;
 }
+interface ActivityHeaderProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+  /** Current one-line activity label. */
+  label?: React.ReactNode;
+  /** Optional leading activity icon. */
+  icon?: React.ReactNode;
+  /** Optional trailing affordance supplied by the interactive owner. */
+  trailing?: React.ReactNode;
+  /** While true, the label uses the shared streaming treatment. */
+  isStreaming?: boolean;
+}
+/**
+ * Presentation-only activity header. It deliberately has no click or
+ * disclosure behavior so a transcript, app shell, or injected preview can
+ * provide the correct interaction semantics around the same visual.
+ */
+declare function ActivityHeader({
+  className,
+  icon,
+  isStreaming,
+  label,
+  trailing,
+  ref,
+  ...props
+}: ActivityHeaderProps & {
+  ref?: React.Ref<HTMLSpanElement>;
+}): React.JSX.Element;
 /**
  * Clickable header line that toggles the activity log. The label shimmers
  * while the parent Activity is streaming.
@@ -148,4 +174,4 @@ declare function ActivityPanel({
   ref?: React.Ref<HTMLDivElement>;
 }): React.JSX.Element;
 //#endregion
-export { Activity, ActivityContent, ActivityContentProps, ActivityItem, ActivityItemGroup, ActivityItemGroupProps, ActivityItemProps, ActivityOutput, ActivityOutputProps, ActivityPanel, ActivityPanelProps, ActivityProps, ActivityText, ActivityTextProps, ActivityTrigger, ActivityTriggerProps };
+export { Activity, ActivityContent, ActivityContentProps, ActivityHeader, ActivityHeaderProps, ActivityItem, ActivityItemGroup, ActivityItemGroupProps, ActivityItemProps, ActivityOutput, ActivityOutputProps, ActivityPanel, ActivityPanelProps, ActivityProps, ActivityText, ActivityTextProps, ActivityTrigger, ActivityTriggerProps };

package/dist/components/Activity.js

@@ -1,6 +1,6 @@
 import { Collapsible } from "./Collapsible.js";
 import { t as cx } from "../class-names-9UtZwb0J.js";
-import { c as ChevronRightIcon } from "../icons-Ba9THQKz.js";
+import { l as ChevronRightIcon } from "../icons-CpfUer49.js";
 import "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/components/Activity.tsx
@@ -35,6 +35,31 @@ function Activity({ className, isStreaming = false, defaultOpen = false, ref, ..
 	});
 }
 /**
+* Presentation-only activity header. It deliberately has no click or
+* disclosure behavior so a transcript, app shell, or injected preview can
+* provide the correct interaction semantics around the same visual.
+*/
+function ActivityHeader({ className, icon, isStreaming = false, label = "Working…", trailing, ref, ...props }) {
+	return /* @__PURE__ */ jsxs("span", {
+		ref,
+		className: cx("activity__header", className),
+		"data-streaming": isStreaming || void 0,
+		...props,
+		children: [
+			icon ? /* @__PURE__ */ jsx("span", {
+				className: "activity__item-icon",
+				"aria-hidden": "true",
+				children: icon
+			}) : null,
+			/* @__PURE__ */ jsx("span", {
+				className: "activity__header-label",
+				children: label
+			}),
+			trailing
+		]
+	});
+}
+/**
 * Clickable header line that toggles the activity log. The label shimmers
 * while the parent Activity is streaming.
 */
@@ -46,27 +71,20 @@ function ActivityTrigger({ className, label = "Working…", icon, children, ref,
 		unstyled: true,
 		children
 	});
-	return /* @__PURE__ */ jsxs(Collapsible.Trigger, {
+	return /* @__PURE__ */ jsx(Collapsible.Trigger, {
 		ref,
 		className: cx("activity__trigger", className),
 		...props,
 		unstyled: true,
-		children: [
-			icon ? /* @__PURE__ */ jsx("span", {
-				className: "activity__item-icon",
-				"aria-hidden": "true",
-				children: icon
-			}) : null,
-			/* @__PURE__ */ jsx("span", {
-				className: "activity__trigger-label",
-				children: label
-			}),
-			/* @__PURE__ */ jsx("span", {
+		children: /* @__PURE__ */ jsx(ActivityHeader, {
+			icon,
+			label,
+			trailing: /* @__PURE__ */ jsx("span", {
 				className: "activity__trigger-icon",
 				"aria-hidden": "true",
 				children: /* @__PURE__ */ jsx(ChevronRightIcon, {})
 			})
-		]
+		})
 	});
 }
 /** The collapsible log of ActivityItem children. */
@@ -182,4 +200,4 @@ function ActivityPanel({ className, label, text, status, error, children, ref, .
 	});
 }
 //#endregion
-export { Activity, ActivityContent, ActivityItem, ActivityItemGroup, ActivityOutput, ActivityPanel, ActivityText, ActivityTrigger };
+export { Activity, ActivityContent, ActivityHeader, ActivityItem, ActivityItemGroup, ActivityOutput, ActivityPanel, ActivityText, ActivityTrigger };

package/dist/components/AgentActivity.d.ts

@@ -0,0 +1,2 @@
+import { a as AgentActivityIconProps, i as AgentActivityIconKind, n as AgentActivityFaviconProps, o as AgentActivityMode, r as AgentActivityIcon, s as AgentActivitySummary, t as AgentActivityFavicon } from "../AgentActivity-BNUNrP9O.js";
+export { AgentActivityFavicon, AgentActivityFaviconProps, AgentActivityIcon, AgentActivityIconKind, AgentActivityIconProps, AgentActivityMode, AgentActivitySummary };

package/dist/components/AgentActivity.js

@@ -0,0 +1,45 @@
+import { C as LinkIcon, G as TerminalIcon, J as WrenchIcon, N as PencilIcon, R as SearchIcon, S as InfoIcon, k as MonitorIcon, q as WarningIcon, v as FileIcon } from "../icons-CpfUer49.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/AgentActivity.tsx
+/** Built-in icon vocabulary shared by AI SDK activity and Agents SDK state summaries. */
+function AgentActivityIcon({ kind }) {
+	switch (kind) {
+		case "thought": return /* @__PURE__ */ jsx(InfoIcon, {});
+		case "read": return /* @__PURE__ */ jsx(FileIcon, {});
+		case "edit": return /* @__PURE__ */ jsx(PencilIcon, {});
+		case "search": return /* @__PURE__ */ jsx(SearchIcon, {});
+		case "web": return /* @__PURE__ */ jsx(LinkIcon, {});
+		case "command": return /* @__PURE__ */ jsx(TerminalIcon, {});
+		case "browser": return /* @__PURE__ */ jsx(MonitorIcon, {});
+		case "approval": return /* @__PURE__ */ jsx(WarningIcon, {});
+		default: return /* @__PURE__ */ jsx(WrenchIcon, {});
+	}
+}
+/** Site favicon for URL-backed activity, with the shared icon vocabulary as fallback. */
+function AgentActivityFavicon({ fallbackKind = "web", url }) {
+	const src = faviconHref(url);
+	const [failed, setFailed] = React.useState(false);
+	React.useEffect(() => setFailed(false), [src]);
+	if (!src || failed) return /* @__PURE__ */ jsx(AgentActivityIcon, { kind: fallbackKind });
+	return /* @__PURE__ */ jsx("img", {
+		className: "activity__favicon",
+		src,
+		alt: "",
+		loading: "lazy",
+		decoding: "async",
+		referrerPolicy: "no-referrer",
+		onError: () => setFailed(true)
+	});
+}
+function faviconHref(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+		return new URL("/favicon.ico", parsed.origin).href;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { AgentActivityFavicon, AgentActivityIcon };

package/dist/components/AgentActivityPreview.d.ts

@@ -0,0 +1,46 @@
+import { n as WorkspaceDestination } from "../WorkspaceLink-DK1DWMHe.js";
+import { s as AgentActivitySummary } from "../AgentActivity-BNUNrP9O.js";
+import * as React from "react";
+
+//#region src/components/AgentActivityPreview.d.ts
+/** The three conditions that make an agent relevant to the transient preview. */
+type AgentActivityPreviewStatus = "running" | "input-required" | "unviewed";
+interface AgentActivityPreviewFavicon {
+  src: string;
+  label: string;
+}
+type AgentActivityPreviewItem = Omit<AgentActivitySummary, "mode"> & {
+  id: string;
+  status: AgentActivityPreviewStatus;
+  favicons?: readonly AgentActivityPreviewFavicon[];
+};
+interface AgentActivityPreviewProps extends Omit<React.HTMLAttributes<HTMLElement>, "children" | "onSelect"> {
+  /** Current agent summaries to show in the transient preview. */
+  items: readonly AgentActivityPreviewItem[];
+  /** Opens the selected agent by its stable id. */
+  onSelect: (id: string) => void;
+  /** Opens a projected file target in the selected agent's workspace. */
+  onOpenWorkspaceFile?: (id: string, destination: Extract<WorkspaceDestination, {
+    kind: "file";
+  }>) => void;
+  /** Hides the complete preview when the host supports dismissal. */
+  onDismiss?: () => void;
+  /** Product mark shown beside the agent rows. */
+  brandIcon?: React.ReactNode;
+}
+/** Compact multi-agent preview for a page overlay or secondary application rail. */
+declare function AgentActivityPreview({
+  "aria-label": ariaLabel,
+  brandIcon,
+  className,
+  items,
+  onDismiss,
+  onOpenWorkspaceFile,
+  onSelect,
+  ref,
+  ...props
+}: AgentActivityPreviewProps & {
+  ref?: React.Ref<HTMLElement>;
+}): React.JSX.Element | null;
+//#endregion
+export { AgentActivityPreview, AgentActivityPreviewFavicon, AgentActivityPreviewItem, AgentActivityPreviewProps, AgentActivityPreviewStatus };