fix: retain session failures across recovery surfaces (#3669)
This commit is contained in:
@@ -4,24 +4,11 @@ import { resolveCompetingInitialScrollOwner } from "./message-list-native-scroll
|
||||
const noProgrammaticLock = () => false;
|
||||
|
||||
describe("resolveCompetingInitialScrollOwner", () => {
|
||||
it("gives a new recovery failure the initial reveal before unread placement", () => {
|
||||
expect(
|
||||
resolveCompetingInitialScrollOwner({
|
||||
hasPendingLayoutRestore: false,
|
||||
hasExplicitScrollTarget: false,
|
||||
hasRecoveryReveal: true,
|
||||
hasUnreadDivider: true,
|
||||
isProgrammaticScrollLocked: noProgrammaticLock,
|
||||
}),
|
||||
).toBe("recovery");
|
||||
});
|
||||
|
||||
it("preserves layout and explicit message placement precedence", () => {
|
||||
expect(
|
||||
resolveCompetingInitialScrollOwner({
|
||||
hasPendingLayoutRestore: true,
|
||||
hasExplicitScrollTarget: true,
|
||||
hasRecoveryReveal: true,
|
||||
hasUnreadDivider: true,
|
||||
isProgrammaticScrollLocked: noProgrammaticLock,
|
||||
}),
|
||||
@@ -30,10 +17,28 @@ describe("resolveCompetingInitialScrollOwner", () => {
|
||||
resolveCompetingInitialScrollOwner({
|
||||
hasPendingLayoutRestore: false,
|
||||
hasExplicitScrollTarget: true,
|
||||
hasRecoveryReveal: true,
|
||||
hasUnreadDivider: true,
|
||||
isProgrammaticScrollLocked: noProgrammaticLock,
|
||||
}),
|
||||
).toBe("explicit-target");
|
||||
});
|
||||
|
||||
it("uses the unread divider and then the programmatic owner for ordinary placement", () => {
|
||||
expect(
|
||||
resolveCompetingInitialScrollOwner({
|
||||
hasPendingLayoutRestore: false,
|
||||
hasExplicitScrollTarget: false,
|
||||
hasUnreadDivider: true,
|
||||
isProgrammaticScrollLocked: noProgrammaticLock,
|
||||
}),
|
||||
).toBe("unread-divider");
|
||||
expect(
|
||||
resolveCompetingInitialScrollOwner({
|
||||
hasPendingLayoutRestore: false,
|
||||
hasExplicitScrollTarget: false,
|
||||
hasUnreadDivider: false,
|
||||
isProgrammaticScrollLocked: () => true,
|
||||
}),
|
||||
).toBe("programmatic-scroll");
|
||||
});
|
||||
});
|
||||
|
||||
@@ -45,7 +45,6 @@ const SCROLL_KEYS = new Set([
|
||||
"PageUp",
|
||||
" ",
|
||||
]);
|
||||
const RECOVERY_SCROLL_KEYS = new Set(["ArrowDown", "End", "PageDown", " "]);
|
||||
|
||||
/** Writes a clamped maximum so the browser resolves the native bottom without
|
||||
* forcing a synchronous scrollHeight layout read. */
|
||||
@@ -234,112 +233,31 @@ type PrependScrollState = {
|
||||
anchorTop: number | null;
|
||||
};
|
||||
|
||||
type RecoveryRevealState = {
|
||||
key: string | null;
|
||||
keepAtTop: boolean;
|
||||
};
|
||||
|
||||
/** Transfers recovery scroll ownership only after a real downward gesture. */
|
||||
function useRecoveryPrependScrollOwnership({
|
||||
/** Captures the reader's current position between older-history requests. */
|
||||
function usePrependScrollStateCapture({
|
||||
scrollRef,
|
||||
recoveryRevealStateRef,
|
||||
isLoadingMoreRef,
|
||||
olderLoadPendingRef,
|
||||
newestItemKeyRef,
|
||||
scrollState,
|
||||
}: {
|
||||
scrollRef: React.RefObject<HTMLDivElement | null>;
|
||||
recoveryRevealStateRef: React.MutableRefObject<RecoveryRevealState>;
|
||||
isLoadingMoreRef: React.MutableRefObject<boolean>;
|
||||
olderLoadPendingRef: React.MutableRefObject<boolean>;
|
||||
newestItemKeyRef: React.MutableRefObject<string | null>;
|
||||
scrollState: React.MutableRefObject<PrependScrollState>;
|
||||
}) {
|
||||
useEffect(() => {
|
||||
const el = scrollRef.current;
|
||||
if (!el) return;
|
||||
let userScrollIntentUntil = 0;
|
||||
let pointerActive = false;
|
||||
let touchActive = false;
|
||||
let touchStartY: number | null = null;
|
||||
const markUserScrollIntent = () => {
|
||||
userScrollIntentUntil = Date.now() + USER_SCROLL_INTENT_WINDOW_MS;
|
||||
};
|
||||
const onWheel = (event: WheelEvent) => {
|
||||
if (event.deltaY > 0) markUserScrollIntent();
|
||||
};
|
||||
const onKeyDown = (event: KeyboardEvent) => {
|
||||
if (RECOVERY_SCROLL_KEYS.has(event.key)) markUserScrollIntent();
|
||||
};
|
||||
const onPointerDown = () => {
|
||||
pointerActive = true;
|
||||
markUserScrollIntent();
|
||||
};
|
||||
const onPointerUp = () => {
|
||||
pointerActive = false;
|
||||
};
|
||||
const onTouchStart = (event: TouchEvent) => {
|
||||
touchActive = true;
|
||||
touchStartY = event.touches[0]?.clientY ?? null;
|
||||
};
|
||||
const onTouchMove = (event: TouchEvent) => {
|
||||
const nextY = event.touches[0]?.clientY;
|
||||
if (touchStartY !== null && nextY !== undefined && nextY < touchStartY) {
|
||||
markUserScrollIntent();
|
||||
}
|
||||
};
|
||||
const onTouchEnd = () => {
|
||||
touchActive = false;
|
||||
touchStartY = null;
|
||||
};
|
||||
const onScroll = () => {
|
||||
const recoveryScrolledAway =
|
||||
recoveryRevealStateRef.current.keepAtTop &&
|
||||
el.scrollTop > 0 &&
|
||||
(userScrollIntentUntil >= Date.now() || pointerActive || touchActive);
|
||||
if (recoveryScrolledAway) {
|
||||
recoveryRevealStateRef.current.keepAtTop = false;
|
||||
if (olderLoadPendingRef.current || isLoadingMoreRef.current) {
|
||||
scrollState.current = capturePrependScrollState(el, newestItemKeyRef.current);
|
||||
}
|
||||
}
|
||||
// Native overflow anchoring can adjust scrollTop while the older page is
|
||||
// being inserted. Keep the pre-request baseline until our layout effect
|
||||
// has restored the visual position explicitly.
|
||||
const element = scrollRef.current;
|
||||
if (!element) return;
|
||||
const capture = () => {
|
||||
if (olderLoadPendingRef.current || isLoadingMoreRef.current) return;
|
||||
scrollState.current = capturePrependScrollState(el, newestItemKeyRef.current);
|
||||
scrollState.current = capturePrependScrollState(element, newestItemKeyRef.current);
|
||||
};
|
||||
scrollState.current = capturePrependScrollState(el, newestItemKeyRef.current);
|
||||
el.addEventListener("wheel", onWheel, { passive: true });
|
||||
el.addEventListener("keydown", onKeyDown);
|
||||
el.addEventListener("pointerdown", onPointerDown, { passive: true });
|
||||
el.addEventListener("pointerup", onPointerUp, { passive: true });
|
||||
el.addEventListener("pointercancel", onPointerUp, { passive: true });
|
||||
el.addEventListener("touchstart", onTouchStart, { passive: true });
|
||||
el.addEventListener("touchmove", onTouchMove, { passive: true });
|
||||
el.addEventListener("touchend", onTouchEnd, { passive: true });
|
||||
el.addEventListener("touchcancel", onTouchEnd, { passive: true });
|
||||
el.addEventListener("scroll", onScroll, { passive: true });
|
||||
return () => {
|
||||
el.removeEventListener("wheel", onWheel);
|
||||
el.removeEventListener("keydown", onKeyDown);
|
||||
el.removeEventListener("pointerdown", onPointerDown);
|
||||
el.removeEventListener("pointerup", onPointerUp);
|
||||
el.removeEventListener("pointercancel", onPointerUp);
|
||||
el.removeEventListener("touchstart", onTouchStart);
|
||||
el.removeEventListener("touchmove", onTouchMove);
|
||||
el.removeEventListener("touchend", onTouchEnd);
|
||||
el.removeEventListener("touchcancel", onTouchEnd);
|
||||
el.removeEventListener("scroll", onScroll);
|
||||
};
|
||||
}, [
|
||||
isLoadingMoreRef,
|
||||
newestItemKeyRef,
|
||||
olderLoadPendingRef,
|
||||
recoveryRevealStateRef,
|
||||
scrollRef,
|
||||
scrollState,
|
||||
]);
|
||||
capture();
|
||||
element.addEventListener("scroll", capture, { passive: true });
|
||||
return () => element.removeEventListener("scroll", capture);
|
||||
}, [isLoadingMoreRef, newestItemKeyRef, olderLoadPendingRef, scrollRef, scrollState]);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -359,7 +277,6 @@ function useScrollPositionOnPrepend(
|
||||
items: RenderItem[],
|
||||
isLoadingMore: boolean,
|
||||
isProgrammaticScrollLocked: () => boolean,
|
||||
recoveryRevealKey: string | null,
|
||||
): () => void {
|
||||
const scrollState = useRef<PrependScrollState>({
|
||||
scrollHeight: 0,
|
||||
@@ -370,22 +287,11 @@ function useScrollPositionOnPrepend(
|
||||
const isLoadingMoreRef = useRef(isLoadingMore);
|
||||
const olderLoadPendingRef = useRef(false);
|
||||
const newestItemKeyRef = useRef<string | null>(getNewestNonSyntheticItemKey(items));
|
||||
const recoveryRevealStateRef = useRef({
|
||||
key: recoveryRevealKey,
|
||||
keepAtTop: recoveryRevealKey !== null,
|
||||
});
|
||||
if (recoveryRevealStateRef.current.key !== recoveryRevealKey) {
|
||||
recoveryRevealStateRef.current = {
|
||||
key: recoveryRevealKey,
|
||||
keepAtTop: recoveryRevealKey !== null,
|
||||
};
|
||||
}
|
||||
isLoadingMoreRef.current = isLoadingMore;
|
||||
if (isLoadingMore) olderLoadPendingRef.current = true;
|
||||
newestItemKeyRef.current = getNewestNonSyntheticItemKey(items);
|
||||
useRecoveryPrependScrollOwnership({
|
||||
usePrependScrollStateCapture({
|
||||
scrollRef,
|
||||
recoveryRevealStateRef,
|
||||
isLoadingMoreRef,
|
||||
olderLoadPendingRef,
|
||||
newestItemKeyRef,
|
||||
@@ -417,11 +323,6 @@ function useScrollPositionOnPrepend(
|
||||
prevFirstKeyRef.current = nextFirstKey;
|
||||
if (olderLoadSettled) olderLoadPendingRef.current = false;
|
||||
if (!el || !prepend || isProgrammaticScrollLocked()) return;
|
||||
if (recoveryRevealStateRef.current.key !== null && recoveryRevealStateRef.current.keepAtTop) {
|
||||
if (el.scrollTop !== 0) el.scrollTop = 0;
|
||||
scrollState.current = capturePrependScrollState(el, newestItemKeyRef.current);
|
||||
return;
|
||||
}
|
||||
const prev = scrollState.current;
|
||||
const anchor = findMessageRow(el, prev.anchorKey);
|
||||
if (anchor && prev.anchorTop !== null) {
|
||||
@@ -1311,8 +1212,6 @@ type InitialScrollApplyParams = {
|
||||
isNearBottomRef: React.RefObject<boolean>;
|
||||
envSwitchPlacementToken: number | null;
|
||||
hasUnreadDivider: boolean;
|
||||
recoveryRevealKey: string | null;
|
||||
recoveryPlacementPendingRef: React.RefObject<boolean>;
|
||||
isProgrammaticScrollLocked: () => boolean;
|
||||
phase: "provisional" | "final";
|
||||
};
|
||||
@@ -1320,11 +1219,9 @@ type InitialScrollApplyParams = {
|
||||
function markInitialScrollConsumed(
|
||||
didInitialScroll: React.RefObject<boolean>,
|
||||
activationPendingRef: React.RefObject<boolean>,
|
||||
recoveryPlacementPendingRef: React.RefObject<boolean>,
|
||||
): void {
|
||||
didInitialScroll.current = true;
|
||||
activationPendingRef.current = false;
|
||||
recoveryPlacementPendingRef.current = false;
|
||||
}
|
||||
|
||||
function completeEnvSwitchPlacement(envSwitchPlacementToken: number | null): void {
|
||||
@@ -1348,30 +1245,23 @@ function isCurrentEnvSwitchPlacement(
|
||||
export type CompetingInitialScrollOwner =
|
||||
| "layout-restore"
|
||||
| "explicit-target"
|
||||
| "recovery"
|
||||
| "unread-divider"
|
||||
| "programmatic-scroll";
|
||||
|
||||
export function resolveCompetingInitialScrollOwner(params: {
|
||||
hasPendingLayoutRestore: boolean;
|
||||
hasExplicitScrollTarget: boolean;
|
||||
hasRecoveryReveal: boolean;
|
||||
hasUnreadDivider: boolean;
|
||||
isProgrammaticScrollLocked: () => boolean;
|
||||
}): CompetingInitialScrollOwner | null {
|
||||
if (params.hasPendingLayoutRestore) return "layout-restore";
|
||||
if (params.hasExplicitScrollTarget) return "explicit-target";
|
||||
if (params.hasRecoveryReveal) return "recovery";
|
||||
if (params.hasUnreadDivider) return "unread-divider";
|
||||
if (params.isProgrammaticScrollLocked()) return "programmatic-scroll";
|
||||
return null;
|
||||
}
|
||||
|
||||
function resolveInitialPlacementOwner(
|
||||
enabled: boolean,
|
||||
recoveryRevealKey: string | null,
|
||||
): "recovery" | "bottom" | "saved-position" {
|
||||
if (recoveryRevealKey !== null) return "recovery";
|
||||
function resolveInitialPlacementOwner(enabled: boolean): "bottom" | "saved-position" {
|
||||
return enabled ? "bottom" : "saved-position";
|
||||
}
|
||||
|
||||
@@ -1381,13 +1271,12 @@ function reportInitialPlacement(params: {
|
||||
sessionId: string | null;
|
||||
token: number | null;
|
||||
enabled: boolean;
|
||||
recoveryRevealKey: string | null;
|
||||
}): void {
|
||||
if (!isDebug()) return;
|
||||
placementDebug(`${params.phase} placement`, {
|
||||
sessionId: params.sessionId,
|
||||
token: params.token,
|
||||
owner: resolveInitialPlacementOwner(params.enabled, params.recoveryRevealKey),
|
||||
owner: resolveInitialPlacementOwner(params.enabled),
|
||||
scrollTop: params.element.scrollTop,
|
||||
scrollHeight: params.element.scrollHeight,
|
||||
clientHeight: params.element.clientHeight,
|
||||
@@ -1434,8 +1323,6 @@ function applyInitialScrollPosition(params: InitialScrollApplyParams): void {
|
||||
isNearBottomRef,
|
||||
envSwitchPlacementToken,
|
||||
hasUnreadDivider,
|
||||
recoveryRevealKey,
|
||||
recoveryPlacementPendingRef,
|
||||
isProgrammaticScrollLocked,
|
||||
phase,
|
||||
} = params;
|
||||
@@ -1455,18 +1342,17 @@ function applyInitialScrollPosition(params: InitialScrollApplyParams): void {
|
||||
const competingOwner = resolveCompetingInitialScrollOwner({
|
||||
hasPendingLayoutRestore,
|
||||
hasExplicitScrollTarget,
|
||||
hasRecoveryReveal: recoveryRevealKey !== null,
|
||||
hasUnreadDivider,
|
||||
isProgrammaticScrollLocked,
|
||||
});
|
||||
if (competingOwner && competingOwner !== "recovery") {
|
||||
if (competingOwner) {
|
||||
if (phase === "provisional") return;
|
||||
placementDebug(`${phase} placement delegated`, {
|
||||
sessionId,
|
||||
owner: competingOwner,
|
||||
token: envSwitchPlacementToken,
|
||||
});
|
||||
markInitialScrollConsumed(didInitialScroll, activationPendingRef, recoveryPlacementPendingRef);
|
||||
markInitialScrollConsumed(didInitialScroll, activationPendingRef);
|
||||
completeEnvSwitchPlacement(envSwitchPlacementToken);
|
||||
return;
|
||||
}
|
||||
@@ -1475,17 +1361,14 @@ function applyInitialScrollPosition(params: InitialScrollApplyParams): void {
|
||||
getStoredAutoScrollTop(sessionId) ??
|
||||
undefined)
|
||||
: undefined;
|
||||
const scrollTop =
|
||||
competingOwner === "recovery"
|
||||
? 0
|
||||
: resolveNativeInitialScrollTop({
|
||||
enabled,
|
||||
hasPendingLayoutRestore,
|
||||
savedScrollTop,
|
||||
scrollHeight: element.scrollHeight,
|
||||
});
|
||||
const scrollTop = resolveNativeInitialScrollTop({
|
||||
enabled,
|
||||
hasPendingLayoutRestore,
|
||||
savedScrollTop,
|
||||
scrollHeight: element.scrollHeight,
|
||||
});
|
||||
if (phase === "final") {
|
||||
markInitialScrollConsumed(didInitialScroll, activationPendingRef, recoveryPlacementPendingRef);
|
||||
markInitialScrollConsumed(didInitialScroll, activationPendingRef);
|
||||
}
|
||||
if (scrollTop === null) {
|
||||
completeFinalEnvSwitchPlacement(phase, envSwitchPlacementToken);
|
||||
@@ -1507,7 +1390,6 @@ function applyInitialScrollPosition(params: InitialScrollApplyParams): void {
|
||||
sessionId,
|
||||
token: envSwitchPlacementToken,
|
||||
enabled,
|
||||
recoveryRevealKey,
|
||||
});
|
||||
finishAppliedInitialPlacement({
|
||||
phase,
|
||||
@@ -1528,31 +1410,16 @@ function shouldSkipProvisionalPlacement(
|
||||
return phase === "provisional" && (hasUnreadDivider || appliedToken === currentToken);
|
||||
}
|
||||
|
||||
function useInitialPlacementLatches(
|
||||
envSwitchPlacementToken: number | null,
|
||||
recoveryRevealKey: string | null,
|
||||
) {
|
||||
function useInitialPlacementLatches(envSwitchPlacementToken: number | null) {
|
||||
const didInitialScroll = useRef(false);
|
||||
const lastTokenRef = useRef<number | null>(null);
|
||||
const provisionalTokenRef = useRef<number | null>(null);
|
||||
const lastRecoveryRevealKeyRef = useRef<string | null>(null);
|
||||
const recoveryPlacementPendingRef = useRef(recoveryRevealKey !== null);
|
||||
if (envSwitchPlacementToken !== null && envSwitchPlacementToken !== lastTokenRef.current) {
|
||||
lastTokenRef.current = envSwitchPlacementToken;
|
||||
provisionalTokenRef.current = null;
|
||||
didInitialScroll.current = false;
|
||||
}
|
||||
if (recoveryRevealKey !== null && recoveryRevealKey !== lastRecoveryRevealKeyRef.current) {
|
||||
lastRecoveryRevealKeyRef.current = recoveryRevealKey;
|
||||
provisionalTokenRef.current = null;
|
||||
didInitialScroll.current = false;
|
||||
recoveryPlacementPendingRef.current = true;
|
||||
}
|
||||
if (recoveryRevealKey === null) {
|
||||
lastRecoveryRevealKeyRef.current = null;
|
||||
recoveryPlacementPendingRef.current = false;
|
||||
}
|
||||
return { didInitialScroll, provisionalTokenRef, recoveryPlacementPendingRef };
|
||||
return { didInitialScroll, provisionalTokenRef };
|
||||
}
|
||||
|
||||
type InitialPlacementLatches = ReturnType<typeof useInitialPlacementLatches>;
|
||||
@@ -1569,7 +1436,6 @@ type InitialScrollPositionParams = {
|
||||
envSwitchPlacementToken: number | null;
|
||||
isRestoringLayout: boolean;
|
||||
isProgrammaticScrollLocked: () => boolean;
|
||||
recoveryRevealKey: string | null;
|
||||
placementLatches: InitialPlacementLatches;
|
||||
};
|
||||
|
||||
@@ -1579,7 +1445,6 @@ type InitialScrollPositionEffectParams = Omit<InitialScrollPositionParams, "plac
|
||||
provisionalTokenRef: React.RefObject<number | null>;
|
||||
isVisibleRef: React.RefObject<boolean>;
|
||||
activationPendingRef: React.RefObject<boolean>;
|
||||
recoveryPlacementPendingRef: React.RefObject<boolean>;
|
||||
};
|
||||
|
||||
function runInitialScrollPositionEffect(
|
||||
@@ -1597,19 +1462,17 @@ function runInitialScrollPositionEffect(
|
||||
envSwitchPlacementToken,
|
||||
isRestoringLayout,
|
||||
isProgrammaticScrollLocked,
|
||||
recoveryRevealKey,
|
||||
storeApi,
|
||||
didInitialScroll,
|
||||
provisionalTokenRef,
|
||||
isVisibleRef,
|
||||
activationPendingRef,
|
||||
recoveryPlacementPendingRef,
|
||||
} = params;
|
||||
if (!isVisible || (envSwitchPlacementToken !== null && isRestoringLayout)) return;
|
||||
const hasEmptyTranscript = itemCount === 0 && recoveryRevealKey === null;
|
||||
const hasEmptyTranscript = itemCount === 0;
|
||||
if (envSwitchPlacementToken !== null && hasEmptyTranscript) {
|
||||
if (historyRefreshPending) return;
|
||||
markInitialScrollConsumed(didInitialScroll, activationPendingRef, recoveryPlacementPendingRef);
|
||||
markInitialScrollConsumed(didInitialScroll, activationPendingRef);
|
||||
completeEnvSwitchPlacement(envSwitchPlacementToken);
|
||||
return;
|
||||
}
|
||||
@@ -1640,8 +1503,6 @@ function runInitialScrollPositionEffect(
|
||||
isNearBottomRef,
|
||||
envSwitchPlacementToken,
|
||||
hasUnreadDivider,
|
||||
recoveryRevealKey,
|
||||
recoveryPlacementPendingRef,
|
||||
isProgrammaticScrollLocked,
|
||||
phase,
|
||||
});
|
||||
@@ -1664,11 +1525,10 @@ function useInitialScrollPosition({
|
||||
envSwitchPlacementToken,
|
||||
isRestoringLayout,
|
||||
isProgrammaticScrollLocked,
|
||||
recoveryRevealKey,
|
||||
placementLatches,
|
||||
}: InitialScrollPositionParams) {
|
||||
const storeApi = useAppStoreApi();
|
||||
const { didInitialScroll, provisionalTokenRef, recoveryPlacementPendingRef } = placementLatches;
|
||||
const { didInitialScroll, provisionalTokenRef } = placementLatches;
|
||||
const { isVisibleRef, activationPendingRef } = useActivationPending(
|
||||
isVisible,
|
||||
envSwitchPlacementToken,
|
||||
@@ -1687,13 +1547,11 @@ function useInitialScrollPosition({
|
||||
envSwitchPlacementToken,
|
||||
isRestoringLayout,
|
||||
isProgrammaticScrollLocked,
|
||||
recoveryRevealKey,
|
||||
storeApi,
|
||||
didInitialScroll,
|
||||
provisionalTokenRef,
|
||||
isVisibleRef,
|
||||
activationPendingRef,
|
||||
recoveryPlacementPendingRef,
|
||||
}),
|
||||
[
|
||||
itemCount,
|
||||
@@ -1707,7 +1565,6 @@ function useInitialScrollPosition({
|
||||
envSwitchPlacementToken,
|
||||
isRestoringLayout,
|
||||
isProgrammaticScrollLocked,
|
||||
recoveryRevealKey,
|
||||
scrollRef,
|
||||
],
|
||||
);
|
||||
@@ -1728,7 +1585,6 @@ type NativeScrollManagementParams = {
|
||||
isLoadingMore: boolean;
|
||||
loadMore: () => Promise<number>;
|
||||
isVisible: boolean;
|
||||
recoveryRevealKey?: string | null;
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -1755,7 +1611,6 @@ export function useNativeScrollManagement(params: NativeScrollManagementParams)
|
||||
isLoadingMore,
|
||||
loadMore,
|
||||
isVisible,
|
||||
recoveryRevealKey = null,
|
||||
} = params;
|
||||
const pendingChatInitialPlacement = useDockviewStore(
|
||||
(state) => state.pendingChatInitialPlacement,
|
||||
@@ -1763,9 +1618,8 @@ export function useNativeScrollManagement(params: NativeScrollManagementParams)
|
||||
const isRestoringLayout = useDockviewStore((state) => state.isRestoringLayout);
|
||||
const envSwitchPlacementToken =
|
||||
pendingChatInitialPlacement?.sessionId === sessionId ? pendingChatInitialPlacement.token : null;
|
||||
const placementLatches = useInitialPlacementLatches(envSwitchPlacementToken, recoveryRevealKey);
|
||||
const initialPlacementPending =
|
||||
envSwitchPlacementToken !== null || placementLatches.recoveryPlacementPendingRef.current;
|
||||
const placementLatches = useInitialPlacementLatches(envSwitchPlacementToken);
|
||||
const initialPlacementPending = envSwitchPlacementToken !== null;
|
||||
const programmaticScrollLockRef = useRef(false);
|
||||
const isProgrammaticScrollLocked = useCallback(() => programmaticScrollLockRef.current, []);
|
||||
const { isNearBottomRef, resyncIsNearBottom, markNotNearBottom } = useAutoScroll({
|
||||
@@ -1790,7 +1644,6 @@ export function useNativeScrollManagement(params: NativeScrollManagementParams)
|
||||
items,
|
||||
isLoadingMore,
|
||||
isProgrammaticScrollLocked,
|
||||
recoveryRevealKey,
|
||||
);
|
||||
const loadMoreWithPrependBaseline = useCallback(() => {
|
||||
beginOlderLoad();
|
||||
@@ -1825,7 +1678,6 @@ export function useNativeScrollManagement(params: NativeScrollManagementParams)
|
||||
envSwitchPlacementToken,
|
||||
isRestoringLayout,
|
||||
isProgrammaticScrollLocked,
|
||||
recoveryRevealKey,
|
||||
placementLatches,
|
||||
});
|
||||
|
||||
|
||||
@@ -86,11 +86,6 @@ const HARNESS_RENDER_ERROR = "harness did not render";
|
||||
const NATIVE_SCROLL_MANAGEMENT_TEST_ID = "native-scroll-management-container";
|
||||
const AUTO_SCROLL_CONTAINER_TEST_ID = "auto-scroll-container";
|
||||
const CACHED_MESSAGE_ID = "cached-message";
|
||||
const RECOVERY_SESSION_ID = "session-recovery";
|
||||
const RECOVERY_MESSAGE_ID = "recovery-message";
|
||||
const OLDEST_ACTIVITY_ID = "activity-old";
|
||||
const NEWEST_MESSAGE_ID = "newest";
|
||||
const OLDER_MESSAGE_ID = "older";
|
||||
const TEST_MESSAGES = [{} as Message];
|
||||
/** Always returns false: the harness never locks programmatic scrolling. */
|
||||
const NEVER_LOCKED = () => false;
|
||||
@@ -114,7 +109,6 @@ function Harness({
|
||||
enabled = true,
|
||||
sessionId = null,
|
||||
isProgrammaticScrollLocked = NEVER_LOCKED,
|
||||
recoveryRevealKey = null,
|
||||
}: {
|
||||
itemCount: number;
|
||||
anchoredBarOffsetPx: number;
|
||||
@@ -127,7 +121,6 @@ function Harness({
|
||||
enabled?: boolean;
|
||||
sessionId?: string | null;
|
||||
isProgrammaticScrollLocked?: () => boolean;
|
||||
recoveryRevealKey?: string | null;
|
||||
}) {
|
||||
const scrollRef = useRef<HTMLDivElement>(null);
|
||||
useLayoutEffect(() => {
|
||||
@@ -155,7 +148,6 @@ function Harness({
|
||||
sessionId,
|
||||
isProgrammaticScrollLocked,
|
||||
isVisible,
|
||||
recoveryRevealKey,
|
||||
} as Parameters<typeof useScrollToDividerOrBottom>[4];
|
||||
useScrollToDividerOrBottom(scrollRef, itemCount, dividerKey, anchoredBarOffsetPx, scrollOptions);
|
||||
return (
|
||||
@@ -290,7 +282,6 @@ function NativeScrollManagementHarness({
|
||||
historyRefreshPending = false,
|
||||
hasUnreadDivider = false,
|
||||
hasMore = true,
|
||||
recoveryRevealKey = null,
|
||||
}: {
|
||||
items: RenderItem[];
|
||||
messages?: Message[];
|
||||
@@ -304,7 +295,6 @@ function NativeScrollManagementHarness({
|
||||
historyRefreshPending?: boolean;
|
||||
hasUnreadDivider?: boolean;
|
||||
hasMore?: boolean;
|
||||
recoveryRevealKey?: string | null;
|
||||
}) {
|
||||
const scrollRef = useRef<HTMLDivElement>(null);
|
||||
useNativeScrollMetrics(scrollRef, metrics);
|
||||
@@ -322,7 +312,6 @@ function NativeScrollManagementHarness({
|
||||
loadMore,
|
||||
isVisible,
|
||||
historyRefreshPending,
|
||||
recoveryRevealKey,
|
||||
});
|
||||
if (recoveryRef) recoveryRef.current = showRecovery;
|
||||
return (
|
||||
@@ -371,301 +360,6 @@ describe("isElementInPreloadRegion", () => {
|
||||
|
||||
// eslint-disable-next-line max-lines-per-function -- pagination invariants share one fixture and lifecycle.
|
||||
describe("useNativeScrollManagement transcript pagination", () => {
|
||||
it("reveals recovery at the top once per error stamp and preserves same-stamp scrolling", () => {
|
||||
const metrics = { scrollHeight: 1000, scrollTop: 240, clientHeight: 400 };
|
||||
const { rerender } = render(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(RECOVERY_MESSAGE_ID)]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
recoveryRevealKey="session-recovery:bootstrap-1"
|
||||
/>,
|
||||
);
|
||||
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
|
||||
metrics.scrollTop = 240;
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(RECOVERY_MESSAGE_ID)]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
recoveryRevealKey="session-recovery:bootstrap-1"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(240);
|
||||
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(RECOVERY_MESSAGE_ID)]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(240);
|
||||
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(RECOVERY_MESSAGE_ID)]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
recoveryRevealKey="session-recovery:bootstrap-1"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
|
||||
metrics.scrollTop = 240;
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(RECOVERY_MESSAGE_ID)]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
recoveryRevealKey="session-recovery:bootstrap-2"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
});
|
||||
|
||||
// eslint-disable-next-line max-lines-per-function -- recovery ownership and the subsequent prepend handoff share one controlled lifecycle.
|
||||
it("keeps recovery visible while an older page settles, then resumes normal anchoring after user scroll", async () => {
|
||||
const page = Promise.withResolvers<number>();
|
||||
const metrics = { scrollHeight: 100, scrollTop: 0, clientHeight: 50 };
|
||||
const activity = transcriptActivity(OLDEST_ACTIVITY_ID, "turn-1");
|
||||
const newest = transcriptMessage(NEWEST_MESSAGE_ID);
|
||||
const { rerender } = render(
|
||||
<NativeScrollManagementHarness
|
||||
items={[activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
loadMore={() => page.promise}
|
||||
recoveryRevealKey="session-recovery:failure-1"
|
||||
/>,
|
||||
);
|
||||
const scroller = screen.getByTestId(NATIVE_SCROLL_MANAGEMENT_TEST_ID);
|
||||
const wrappedLoadMore = sharedSentinelCalls.at(-1)?.[4] as () => Promise<number>;
|
||||
|
||||
const pendingLoad = wrappedLoadMore();
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
isLoadingMore
|
||||
loadMore={() => page.promise}
|
||||
recoveryRevealKey="session-recovery:failure-1"
|
||||
/>,
|
||||
);
|
||||
metrics.scrollHeight = 200;
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(OLDER_MESSAGE_ID), activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
isLoadingMore
|
||||
loadMore={() => page.promise}
|
||||
recoveryRevealKey="session-recovery:failure-1"
|
||||
/>,
|
||||
);
|
||||
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
|
||||
page.resolve(1);
|
||||
await act(async () => {
|
||||
await pendingLoad;
|
||||
});
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(OLDER_MESSAGE_ID), activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
loadMore={() => page.promise}
|
||||
recoveryRevealKey="session-recovery:failure-1"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
|
||||
const nextPage = Promise.withResolvers<number>();
|
||||
const nextLoadMore = sharedSentinelCalls.at(-1)?.[4] as () => Promise<number>;
|
||||
const pendingNextLoad = nextLoadMore();
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(OLDER_MESSAGE_ID), activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
isLoadingMore
|
||||
loadMore={() => nextPage.promise}
|
||||
recoveryRevealKey="session-recovery:failure-1"
|
||||
/>,
|
||||
);
|
||||
act(() => {
|
||||
scroller.dispatchEvent(new WheelEvent("wheel", { deltaY: 100 }));
|
||||
metrics.scrollTop = 40;
|
||||
scroller.dispatchEvent(new Event("scroll"));
|
||||
});
|
||||
expect(metrics.scrollTop).toBe(40);
|
||||
|
||||
metrics.scrollHeight = 300;
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[
|
||||
transcriptMessage("older-2"),
|
||||
transcriptMessage(OLDER_MESSAGE_ID),
|
||||
activity,
|
||||
newest,
|
||||
]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
isLoadingMore
|
||||
loadMore={() => nextPage.promise}
|
||||
recoveryRevealKey="session-recovery:failure-1"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(140);
|
||||
|
||||
nextPage.resolve(1);
|
||||
await act(async () => {
|
||||
await pendingNextLoad;
|
||||
});
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[
|
||||
transcriptMessage("older-2"),
|
||||
transcriptMessage(OLDER_MESSAGE_ID),
|
||||
activity,
|
||||
newest,
|
||||
]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
loadMore={() => nextPage.promise}
|
||||
recoveryRevealKey="session-recovery:failure-1"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(140);
|
||||
});
|
||||
|
||||
it("keeps an already-loading older page below a newly revealed recovery card", async () => {
|
||||
const page = Promise.withResolvers<number>();
|
||||
const metrics = { scrollHeight: 100, scrollTop: 0, clientHeight: 50 };
|
||||
const activity = transcriptActivity(OLDEST_ACTIVITY_ID, "turn-1");
|
||||
const newest = transcriptMessage(NEWEST_MESSAGE_ID);
|
||||
const { rerender } = render(
|
||||
<NativeScrollManagementHarness
|
||||
items={[activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
loadMore={() => page.promise}
|
||||
/>,
|
||||
);
|
||||
const wrappedLoadMore = sharedSentinelCalls.at(-1)?.[4] as () => Promise<number>;
|
||||
const pendingLoad = wrappedLoadMore();
|
||||
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
isLoadingMore
|
||||
loadMore={() => page.promise}
|
||||
/>,
|
||||
);
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
isLoadingMore
|
||||
loadMore={() => page.promise}
|
||||
recoveryRevealKey="session-recovery:failure-2"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
|
||||
metrics.scrollHeight = 200;
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(OLDER_MESSAGE_ID), activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
isLoadingMore
|
||||
loadMore={() => page.promise}
|
||||
recoveryRevealKey="session-recovery:failure-2"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
|
||||
page.resolve(1);
|
||||
await act(async () => {
|
||||
await pendingLoad;
|
||||
});
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[transcriptMessage(OLDER_MESSAGE_ID), activity, newest]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
loadMore={() => page.promise}
|
||||
recoveryRevealKey="session-recovery:failure-2"
|
||||
/>,
|
||||
);
|
||||
expect(metrics.scrollTop).toBe(0);
|
||||
});
|
||||
|
||||
it("resumes normal auto-scroll after the initial recovery placement is consumed", () => {
|
||||
const metrics = { scrollHeight: 100, scrollTop: 0, clientHeight: 50 };
|
||||
const firstMessage = { id: "first-message" } as Message;
|
||||
const scrollerMessages = [firstMessage];
|
||||
const activity = transcriptActivity(OLDEST_ACTIVITY_ID, "turn-1");
|
||||
const newest = transcriptMessage(NEWEST_MESSAGE_ID);
|
||||
const { rerender } = render(
|
||||
<NativeScrollManagementHarness
|
||||
items={[activity, newest]}
|
||||
messages={scrollerMessages}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
hasMore={false}
|
||||
recoveryRevealKey="session-recovery:placement-1"
|
||||
/>,
|
||||
);
|
||||
const scroller = screen.getByTestId(NATIVE_SCROLL_MANAGEMENT_TEST_ID);
|
||||
|
||||
metrics.scrollTop = 50;
|
||||
act(() => {
|
||||
scroller.dispatchEvent(new WheelEvent("wheel", { deltaY: 100 }));
|
||||
scroller.dispatchEvent(new Event("scroll"));
|
||||
});
|
||||
metrics.scrollHeight = 150;
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[activity, newest]}
|
||||
messages={[...scrollerMessages, { id: "second-message" } as Message]}
|
||||
metrics={metrics}
|
||||
sessionId={RECOVERY_SESSION_ID}
|
||||
enabled
|
||||
hasMore={false}
|
||||
recoveryRevealKey="session-recovery:placement-1"
|
||||
/>,
|
||||
);
|
||||
|
||||
expect(metrics.scrollTop).toBe(2_147_483_647);
|
||||
});
|
||||
|
||||
// @covers AC-UI-TRANSCRIPT-AUTO-SCROLL-001.11
|
||||
// @covers AC-UI-TRANSCRIPT-AUTO-SCROLL-001.14
|
||||
it("places cached enabled history before refresh and reconciles after it settles", () => {
|
||||
@@ -1049,48 +743,6 @@ describe("useNativeScrollManagement transcript pagination", () => {
|
||||
expect(sharedSentinelRecheck).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does not recheck a restored transcript while explicit recovery is active", () => {
|
||||
const requestAnimationFrame = vi
|
||||
.spyOn(window, "requestAnimationFrame")
|
||||
.mockImplementation((callback) => {
|
||||
callback(0);
|
||||
return 1;
|
||||
});
|
||||
const recoveryRef = { current: false };
|
||||
const { rerender } = render(
|
||||
<NativeScrollManagementHarness
|
||||
items={[]}
|
||||
sessionId="session-1"
|
||||
recoveryRef={recoveryRef}
|
||||
isVisible={false}
|
||||
/>,
|
||||
);
|
||||
const options = sharedSentinelCalls.at(-1)?.[5] as {
|
||||
onLoadSettled: (result: {
|
||||
count: number;
|
||||
rejected: boolean;
|
||||
continuation: "no-progress";
|
||||
}) => void;
|
||||
};
|
||||
act(() => {
|
||||
options.onLoadSettled({ count: 0, rejected: false, continuation: "no-progress" });
|
||||
});
|
||||
sharedSentinelRecheck.mockClear();
|
||||
|
||||
rerender(
|
||||
<NativeScrollManagementHarness
|
||||
items={[]}
|
||||
sessionId="session-1"
|
||||
recoveryRef={recoveryRef}
|
||||
isVisible
|
||||
/>,
|
||||
);
|
||||
|
||||
expect(recoveryRef.current).toBe(true);
|
||||
expect(sharedSentinelRecheck).not.toHaveBeenCalled();
|
||||
requestAnimationFrame.mockRestore();
|
||||
});
|
||||
|
||||
it("retries a disarmed short page on the next upward scroll", () => {
|
||||
const metrics = { scrollHeight: 1000, scrollTop: 100, clientHeight: 400 };
|
||||
render(<NativeScrollManagementHarness items={[]} metrics={metrics} />);
|
||||
@@ -1351,18 +1003,10 @@ describe("useNativeScrollManagement transcript pagination", () => {
|
||||
|
||||
// eslint-disable-next-line max-lines-per-function -- this suite keeps the related scroll invariants together.
|
||||
describe("useScrollToDividerOrBottom — anchored-bar offset", () => {
|
||||
it("leaves an active recovery transcript at the top for its first reveal", () => {
|
||||
render(
|
||||
<Harness
|
||||
itemCount={2}
|
||||
anchoredBarOffsetPx={0}
|
||||
dividerKey={null}
|
||||
scrollHeight={1000}
|
||||
recoveryRevealKey="session-1:bootstrap-1"
|
||||
/>,
|
||||
);
|
||||
it("places an enabled transcript at the bottom on its first render", () => {
|
||||
render(<Harness itemCount={2} anchoredBarOffsetPx={0} dividerKey={null} scrollHeight={1000} />);
|
||||
|
||||
expect(screen.getByTestId(DIVIDER_SCROLL_CONTAINER_TEST_ID).scrollTop).toBe(0);
|
||||
expect(screen.getByTestId(DIVIDER_SCROLL_CONTAINER_TEST_ID).scrollTop).toBe(1000);
|
||||
});
|
||||
|
||||
it("waits for an inactive transcript to become visible before placing the initial view", () => {
|
||||
|
||||
@@ -2,15 +2,7 @@
|
||||
|
||||
/* eslint-disable max-lines -- native transcript composition owns scrolling. */
|
||||
|
||||
import {
|
||||
useEffect,
|
||||
useMemo,
|
||||
useRef,
|
||||
memo,
|
||||
forwardRef,
|
||||
useImperativeHandle,
|
||||
type ReactNode,
|
||||
} from "react";
|
||||
import { useEffect, useMemo, useRef, memo, forwardRef, useImperativeHandle } from "react";
|
||||
import { SessionPanelContent } from "@kandev/ui/pannel-session";
|
||||
import type { Message, TaskSessionState } from "@/lib/types/http";
|
||||
import type { RenderItem } from "@/hooks/use-processed-messages";
|
||||
@@ -110,7 +102,6 @@ type NativeMessageListScrollParams = {
|
||||
/** Changes when transcript status rows can add/remove space above messages. */
|
||||
scrollLayoutKey: string;
|
||||
isVisible: boolean;
|
||||
recoveryRevealKey?: string | null;
|
||||
};
|
||||
|
||||
type ScrollToDividerOptions = {
|
||||
@@ -121,22 +112,8 @@ type ScrollToDividerOptions = {
|
||||
isProgrammaticScrollLocked?: () => boolean;
|
||||
isVisible?: boolean;
|
||||
historyRefreshPending?: boolean;
|
||||
recoveryRevealKey?: string | null;
|
||||
};
|
||||
|
||||
function consumeRecoveryRevealForDivider(
|
||||
recoveryRevealKey: string | null,
|
||||
didInitialScroll: React.RefObject<boolean>,
|
||||
activationPendingRef: React.RefObject<boolean>,
|
||||
): boolean {
|
||||
if (recoveryRevealKey === null) return false;
|
||||
// The native initial-position hook owns the recovery reveal. Mark this
|
||||
// hook consumed so its normal bottom/divider placement cannot override it.
|
||||
didInitialScroll.current = true;
|
||||
activationPendingRef.current = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
function useNativeMessageListScroll(params: NativeMessageListScrollParams) {
|
||||
const {
|
||||
scrollRef,
|
||||
@@ -159,7 +136,6 @@ function useNativeMessageListScroll(params: NativeMessageListScrollParams) {
|
||||
onFirstMessageHiddenChange,
|
||||
scrollLayoutKey,
|
||||
isVisible,
|
||||
recoveryRevealKey,
|
||||
} = params;
|
||||
const {
|
||||
handleScrollToMessage,
|
||||
@@ -182,7 +158,6 @@ function useNativeMessageListScroll(params: NativeMessageListScrollParams) {
|
||||
isLoadingMore,
|
||||
loadMore,
|
||||
isVisible,
|
||||
recoveryRevealKey,
|
||||
});
|
||||
const anchoredBarOffsetPx = anchoredBarScrollOffsetPx(anchoredBarHeight);
|
||||
useEffect(() => {
|
||||
@@ -196,7 +171,6 @@ function useNativeMessageListScroll(params: NativeMessageListScrollParams) {
|
||||
isProgrammaticScrollLocked,
|
||||
isVisible,
|
||||
historyRefreshPending,
|
||||
recoveryRevealKey,
|
||||
});
|
||||
useImperativeHandle(ref, () => ({ scrollToMessage: handleScrollToMessage }), [
|
||||
handleScrollToMessage,
|
||||
@@ -304,7 +278,6 @@ type NativeMessageListBodyProps = {
|
||||
onScrollToMessage: (messageId: string, options?: { align?: "start" | "center" }) => void;
|
||||
autoScrollEnabled: boolean;
|
||||
dividerBeforeItemKey?: string | null;
|
||||
prependContent?: ReactNode;
|
||||
launchErrorOwned: boolean;
|
||||
launchErrorStamp?: string;
|
||||
launchErrorOccurredAt?: string;
|
||||
@@ -346,7 +319,7 @@ type NativeMessageListBodyProps = {
|
||||
* keep their existing visible-host behavior without participating in read
|
||||
* tracking.
|
||||
*/
|
||||
// eslint-disable-next-line max-lines-per-function -- divider and recovery placement share one scroll lifecycle.
|
||||
// eslint-disable-next-line max-lines-per-function -- divider and initial placement share one scroll lifecycle.
|
||||
export function useScrollToDividerOrBottom(
|
||||
scrollRef: React.RefObject<HTMLDivElement | null>,
|
||||
itemCount: number,
|
||||
@@ -362,7 +335,6 @@ export function useScrollToDividerOrBottom(
|
||||
isProgrammaticScrollLocked = () => false,
|
||||
isVisible = true,
|
||||
historyRefreshPending = false,
|
||||
recoveryRevealKey = null,
|
||||
} = options;
|
||||
const { isVisibleRef, activationPendingRef } = useActivationPending(isVisible);
|
||||
const isUserScrollingRef = useDividerUserScrolling(scrollRef);
|
||||
@@ -393,8 +365,6 @@ export function useScrollToDividerOrBottom(
|
||||
}
|
||||
const el = scrollRef.current;
|
||||
if (!el || historyRefreshPending) return;
|
||||
if (consumeRecoveryRevealForDivider(recoveryRevealKey, didInitialScroll, activationPendingRef))
|
||||
return;
|
||||
if (itemCount === 0) return;
|
||||
|
||||
const placeInitialPosition = () => {
|
||||
@@ -464,7 +434,6 @@ export function useScrollToDividerOrBottom(
|
||||
isProgrammaticScrollLocked,
|
||||
isVisible,
|
||||
historyRefreshPending,
|
||||
recoveryRevealKey,
|
||||
scrollRef,
|
||||
]);
|
||||
}
|
||||
@@ -520,14 +489,12 @@ function NativeMessageListBody({
|
||||
onScrollToMessage,
|
||||
autoScrollEnabled,
|
||||
dividerBeforeItemKey,
|
||||
prependContent,
|
||||
launchErrorOwned,
|
||||
launchErrorStamp,
|
||||
launchErrorOccurredAt,
|
||||
}: NativeMessageListBodyProps) {
|
||||
return (
|
||||
<div className="p-4">
|
||||
{prependContent ? <div className="mb-4">{prependContent}</div> : null}
|
||||
{/* Sentinel for lazy loading older messages */}
|
||||
{hasMore && <div ref={sentinelRef} className="h-px" />}
|
||||
|
||||
@@ -623,8 +590,6 @@ export const NativeMessageList = memo(
|
||||
launchErrorOwned = false,
|
||||
launchErrorStamp,
|
||||
launchErrorOccurredAt,
|
||||
prependContent,
|
||||
recoveryRevealKey,
|
||||
}: MessageListProps,
|
||||
ref,
|
||||
) {
|
||||
@@ -699,7 +664,6 @@ export const NativeMessageList = memo(
|
||||
isWorking,
|
||||
].join(":"),
|
||||
isVisible,
|
||||
recoveryRevealKey,
|
||||
});
|
||||
|
||||
return (
|
||||
@@ -739,7 +703,6 @@ export const NativeMessageList = memo(
|
||||
onScrollToMessage={handleScrollToMessage}
|
||||
autoScrollEnabled={autoScrollEnabled}
|
||||
dividerBeforeItemKey={dividerBeforeItemKey}
|
||||
prependContent={prependContent}
|
||||
launchErrorOwned={launchErrorOwned}
|
||||
launchErrorStamp={launchErrorStamp}
|
||||
launchErrorOccurredAt={launchErrorOccurredAt}
|
||||
|
||||
@@ -64,10 +64,6 @@ export type MessageListProps = {
|
||||
* top — the desktop-only, opt-in anchored last-prompt bar. `null`/`undefined`
|
||||
* when the setting is off or on mobile. */
|
||||
stickyPromptBar?: ReactNode;
|
||||
/** Rendered above transcript status and messages inside the native viewport. */
|
||||
prependContent?: ReactNode;
|
||||
/** Identity of the active recovery content for one-time initial reveal. */
|
||||
recoveryRevealKey?: string | null;
|
||||
/** Current rendered height (px) of the anchored last-prompt bar's pinned
|
||||
* overlay, or 0/undefined when it isn't showing. Lets a target scrolled
|
||||
* to the top of the transcript (e.g. the unread "New" divider) reserve
|
||||
|
||||
@@ -11,6 +11,9 @@ export type ActionMeta = {
|
||||
action_visibility?: "running";
|
||||
variant?: string;
|
||||
recovery_actions?: boolean;
|
||||
scope?: "session" | "task";
|
||||
error_stamp?: string;
|
||||
recovery_stamp?: string;
|
||||
is_auth_error?: boolean;
|
||||
auth_methods?: RecoveryAuthMethod[];
|
||||
error_output?: string;
|
||||
|
||||
@@ -123,23 +123,25 @@ function renderWithTranscript(
|
||||
});
|
||||
}
|
||||
|
||||
describe("ActionMessage — recovery card retires once the agent is back", () => {
|
||||
it("hides the card when a resume re-established the agent after the failure", () => {
|
||||
describe("ActionMessage — recovery history remains after the agent is back", () => {
|
||||
it("retains the entry without controls when a resume re-established the agent", () => {
|
||||
// A resumed agent settles at WAITING_FOR_INPUT, not RUNNING, so the session
|
||||
// state alone never retires the card.
|
||||
renderWithTranscript("WAITING_FOR_INPUT", [bootMessage(BOOTED_AFTER_FAILURE)]);
|
||||
|
||||
expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull();
|
||||
expect(screen.getByText(RECOVERY_MESSAGE)).toBeTruthy();
|
||||
expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull();
|
||||
expect(screen.queryByTestId(FRESH_TEST_ID)).toBeNull();
|
||||
});
|
||||
|
||||
it("hides the card when a fresh start re-established the agent after the failure", () => {
|
||||
it("retains the entry without controls when a fresh start re-established the agent", () => {
|
||||
renderWithTranscript("WAITING_FOR_INPUT", [
|
||||
bootMessage(BOOTED_AFTER_FAILURE, { is_resuming: false }),
|
||||
]);
|
||||
|
||||
expect(screen.getByText(RECOVERY_MESSAGE)).toBeTruthy();
|
||||
expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull();
|
||||
expect(screen.queryByTestId(FRESH_TEST_ID)).toBeNull();
|
||||
});
|
||||
|
||||
it("keeps the card visible when the resume attempt failed", () => {
|
||||
@@ -314,7 +316,7 @@ describe("ActionMessage — a recovery that failed keeps its controls", () => {
|
||||
|
||||
fireEvent.click(screen.getByTestId(RESUME_TEST_ID));
|
||||
await waitFor(() => expect(requestMock).toHaveBeenCalledTimes(1));
|
||||
await waitFor(() => expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull());
|
||||
await waitFor(() => expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull());
|
||||
|
||||
// The launch was accepted, so the card hid; the agent then failed to come up.
|
||||
live.setSessionState("STARTING");
|
||||
@@ -329,7 +331,7 @@ describe("ActionMessage — a recovery that failed keeps its controls", () => {
|
||||
const live = renderWithLiveStore([]);
|
||||
|
||||
fireEvent.click(screen.getByTestId(RESUME_TEST_ID));
|
||||
await waitFor(() => expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull());
|
||||
await waitFor(() => expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull());
|
||||
|
||||
live.setSessionState("FAILED");
|
||||
|
||||
@@ -341,13 +343,13 @@ describe("ActionMessage — a recovery that failed keeps its controls", () => {
|
||||
const live = renderWithLiveStore([]);
|
||||
|
||||
fireEvent.click(screen.getByTestId(RESUME_TEST_ID));
|
||||
await waitFor(() => expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull());
|
||||
await waitFor(() => expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull());
|
||||
|
||||
live.setSessionState("STARTING");
|
||||
live.setMessages([bootMessage(BOOTED_AFTER_FAILURE)]);
|
||||
live.setSessionState("WAITING_FOR_INPUT");
|
||||
|
||||
expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull();
|
||||
expect(screen.getByText(RECOVERY_MESSAGE)).toBeTruthy();
|
||||
expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
/* eslint-disable max-lines -- recovery action variants share one rendering harness. */
|
||||
import { afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
|
||||
import { StateProvider, useAppStoreApi } from "@/components/state-provider";
|
||||
@@ -142,12 +143,17 @@ function renderAction(
|
||||
sessionState?: TaskSessionState,
|
||||
sessionError?: string,
|
||||
activeTurnId?: string,
|
||||
sessionMetadata?: Record<string, unknown> | null,
|
||||
) {
|
||||
const initialState: Partial<AppState> = sessionState
|
||||
? {
|
||||
taskSessions: {
|
||||
items: {
|
||||
[TEST_SESSION_ID]: { state: sessionState, error_message: sessionError } as TaskSession,
|
||||
[TEST_SESSION_ID]: {
|
||||
state: sessionState,
|
||||
error_message: sessionError,
|
||||
metadata: sessionMetadata,
|
||||
} as TaskSession,
|
||||
},
|
||||
},
|
||||
turns: {
|
||||
@@ -288,21 +294,68 @@ describe("ActionMessage — transient retry (warning variant)", () => {
|
||||
renderAction(errorMsg, "WAITING_FOR_INPUT", "");
|
||||
expect(screen.getByTestId(RESUME_TEST_ID)).toBeTruthy();
|
||||
});
|
||||
});
|
||||
|
||||
it("hides a recovery card after its Resume request succeeds", async () => {
|
||||
describe("ActionMessage — session recovery history", () => {
|
||||
it("keeps the recovery entry after its Resume request succeeds and removes controls", async () => {
|
||||
const errorMsg = recoveryMessage(true);
|
||||
|
||||
renderAction(errorMsg, "WAITING_FOR_INPUT", "");
|
||||
fireEvent.click(screen.getByTestId(RESUME_TEST_ID));
|
||||
await waitFor(() => expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull());
|
||||
await waitFor(() => expect(screen.getByText(RECOVERY_MESSAGE)).toBeTruthy());
|
||||
expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull();
|
||||
});
|
||||
|
||||
it("keeps the recovery card hidden after a successful resume settles back to waiting", async () => {
|
||||
it("shows recovery controls only for the current stamped failure", () => {
|
||||
const historical = recoveryMessage(true);
|
||||
historical.metadata = {
|
||||
...(historical.metadata as Record<string, unknown>),
|
||||
error_stamp: "failure-old",
|
||||
};
|
||||
const current = recoveryMessage(true);
|
||||
current.metadata = {
|
||||
...(current.metadata as Record<string, unknown>),
|
||||
error_stamp: "failure-current",
|
||||
};
|
||||
const { rerender } = renderAction(historical, "WAITING_FOR_INPUT", "", undefined, {
|
||||
last_agent_error: {
|
||||
message: "The newer session failure.",
|
||||
stamp: "failure-current",
|
||||
},
|
||||
});
|
||||
|
||||
expect(screen.getByText(RECOVERY_MESSAGE)).toBeTruthy();
|
||||
expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull();
|
||||
|
||||
rerender(<ActionMessage comment={current} />);
|
||||
|
||||
expect(screen.getByTestId(RESUME_TEST_ID)).toBeTruthy();
|
||||
});
|
||||
|
||||
it("keeps controls for an unstamped legacy row matching the current failure", () => {
|
||||
const legacy = recoveryMessage(true);
|
||||
legacy.content = "Agent encountered an error: The agent could not start.";
|
||||
legacy.metadata = {
|
||||
...(legacy.metadata as Record<string, unknown>),
|
||||
error_stamp: undefined,
|
||||
};
|
||||
|
||||
renderAction(legacy, "WAITING_FOR_INPUT", "", undefined, {
|
||||
last_agent_error: {
|
||||
message: "The agent could not start.",
|
||||
occurred_at: legacy.created_at,
|
||||
},
|
||||
});
|
||||
|
||||
expect(screen.getByTestId(RESUME_TEST_ID)).toBeTruthy();
|
||||
});
|
||||
|
||||
it("keeps the historical recovery entry after a successful resume settles back to waiting", async () => {
|
||||
const errorMsg = recoveryMessage(true);
|
||||
|
||||
const { setSessionState } = renderActionWithStore(errorMsg, "WAITING_FOR_INPUT", "");
|
||||
fireEvent.click(screen.getByTestId(RESUME_TEST_ID));
|
||||
await waitFor(() => expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull());
|
||||
await waitFor(() => expect(screen.getByText(RECOVERY_MESSAGE)).toBeTruthy());
|
||||
|
||||
// A successful resume drives the session through an active state (which
|
||||
// hides the card via isSessionActive) and then back to WAITING_FOR_INPUT
|
||||
@@ -312,7 +365,7 @@ describe("ActionMessage — transient retry (warning variant)", () => {
|
||||
setSessionState("STARTING");
|
||||
setSessionState("WAITING_FOR_INPUT");
|
||||
|
||||
expect(screen.queryByText(RECOVERY_MESSAGE)).toBeNull();
|
||||
expect(screen.getByText(RECOVERY_MESSAGE)).toBeTruthy();
|
||||
expect(screen.queryByTestId(RESUME_TEST_ID)).toBeNull();
|
||||
});
|
||||
|
||||
|
||||
@@ -13,11 +13,62 @@ import { parseRetryAt, retryCountdownLabel } from "./transient-retry";
|
||||
import { hasSessionRecoveryResolutionAfter } from "@/hooks/processed-message-filtering";
|
||||
import { ActionButtons } from "./action-message-actions";
|
||||
import { SessionRecoveryActionButtons, sessionRecoveryAction } from "./action-message-recovery";
|
||||
import {
|
||||
lastAgentErrorStamp,
|
||||
readLastAgentError,
|
||||
type LastAgentError,
|
||||
} from "@/lib/session-last-agent-error";
|
||||
import { legacyRecoveryMessageMatchesError } from "@/lib/session-recovery-presentation";
|
||||
|
||||
function isSessionActive(state?: TaskSessionState) {
|
||||
return state === "RUNNING" || state === "STARTING" || state === "COMPLETED";
|
||||
}
|
||||
|
||||
function currentSessionRecoveryError(sessionMetadata: Record<string, unknown> | null) {
|
||||
if (!sessionMetadata) return null;
|
||||
return readLastAgentError(sessionMetadata);
|
||||
}
|
||||
|
||||
function isCurrentRecoveryMessage(
|
||||
isRecoveryMessage: boolean,
|
||||
messageRecoveryStamp: string | undefined,
|
||||
currentRecoveryError: LastAgentError | null,
|
||||
comment: Message,
|
||||
) {
|
||||
if (!isRecoveryMessage) return true;
|
||||
if (!currentRecoveryError) return true;
|
||||
const currentRecoveryStamp = lastAgentErrorStamp(currentRecoveryError);
|
||||
if (messageRecoveryStamp) return currentRecoveryStamp === messageRecoveryStamp;
|
||||
return legacyRecoveryMessageMatchesError(
|
||||
comment.content,
|
||||
comment.created_at,
|
||||
currentRecoveryError,
|
||||
);
|
||||
}
|
||||
|
||||
function shouldShowRecoveryActions({
|
||||
isRecoveryMessage,
|
||||
isCurrentRecovery,
|
||||
recoveryResolvedDurably,
|
||||
agentRebooted,
|
||||
recoveryRequested,
|
||||
recoveryFailedAgain,
|
||||
sessionState,
|
||||
}: {
|
||||
isRecoveryMessage: boolean;
|
||||
isCurrentRecovery: boolean;
|
||||
recoveryResolvedDurably: boolean;
|
||||
agentRebooted: boolean;
|
||||
recoveryRequested: boolean;
|
||||
recoveryFailedAgain: boolean;
|
||||
sessionState?: TaskSessionState;
|
||||
}) {
|
||||
if (!isRecoveryMessage) return true;
|
||||
if (!isCurrentRecovery || recoveryResolvedDurably || agentRebooted) return false;
|
||||
if (recoveryRequested && !recoveryFailedAgain) return false;
|
||||
return !isSessionActive(sessionState);
|
||||
}
|
||||
|
||||
export const ActionMessage = memo(function ActionMessage({ comment }: { comment: Message }) {
|
||||
// Read session state from the store instead of receiving it as a prop, so a
|
||||
// state transition doesn't re-render every message in the list (only the
|
||||
@@ -51,6 +102,23 @@ export const ActionMessage = memo(function ActionMessage({ comment }: { comment:
|
||||
// that came back failed — a failed boot row, or a session driven to FAILED —
|
||||
// must surface its card again, buttons included, or the retry is unreachable.
|
||||
const recoveryFailedAgain = agentBootFailed || sessionState === "FAILED";
|
||||
const currentRecoveryError = currentSessionRecoveryError(sessionMetadata ?? null);
|
||||
const messageRecoveryStamp = metadata?.recovery_stamp ?? metadata?.error_stamp;
|
||||
const isCurrentRecovery = isCurrentRecoveryMessage(
|
||||
isRecoveryMessage,
|
||||
messageRecoveryStamp,
|
||||
currentRecoveryError,
|
||||
comment,
|
||||
);
|
||||
const recoveryActionsVisible = shouldShowRecoveryActions({
|
||||
isRecoveryMessage,
|
||||
isCurrentRecovery,
|
||||
recoveryResolvedDurably,
|
||||
agentRebooted,
|
||||
recoveryRequested,
|
||||
recoveryFailedAgain,
|
||||
sessionState,
|
||||
});
|
||||
|
||||
if (metadata?.action_visibility === "running") {
|
||||
if (sessionState === "RUNNING" && comment.turn_id && activeTurnId === comment.turn_id) {
|
||||
@@ -77,9 +145,7 @@ export const ActionMessage = memo(function ActionMessage({ comment }: { comment:
|
||||
sessionState={sessionState}
|
||||
taskId={comment.task_id}
|
||||
sessionId={comment.session_id}
|
||||
recoveryResolved={
|
||||
recoveryResolvedDurably || agentRebooted || (recoveryRequested && !recoveryFailedAgain)
|
||||
}
|
||||
recoveryActionsVisible={recoveryActionsVisible}
|
||||
onRecoveryRequested={() => setRecoveryRequested(true)}
|
||||
/>
|
||||
);
|
||||
@@ -92,7 +158,7 @@ function SettledActionMessage({
|
||||
sessionState,
|
||||
taskId,
|
||||
sessionId,
|
||||
recoveryResolved,
|
||||
recoveryActionsVisible,
|
||||
onRecoveryRequested,
|
||||
}: {
|
||||
metadata: ActionMeta | undefined;
|
||||
@@ -101,12 +167,12 @@ function SettledActionMessage({
|
||||
sessionState?: TaskSessionState;
|
||||
taskId?: string;
|
||||
sessionId?: string;
|
||||
recoveryResolved: boolean;
|
||||
recoveryActionsVisible: boolean;
|
||||
onRecoveryRequested: () => void;
|
||||
}) {
|
||||
// A retry card is persisted against the failed turn, so hide it while the
|
||||
// replacement turn is starting or running to avoid showing stale progress.
|
||||
if (isSessionActive(sessionState)) return null;
|
||||
if (isSessionActive(sessionState) && metadata?.recovery_actions !== true) return null;
|
||||
|
||||
if (metadata?.retrying) {
|
||||
return <TransientRetryNotice metadata={metadata} taskId={taskId} />;
|
||||
@@ -117,10 +183,9 @@ function SettledActionMessage({
|
||||
metadata={metadata}
|
||||
message={message}
|
||||
sessionError={sessionError}
|
||||
sessionState={sessionState}
|
||||
taskId={taskId}
|
||||
sessionId={sessionId}
|
||||
recoveryResolved={recoveryResolved}
|
||||
recoveryActionsVisible={recoveryActionsVisible}
|
||||
onRecoveryRequested={onRecoveryRequested}
|
||||
/>
|
||||
);
|
||||
@@ -130,32 +195,23 @@ function SettledFailureMessage({
|
||||
metadata,
|
||||
message,
|
||||
sessionError,
|
||||
sessionState,
|
||||
taskId,
|
||||
sessionId,
|
||||
recoveryResolved,
|
||||
recoveryActionsVisible,
|
||||
onRecoveryRequested,
|
||||
}: {
|
||||
metadata: ActionMeta | undefined;
|
||||
message: string;
|
||||
sessionError?: string;
|
||||
sessionState?: TaskSessionState;
|
||||
taskId?: string;
|
||||
sessionId?: string;
|
||||
recoveryResolved: boolean;
|
||||
recoveryActionsVisible: boolean;
|
||||
onRecoveryRequested: () => void;
|
||||
}) {
|
||||
// A waiting session can still need recovery, so only hide this persisted card
|
||||
// once its own recovery resolved: either the Resume click was acknowledged or
|
||||
// the transcript shows the agent booted again after this failure. A resumed
|
||||
// agent settles at WAITING_FOR_INPUT, which isSessionActive deliberately
|
||||
// excludes, so without that second signal the card outlives the failure it
|
||||
// describes.
|
||||
if (isSessionActive(sessionState) || (metadata?.recovery_actions && recoveryResolved))
|
||||
return null;
|
||||
const renderedMetadata = recoveryActionsVisible ? metadata : withoutRecoveryActions(metadata);
|
||||
|
||||
const specialRecovery = renderSpecialRecovery({
|
||||
metadata,
|
||||
metadata: renderedMetadata,
|
||||
message,
|
||||
sessionError,
|
||||
taskId,
|
||||
@@ -169,16 +225,16 @@ function SettledFailureMessage({
|
||||
? "text-amber-600 dark:text-amber-400"
|
||||
: "text-red-600 dark:text-red-400";
|
||||
return (
|
||||
<div className="w-full">
|
||||
<div className="w-full" data-testid="session-recovery-action-message">
|
||||
<div className="flex items-start gap-3 w-full rounded px-2 py-1 -mx-2">
|
||||
<div className="flex-shrink-0 mt-0.5">
|
||||
<IconAlertTriangle className={cn("h-4 w-4", iconClass)} />
|
||||
</div>
|
||||
<div className="flex-1 min-w-0 pt-0.5">
|
||||
<div className={cn("text-xs break-words", textClass)}>{message}</div>
|
||||
<ActionMessageDetails metadata={metadata} />
|
||||
<ActionMessageDetails metadata={renderedMetadata} />
|
||||
{renderSettledActionButtons({
|
||||
actions: metadata?.actions,
|
||||
actions: renderedMetadata?.actions,
|
||||
taskId,
|
||||
sessionId,
|
||||
isRecoveryMessage: metadata?.recovery_actions === true,
|
||||
@@ -190,6 +246,11 @@ function SettledFailureMessage({
|
||||
);
|
||||
}
|
||||
|
||||
function withoutRecoveryActions(metadata: ActionMeta | undefined): ActionMeta | undefined {
|
||||
if (!metadata) return undefined;
|
||||
return { ...metadata, actions: undefined };
|
||||
}
|
||||
|
||||
function renderSettledActionButtons({
|
||||
actions,
|
||||
taskId,
|
||||
|
||||
Reference in New Issue
Block a user