@remit/web-client 0.0.324 → 0.0.326

package/src/components/mail/MessageAttachments.tsx

@@ -1,188 +0,0 @@
-import { messageOperationsDescribeMessageQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type {
-	RemitImapBodyPartResponse,
-	RemitImapDescribeMessageResponse,
-} from "@remit/api-http-client/types.gen.ts";
-import { encapsulatedParts } from "@remit/data-ports/message-parts";
-import { type AttachmentDownloadState, AttachmentList } from "@remit/ui";
-import { useQueryClient } from "@tanstack/react-query";
-import { useMemo, useState } from "react";
-import { useAuthProvider } from "@/auth/provider";
-import {
-	attachmentFailureContent,
-	attachmentReportUrl,
-	extractAttachmentFailureDetail,
-	extractAttachmentFailureReason,
-	fetchAttachment,
-	isRepairableByRefetch,
-	saveBlob,
-} from "@/lib/attachment-download";
-import {
-	type MessageAttachment,
-	selectMessageAttachments,
-} from "@/lib/message-attachments";
-import { MessageBody } from "./MessageBody";
-
-interface MessageAttachmentsProps {
-	messageId: string;
-	/** Body parts from `describeMessage`; absent while the message is loading. */
-	bodyParts?: readonly RemitImapBodyPartResponse[];
-	/** The thread row's server-side attachment flag. */
-	hasAttachment?: boolean;
-	className?: string;
-}
-
-const IDLE: AttachmentDownloadState = { status: "idle" };
-
-/**
- * The attachments carried by an open message, and the download behind each row.
- *
- * Download state is per row and lives here rather than in a query: a download is
- * a one-shot user action with no cached result to hold, and the bytes are handed
- * to the browser rather than rendered.
- *
- * A forwarded message also opens in place: its own parts render through the
- * same body and attachment components as the message carrying it.
- */
-export const MessageAttachments = ({
-	messageId,
-	bodyParts,
-	hasAttachment = false,
-	className,
-}: MessageAttachmentsProps) => {
-	const { getToken } = useAuthProvider();
-	const queryClient = useQueryClient();
-	const [downloads, setDownloads] = useState<
-		Record<string, AttachmentDownloadState>
-	>({});
-	const [openedId, setOpenedId] = useState<string | null>(null);
-
-	const attachments = useMemo(
-		() => selectMessageAttachments(bodyParts ?? []),
-		[bodyParts],
-	);
-
-	const describeKey = messageOperationsDescribeMessageQueryKey({
-		path: { messageId },
-	});
-
-	/**
-	 * A stale signature and an unmaterialized part are both repaired by re-reading
-	 * the message: `describeMessage` re-signs every `contentUrl`, and it
-	 * materializes the deferred per-part objects on its way through. Re-hitting
-	 * the same URL alone cannot fix either (remit-mail/remit#1240), so the retry
-	 * goes through the read path and then uses the URL it just minted.
-	 */
-	const fetchThroughRefreshedDescribe = (
-		attachment: MessageAttachment,
-	): Promise<Blob> =>
-		fetchAttachment(attachment.contentUrl, getToken).catch(
-			(error: unknown): Promise<Blob> => {
-				if (!isRepairableByRefetch(extractAttachmentFailureReason(error))) {
-					throw error;
-				}
-				return queryClient
-					.refetchQueries({ queryKey: describeKey })
-					.then(() => {
-						const refreshed =
-							queryClient.getQueryData<RemitImapDescribeMessageResponse>(
-								describeKey,
-							);
-						const renewed = refreshed
-							? selectMessageAttachments(refreshed.bodyParts).find(
-									(candidate) => candidate.bodyPartId === attachment.bodyPartId,
-								)
-							: undefined;
-						return fetchAttachment(
-							renewed?.contentUrl ?? attachment.contentUrl,
-							getToken,
-						);
-					});
-			},
-		);
-
-	const setState = (id: string, state: AttachmentDownloadState) =>
-		setDownloads((current) => ({ ...current, [id]: state }));
-
-	const download = (bodyPartId: string) => {
-		const attachment = attachments.find(
-			(candidate) => candidate.bodyPartId === bodyPartId,
-		);
-		if (!attachment) {
-			throw new Error(
-				`No attachment part ${bodyPartId} on message ${messageId}`,
-			);
-		}
-
-		setState(bodyPartId, { status: "downloading" });
-		fetchThroughRefreshedDescribe(attachment)
-			.then((blob) => {
-				saveBlob(blob, attachment.filename);
-				setState(bodyPartId, IDLE);
-			})
-			.catch((error: unknown) => {
-				const reason = extractAttachmentFailureReason(error);
-				const fallback = extractAttachmentFailureDetail(error);
-				const { title, detail } = attachmentFailureContent(
-					reason,
-					attachment.filename,
-					fallback,
-				);
-				setState(bodyPartId, {
-					status: "failed",
-					title,
-					detail,
-					reportUrl: attachmentReportUrl(reason, attachment.filename, fallback),
-				});
-			});
-	};
-
-	// Only claim an attachment is unaccounted for once the parts have arrived;
-	// while `describeMessage` is in flight there is nothing to contradict.
-	const hasUnlistedAttachment =
-		hasAttachment && bodyParts !== undefined && attachments.length === 0;
-
-	const openedMessage = attachments.find(
-		(attachment) =>
-			attachment.kind === "message" && attachment.bodyPartId === openedId,
-	);
-	const openedParts = openedMessage
-		? encapsulatedParts(bodyParts ?? [], openedMessage.partPath)
-		: [];
-
-	return (
-		<AttachmentList
-			className={className}
-			attachments={attachments.map((attachment) => ({
-				attachmentId: attachment.bodyPartId,
-				kind: attachment.kind,
-				filename: attachment.filename,
-				typeLabel: attachment.typeLabel,
-				sizeOctets: attachment.sizeOctets,
-				download: downloads[attachment.bodyPartId] ?? IDLE,
-			}))}
-			onDownload={download}
-			hasUnlistedAttachment={hasUnlistedAttachment}
-			onToggleOpen={(bodyPartId) =>
-				setOpenedId((current) => (current === bodyPartId ? null : bodyPartId))
-			}
-			opened={
-				openedMessage
-					? {
-							attachmentId: openedMessage.bodyPartId,
-							content: (
-								<>
-									<MessageBody bodyParts={openedParts} messageId={messageId} />
-									<MessageAttachments
-										messageId={messageId}
-										bodyParts={openedParts}
-										className="mt-4"
-									/>
-								</>
-							),
-						}
-					: undefined
-			}
-		/>
-	);
-};

package/src/components/mail/MessageBody.blocked-sender.test.ts

@@ -1,193 +0,0 @@
-/**
- * Image gating at the `MessageBody` seam (#352). `BlockedFlag` declares that a
- * blocked sender's images never load "even on explicit click", and Settings >
- * Senders promises the same. Blocked therefore suppresses auto-load AND removes
- * the manual load affordances, and outranks `trusted` when both are set.
- *
- * Renders through the real pipeline — sanitizer, blocked-image count, notice —
- * against the jsdom harness, so the assertions read the DOM the user gets.
- */
-
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { createElement } from "react";
-import { createDomHarness, type DomHarness } from "../../test-support/dom";
-import { MessageBody } from "./MessageBody";
-
-let harness: DomHarness | undefined;
-
-// The sandboxed frame measures itself once the iframe loads. jsdom fires that
-// load but has no ResizeObserver, and the resulting ReferenceError is raised
-// inside a listener where no assertion can see it.
-(globalThis as { ResizeObserver?: unknown }).ResizeObserver = class {
-	observe() {}
-	unobserve() {}
-	disconnect() {}
-};
-
-afterEach(() => {
-	harness?.close();
-	harness = undefined;
-});
-
-const MARKETING_HTML = `
-<div>
-	<img src="https://tracker.example/hero.png" alt="Hero" />
-	<p>Up to 40% off everything this weekend.</p>
-	<img src="https://tracker.example/pixel.gif" alt="" />
-</div>
-`;
-
-// Every remote-image vector an email can reach for, not just `img src`.
-const MULTI_VECTOR_HTML = `
-<div>
-	<img src="https://tracker.example/hero.png" srcset="https://tracker.example/hero@2x.png 2x" alt="Hero" />
-	<picture>
-		<source srcset="https://tracker.example/wide.png" type="image/png" />
-		<img src="https://tracker.example/narrow.png" alt="Deal" />
-	</picture>
-	<video poster="https://tracker.example/poster.jpg"><source src="https://tracker.example/clip.mp4" type="video/mp4" /></video>
-</div>
-`;
-
-const mount = (
-	flags: { isTrusted?: boolean; isBlocked?: boolean },
-	overrides: { html?: string; messageId?: string } = {},
-) => {
-	harness = createDomHarness();
-	harness.renderApp(
-		createElement(MessageBody, {
-			html: MARKETING_HTML,
-			messageId: "msg-1",
-			fromAddressId: "addr-1",
-			category: "marketing",
-			...flags,
-			...overrides,
-		}),
-	);
-	return harness;
-};
-
-const rerender = (
-	dom: DomHarness,
-	flags: { isTrusted?: boolean; isBlocked?: boolean },
-	overrides: { html?: string; messageId?: string } = {},
-) => {
-	dom.renderApp(
-		createElement(MessageBody, {
-			html: MARKETING_HTML,
-			messageId: "msg-1",
-			fromAddressId: "addr-1",
-			category: "marketing",
-			...flags,
-			...overrides,
-		}),
-	);
-};
-
-const frameHtml = (dom: DomHarness): string =>
-	dom.query<HTMLIFrameElement>("iframe")?.getAttribute("srcdoc") ?? "";
-
-// A blocked image keeps its original URL in `data-blocked-src` — only a live
-// `src=` means the browser will fetch it.
-const REMOTE_SRC = /\ssrc="https:\/\/tracker\.example\/hero\.png"/;
-
-describe("MessageBody image gating — blocked senders (#352)", () => {
-	it("never auto-loads images for a blocked sender", () => {
-		const dom = mount({ isBlocked: true });
-		assert.match(
-			frameHtml(dom),
-			/data-blocked-src/,
-			"a blocked sender's remote images must stay placeholders",
-		);
-		assert.doesNotMatch(frameHtml(dom), REMOTE_SRC);
-	});
-
-	it("offers no manual load affordance for a blocked sender", () => {
-		const dom = mount({ isBlocked: true });
-		assert.equal(
-			dom.queryAll("button").length,
-			0,
-			"never load, even on explicit click — the controls are absent, not disabled",
-		);
-		assert.doesNotMatch(dom.html(), /\bdisabled\b/);
-	});
-
-	it("says why the message has no images instead of going quiet", () => {
-		const dom = mount({ isBlocked: true });
-		assert.match(dom.text(), /2 images hidden/);
-		assert.match(dom.text(), /you blocked this sender/);
-	});
-
-	it("keeps images blocked when the sender is both blocked and trusted", () => {
-		const dom = mount({ isBlocked: true, isTrusted: true });
-		assert.match(frameHtml(dom), /data-blocked-src/);
-		assert.equal(dom.queryAll("button").length, 0);
-		assert.match(dom.text(), /you blocked this sender/);
-	});
-
-	it("emits no fetchable tracker URL through srcset, picture or poster either", () => {
-		const dom = mount({ isBlocked: true }, { html: MULTI_VECTOR_HTML });
-		// The placeholder swap parks the original `img src` in
-		// `data-blocked-src` for "load once"; anywhere else in the srcdoc, a
-		// tracker URL is a request the frame will make.
-		const live = frameHtml(dom).replace(/data-blocked-src="[^"]*"/g, "");
-		assert.doesNotMatch(
-			live,
-			/tracker\.example/,
-			"blocked means no remote image request, whichever attribute names it",
-		);
-		assert.match(
-			frameHtml(dom),
-			/data-blocked-src="https:\/\/tracker\.example/,
-		);
-	});
-});
-
-describe("MessageBody load-once is scoped to one message (#352)", () => {
-	it("drops the grant when the same instance is handed a different message", () => {
-		const dom = mount({});
-		dom.click(dom.byText("button", "Load once"));
-		assert.match(frameHtml(dom), REMOTE_SRC);
-
-		rerender(dom, {}, { messageId: "msg-2" });
-
-		assert.doesNotMatch(
-			frameHtml(dom),
-			REMOTE_SRC,
-			"a load-once decision belongs to the message it was taken on",
-		);
-		assert.match(frameHtml(dom), /data-blocked-src/);
-		assert.ok(dom.byText("button", "Load once"));
-	});
-
-	it("keeps the grant while the message stays the same", () => {
-		const dom = mount({});
-		dom.click(dom.byText("button", "Load once"));
-		rerender(dom, { isTrusted: false });
-		assert.match(frameHtml(dom), REMOTE_SRC);
-	});
-});
-
-describe("MessageBody image gating — the states blocking must not change", () => {
-	it("auto-loads a trusted sender's images and shows no notice", () => {
-		const dom = mount({ isTrusted: true });
-		assert.match(frameHtml(dom), REMOTE_SRC);
-		assert.doesNotMatch(frameHtml(dom), /data-blocked-src/);
-		assert.doesNotMatch(dom.text(), /hidden|blocked for privacy/);
-	});
-
-	it("still offers Load once and Always trust to a merely untrusted sender", () => {
-		const dom = mount({});
-		assert.match(frameHtml(dom), /data-blocked-src/);
-		assert.match(dom.text(), /2 images blocked for privacy/);
-		assert.ok(dom.byText("button", "Load once"));
-		assert.ok(dom.byText("button", "Always trust"));
-	});
-
-	it("loads the images once the untrusted sender's Load once is taken", () => {
-		const dom = mount({});
-		dom.click(dom.byText("button", "Load once"));
-		assert.match(frameHtml(dom), REMOTE_SRC);
-	});
-});

package/src/components/mail/MessageBody.tsx

@@ -1,226 +0,0 @@
-import {
-	buildCidResolver,
-	type CidResolver,
-	cn,
-	type EmailRenderCategory,
-	MessageBodyView,
-} from "@remit/ui";
-import { useMemo, useState } from "react";
-import { useIsDark } from "@/hooks/useIsDark";
-import { useMessageBodyContent } from "@/hooks/useMessageBodyContent";
-import { useToggleTrusted } from "@/hooks/useToggleTrusted";
-import { BlockedImagesNotice } from "./BlockedImagesNotice";
-import { MessageBodyErrorBanner } from "./MessageBodyErrorBanner";
-
-/**
- * Subset of the OpenAPI `BodyPartResponse` consumed by this component for
- * inline-image / attachment URL resolution and the body fetcher. Pinning a
- * structural subset avoids a hard import on the generated types so this file
- * compiles before `make` runs in fresh checkouts.
- */
-export interface MessageBodyPart {
-	bodyPartId: string;
-	partPath: string;
-	mediaType: string;
-	mediaSubtype: string;
-	contentId?: string;
-	contentUrl: string;
-	disposition?: string;
-	dispositionFilename?: string;
-	isMultipart: boolean;
-}
-
-interface MessageBodyProps {
-	/**
-	 * Body parts from `describeMessage`. The component picks the first
-	 * `text/html` part (fallback `text/plain`) and fetches its `contentUrl`
-	 * from CloudFront. `cid:CONTENT_ID` references in HTML resolve to other
-	 * parts' `contentUrl` via the same list (#224 PR 3).
-	 */
-	bodyParts?: readonly MessageBodyPart[];
-	/**
-	 * Local-render fallback for callers that don't have BodyParts (Outbox
-	 * drafts, Compose preview). When `bodyParts` is provided, these are
-	 * ignored — the component fetches via CloudFront instead.
-	 */
-	html?: string;
-	text?: string;
-	/**
-	 * Whether the From-address has the `trusted` flag set. Trusted senders
-	 * auto-load images. The "Load images" bar is suppressed entirely for
-	 * trusted senders. Ignored when `isBlocked` is set.
-	 */
-	isTrusted?: boolean;
-	/**
-	 * Whether the From-address has the `blocked` flag set. A blocked sender
-	 * never loads images, "even on explicit click" (`BlockedFlag`), so this
-	 * suppresses auto-load and removes the manual load affordances rather than
-	 * greying them out. Blocked outranks trusted: it is the more restrictive
-	 * instruction, and a sender carrying both is still blocked.
-	 */
-	isBlocked?: boolean;
-	/**
-	 * The current message id. Required for the body-content query cache key
-	 * and by `useToggleTrusted` for the optimistic cache patch.
-	 */
-	messageId?: string;
-	/**
-	 * The From-address `addressId`. When omitted (e.g. the envelope has no
-	 * parseable From) the "Always trust" button is hidden.
-	 */
-	fromAddressId?: string;
-	/**
-	 * Message category (personal/newsletter/marketing/…). Together with
-	 * `hasAuthorBackground` this determines whether to apply the framed
-	 * newsletter treatment or the plain-email normalization CSS.
-	 */
-	category?: EmailRenderCategory;
-	/**
-	 * Extra classes for the `.message-body` wrapper. `MessageCard` leaves this
-	 * unset: the kit's `ExpandedMessage` owns the gutter, and runs the sandboxed
-	 * email frame out of it so mail renders on its own ground.
-	 */
-	className?: string;
-}
-
-const LoadingSkeleton = () => (
-	// biome-ignore lint/a11y/useSemanticElements: <div> with role="status" preserves block layout; <output> is inline
-	<div
-		className="animate-pulse space-y-2"
-		role="status"
-		aria-label="Loading message body"
-	>
-		<div className="h-4 bg-surface-sunken rounded w-full" />
-		<div className="h-4 bg-surface-sunken rounded w-11/12" />
-		<div className="h-4 bg-surface-sunken rounded w-3/4" />
-		<div className="h-4 bg-surface-sunken rounded w-5/6" />
-	</div>
-);
-
-const EmptyBody = () => (
-	<p className="text-fg-muted text-sm italic">
-		This message has no body content.
-	</p>
-);
-
-export const MessageBody = ({
-	bodyParts,
-	html,
-	text,
-	isTrusted = false,
-	isBlocked = false,
-	messageId,
-	fromAddressId,
-	category,
-	className,
-}: MessageBodyProps) => {
-	// "Load once" is a decision about one message. Reset it when the instance is
-	// handed a different message so the grant can't ride along — today every
-	// caller keys this component by message, which makes the leak unreachable,
-	// but the guarantee should hold structurally rather than by a caller's key.
-	const [allowImagesOnce, setAllowImagesOnce] = useState(false);
-	const [grantedFor, setGrantedFor] = useState(messageId);
-	if (grantedFor !== messageId) {
-		setGrantedFor(messageId);
-		setAllowImagesOnce(false);
-	}
-	const allowImages = !isBlocked && (isTrusted || allowImagesOnce);
-	const isDark = useIsDark();
-	// `useToggleTrusted` surfaces its own failure (banner + rollback) and a fatal
-	// 5xx escalates globally — no consumer-side error effect needed here.
-	const { toggleTrusted, isPending: isTrustPending } = useToggleTrusted({
-		messageId: messageId ?? "",
-	});
-
-	const hasParts = !!bodyParts && bodyParts.length > 0;
-	const {
-		picked,
-		data: fetched,
-		isLoading: isBodyLoading,
-		isError: isBodyError,
-		error: bodyError,
-		refetch: refetchBody,
-	} = useMessageBodyContent({
-		messageId,
-		bodyParts,
-		enabled: hasParts,
-	});
-
-	const resolveCid: CidResolver = useMemo(
-		() => buildCidResolver(bodyParts ?? []),
-		[bodyParts],
-	);
-
-	const renderedHtml =
-		hasParts && fetched?.kind === "html" ? fetched.body : html;
-	const renderedText =
-		hasParts && fetched?.kind === "text" ? fetched.body : text;
-
-	if (hasParts) {
-		if (isBodyLoading) {
-			return (
-				<div className={cn("message-body", className)}>
-					<LoadingSkeleton />
-				</div>
-			);
-		}
-		if (isBodyError) {
-			return (
-				<div className={cn("message-body", className)}>
-					<MessageBodyErrorBanner
-						error={bodyError}
-						onRetry={() => refetchBody()}
-					/>
-				</div>
-			);
-		}
-		if (!picked) {
-			return (
-				<div className={cn("message-body", className)}>
-					<EmptyBody />
-				</div>
-			);
-		}
-	} else if (!html && !text) {
-		return (
-			<div className={cn("message-body", className)}>
-				<EmptyBody />
-			</div>
-		);
-	}
-
-	const canAlwaysTrust = Boolean(fromAddressId && messageId);
-	const handleAlwaysTrust = () => {
-		if (!fromAddressId || isTrustPending) return;
-		setAllowImagesOnce(true);
-		toggleTrusted(fromAddressId, false);
-	};
-
-	// The sanitize → classify → sandboxed-iframe rendering lives in the kit's
-	// `MessageBodyView` (the single source of truth, shared with Storybook's
-	// reading panes — #940). This component keeps the data orchestration:
-	// bodyParts → html/text, the allow-images-once trust state, and the
-	// privacy "images blocked" bar (it touches app trust state, so it stays
-	// here and is injected via `renderBlockedNotice`).
-	return (
-		<MessageBodyView
-			className={className}
-			html={renderedHtml}
-			text={renderedText}
-			isDark={isDark}
-			category={category}
-			allowImages={allowImages}
-			resolveCid={resolveCid}
-			renderBlockedNotice={(blockedImageCount) => (
-				<BlockedImagesNotice
-					blockedImageCount={blockedImageCount}
-					canAlwaysTrust={canAlwaysTrust}
-					isTrustPending={isTrustPending}
-					isSenderBlocked={isBlocked}
-					onLoadOnce={() => setAllowImagesOnce(true)}
-					onAlwaysTrust={handleAlwaysTrust}
-				/>
-			)}
-		/>
-	);
-};

package/src/components/mail/MessageBodyErrorBanner.render.test.ts

@@ -1,85 +0,0 @@
-/**
- * React-render smoke test for `MessageBodyErrorBanner`. Pure helpers are
- * covered by `MessageBodyErrorBanner.test.ts`; this file proves the component
- * itself renders without crashing in the two surfaces that matter:
- *
- *  1. local-dev (no Cognito, no `Authenticator.Provider` in scope) — the
- *     previous version of this component called `useAuthenticator` at the
- *     top of render, which throws `USE_AUTHENTICATOR_ERROR` outside the
- *     provider and would crash the whole MessageBody subtree on the first
- *     body-fetch failure. The fix gates the hook-using subcomponent behind
- *     `isCognitoConfigured()`. This test pins that behaviour.
- *  2. body-missing variant — no sign-in CTA regardless of config, so it
- *     should also render fine without the provider.
- *
- * Uses `react-dom/server`'s `renderToString` so the assertion runs without
- * pulling in jsdom/happy-dom (no new deps).
- */
-
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { createElement } from "react";
-import { renderToString } from "react-dom/server";
-import { BodyFetchError } from "@/hooks/useMessageBodyContent";
-import { MessageBodyErrorBanner } from "./MessageBodyErrorBanner";
-
-const renderBanner = (error: unknown, onRetry?: () => void): string =>
-	renderToString(
-		createElement(MessageBodyErrorBanner, { error, onRetry }) as never,
-	);
-
-/**
- * The sign-in CTA is rendered as a `<button>` whose text is "Sign in again".
- * The string "Sign in again" also appears as the prefix of the auth-variant
- * detail copy, so the assertion must look for the BUTTON tag specifically,
- * not the bare substring.
- */
-const hasSignInButton = (html: string): boolean =>
-	/<button\b[^>]*>Sign in again<\/button>/.test(html);
-
-describe("MessageBodyErrorBanner renders without an Authenticator.Provider in scope (#401 review)", () => {
-	it("renders the body-missing variant without throwing — local-dev / production both reach this branch", () => {
-		const html = renderBanner(
-			new BodyFetchError("body-missing", "missing", 403),
-		);
-		assert.match(html, /Message body is missing in storage/);
-		assert.match(html, /data-reason="body-missing"/);
-		assert.equal(
-			hasSignInButton(html),
-			false,
-			"sign-in CTA must not appear for body-missing — only the auth variant",
-		);
-	});
-
-	it("renders the auth variant in local-dev WITHOUT mounting the sign-in CTA — `useAuthenticator` would throw outside `Authenticator.Provider` and crash the subtree", () => {
-		// Default test env: `globalThis.__REMIT_CONFIG__` is unset, so
-		// `isCognitoConfigured()` returns false — same shape as `AuthShell`
-		// running without the provider. If `MessageBodyErrorBanner` calls
-		// `useAuthenticator` unconditionally again, this `renderToString`
-		// call throws.
-		const html = renderBanner(
-			new BodyFetchError("auth", "Invalid id_token", 401),
-		);
-		assert.match(html, /Your session expired/);
-		assert.match(html, /data-reason="auth"/);
-		assert.equal(
-			hasSignInButton(html),
-			false,
-			"sign-in CTA must be suppressed when Cognito is not configured (no Authenticator.Provider in the tree) — pre-fix regression: the button rendered and `useAuthenticator` crashed at render",
-		);
-	});
-
-	it("renders the generic variant for unknown errors without crashing", () => {
-		const html = renderBanner(new Error("network down"));
-		assert.match(html, /Couldn.+t load message body/);
-		assert.match(html, /network down/);
-	});
-
-	it("renders a Retry button when onRetry is supplied (every variant)", () => {
-		const html = renderBanner(
-			new BodyFetchError("body-missing", "missing", 403),
-			() => undefined,
-		);
-		assert.match(html, /<button\b[^>]*>Retry<\/button>/);
-	});
-});