@onekeyfe/react-native-native-list 3.0.157-alpha.253 → 3.0.157-alpha.255

package/ios/tests/NativeListActivityPresentationTests.swift

@@ -0,0 +1,43 @@
+import UIKit
+import XCTest
+@testable import NativeListModule
+
+@MainActor
+final class NativeListActivityPresentationTests: XCTestCase {
+  func testSmallNumberRunsPreserveBaselineAcrossAmountsFiatAndFee() throws {
+    func segments(_ prefix: String, _ suffix: String) -> [[String: Any]] {
+      [["text": prefix], ["text": "5", "style": "subscript"], ["text": suffix]]
+    }
+    let item = try NativeListItem(data: [
+      "type": "activity", "key": "transfer", "title": "Transfer",
+      "leading": ["kind": "icon", "name": "ArrowTopOutline"],
+      "amounts": [[
+        "key": "receive", "text": "0.051 ETH", "textSegments": segments("0.0", "1 ETH"),
+        "secondaryText": "$0.051", "secondaryTextSegments": segments("$0.0", "1"),
+      ]],
+      "fee": [
+        "primary": "0.051 GAS", "primaryTextSegments": segments("0.0", "1 GAS"),
+        "secondary": "€0.051", "secondaryTextSegments": segments("€0.0", "1"),
+      ],
+    ])
+    let view = NativeListActivityDetailsView()
+    view.bind(item, theme: nil)
+    func labels(in view: UIView) -> [UILabel] {
+      (view as? UILabel).map { [$0] } ?? view.subviews.flatMap { labels(in: $0) }
+    }
+    let cases: [(String, Int, CGFloat)] = [
+      ("0.051 ETH", 3, 16), ("$0.051", 4, 14),
+      ("0.051 GAS", 3, 14), ("€0.051", 4, 12),
+    ]
+    let rendered = labels(in: view)
+    for (text, countIndex, parentSize) in cases {
+      let label = try XCTUnwrap(rendered.first { $0.attributedText?.string == text })
+      let value = try XCTUnwrap(label.attributedText)
+      let font = try XCTUnwrap(value.attribute(.font, at: countIndex, effectiveRange: nil) as? UIFont)
+      XCTAssertEqual(font.pointSize, ceil(parentSize * 0.6))
+      let baseline = value.attribute(.baselineOffset, at: 0, effectiveRange: nil) as? NSNumber
+      let countBaseline = value.attribute(.baselineOffset, at: countIndex, effectiveRange: nil) as? NSNumber
+      XCTAssertEqual(countBaseline?.doubleValue ?? 0, baseline?.doubleValue ?? 0)
+    }
+  }
+}

package/ios/tests/NativeListLifecycleTests.swift

@@ -0,0 +1,213 @@
+import UIKit
+import XCTest
+@testable import NativeListModule
+
+@MainActor
+final class NativeListLifecycleTests: XCTestCase {
+  func testSectionLoadingStopsOnRebindReuseAndDetach() throws {
+    let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
+    let controller = UIViewController()
+    window.rootViewController = controller
+    window.isHidden = false
+    defer { window.isHidden = true }
+    let cell = NativeListSectionHeaderCell(frame: CGRect(x: 0, y: 0, width: 320, height: 40))
+    controller.view.addSubview(cell)
+    func bind(loading: Bool) throws {
+      let item = try NativeListItem(data: [
+        "key": "section", "type": "sectionHeader", "sectionKey": "pending",
+        "title": "Confirming", "variant": "history", "titleLoading": loading,
+        "style": ["title": ["color": "#FFAA00"]],
+      ])
+      cell.bind(item: item, theme: nil, layout: "sectioned", selected: false,
+                checkboxState: { _, _, fallback in fallback })
+    }
+    try bind(loading: true)
+    let spinner = try XCTUnwrap(cell.root.arrangedSubviews.first as? UIActivityIndicatorView)
+    XCTAssertTrue(spinner.isAnimating)
+    XCTAssertFalse(spinner.isAccessibilityElement)
+    XCTAssertEqual(spinner.color, UIColor(nativeListHex: "#FFAA00", fallback: .clear))
+
+    try bind(loading: false)
+    XCTAssertFalse(spinner.isAnimating)
+    XCTAssertNil(spinner.superview)
+    try bind(loading: true)
+    XCTAssertTrue(spinner.isAnimating)
+    cell.removeFromSuperview()
+    XCTAssertFalse(spinner.isAnimating)
+    controller.view.addSubview(cell)
+    XCTAssertTrue(spinner.isAnimating)
+    cell.prepareForReuse()
+    XCTAssertFalse(spinner.isAnimating)
+  }
+
+  func testRebindingAndReuseInvalidateThePreviousActionEpoch() throws {
+    let cell = NativeListActionCell(frame: CGRect(x: 0, y: 0, width: 320, height: 60))
+    let first = try NativeListItem(data: ["key": "row", "type": "action", "title": "First"])
+    let changed = try NativeListItem(data: ["key": "row", "type": "action", "title": "Changed"])
+    var invalidatedEpochs: [Int] = []
+    cell.onBindingInvalidated = { _, epoch in invalidatedEpochs.append(epoch) }
+
+    func bind(_ item: NativeListItem) {
+      cell.bind(item: item, theme: nil, layout: "linear", selected: false,
+                checkboxState: { _, _, fallback in fallback })
+    }
+
+    bind(first)
+    let originalEpoch = cell.rowActionOrigin().bindingEpoch
+    bind(first)
+    XCTAssertEqual(cell.bindingEpoch, originalEpoch, "Identical content should retain its action origin")
+    XCTAssertTrue(invalidatedEpochs.isEmpty)
+
+    bind(changed)
+    XCTAssertEqual(invalidatedEpochs, [originalEpoch])
+    XCTAssertNotEqual(cell.rowActionOrigin().bindingEpoch, originalEpoch)
+
+    let changedEpoch = cell.bindingEpoch
+    cell.prepareForReuse()
+    XCTAssertEqual(invalidatedEpochs, [originalEpoch, changedEpoch])
+    XCTAssertNotEqual(cell.bindingEpoch, changedEpoch)
+  }
+
+  func testFixedFooterReplacesRendererAndKeepsActionRouting() throws {
+    let view = NativeListView(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
+    var actions: [[String: Any]] = []
+    view.onRowAction = { payload in
+      let data = Data(payload.utf8)
+      if let action = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] {
+        actions.append(action)
+      }
+    }
+
+    view.applySnapshotJson(try snapshot(footer: [
+      "key": "footer", "type": "action", "title": "Continue", "actionKey": "continue",
+    ]))
+    let first = try XCTUnwrap(footerCell(in: view))
+    XCTAssertTrue(first is NativeListActionCell)
+    XCTAssertFalse(first.isHidden)
+    XCTAssertEqual(first.accessibilityLabel, "Continue")
+    let gestureCount = first.gestureRecognizers?.count
+
+    view.applySnapshotJson(try snapshot(footer: [
+      "key": "footer", "type": "system", "variant": "retry", "title": "Retry",
+      "actionKey": "retry",
+    ]))
+    let second = try XCTUnwrap(footerCell(in: view))
+    XCTAssertTrue(second is NativeListSystemCell)
+    XCTAssertFalse(second === first)
+    XCTAssertNil(first.superview)
+    XCTAssertFalse(second.isHidden)
+    XCTAssertEqual(second.accessibilityLabel, "Retry")
+    XCTAssertEqual(second.gestureRecognizers?.count, gestureCount)
+
+    second.onAction?(try NativeListItem(data: [
+      "key": "footer", "type": "system", "variant": "retry", "title": "Retry",
+      "actionKey": "retry",
+    ]), "retry", nil, nil)
+    XCTAssertEqual(actions.last?["actionKey"] as? String, "retry")
+
+    view.applySnapshotJson(try snapshot(footer: nil))
+    XCTAssertTrue(second.isHidden)
+  }
+
+  private func snapshot(footer: [String: Any]?) throws -> String {
+    var value: [String: Any] = [
+      "schemaVersion": 1, "generation": 1, "layout": ["kind": "linear"], "rows": [],
+    ]
+    if let footer { value["fixedFooter"] = footer }
+    let data = try JSONSerialization.data(withJSONObject: value, options: [.sortedKeys])
+    return String(decoding: data, as: UTF8.self)
+  }
+
+  func testContentShrinkCorrectsRestoredOffsetAfterPagerInsetsAndUpdatesObserver() throws {
+    let view = try makeScrollingList()
+    let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+    list.contentInset = UIEdgeInsets(top: 108, left: 0, bottom: 0, right: 0)
+    list.contentOffset.y = 600
+    var savedLogicalOffset = list.contentOffset.y + list.contentInset.top
+    let offsetObserver = list.observe(\.contentOffset, options: [.new]) { list, _ in
+      savedLogicalOffset = list.contentOffset.y + list.contentInset.top
+    }
+    // Model the pager's synchronous content-size observer and cached-offset restoration.
+    let sizeObserver = list.observe(\.contentSize, options: [.old, .new]) { list, change in
+      if change.oldValue != change.newValue, list.contentSize.height < 200 {
+        list.contentInset.bottom = max(0, list.bounds.height - 44 - list.contentSize.height)
+        list.contentOffset.y = 600
+      }
+    }
+    view.applySnapshotJson(try scrollingSnapshot(count: 0))
+    view.layoutIfNeeded()
+    list.layoutIfNeeded()
+    drainMainQueue()
+    XCTAssertEqual(list.contentSize.height, 132, accuracy: 0.5)
+    XCTAssertEqual(list.contentOffset.y, -44, accuracy: 0.5)
+    XCTAssertEqual(savedLogicalOffset, 64, accuracy: 0.5)
+    withExtendedLifetime((offsetObserver, sizeObserver)) {}
+  }
+
+  func testContentShrinkPreservesInRangeAndNegativePullOffsets() throws {
+    for offset in [CGFloat(120), CGFloat(-160)] {
+      let view = try makeScrollingList()
+      let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+      list.contentInset.top = 108
+      view.applySnapshotJson(try scrollingSnapshot(count: 20))
+      view.layoutIfNeeded()
+      list.layoutIfNeeded()
+      // Preserve a valid offset or a refresh pull while shrink correction is queued.
+      list.contentOffset.y = offset
+      drainMainQueue()
+      XCTAssertEqual(list.contentOffset.y, offset, accuracy: 0.5)
+    }
+  }
+
+  func testContentShrinkWaitsForRefreshCompletion() throws {
+    let view = try makeScrollingList()
+    let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+    view.applySnapshotJson(try scrollingSnapshot(count: 0, refreshing: true))
+    view.layoutIfNeeded()
+    list.layoutIfNeeded()
+    list.contentOffset.y = 600
+    drainMainQueue()
+    XCTAssertEqual(list.contentOffset.y, 600, accuracy: 0.5)
+    view.setRefreshing(false)
+    drainMainQueue()
+    let inset = list.adjustedContentInset
+    let maximum = max(-inset.top, list.contentSize.height - list.bounds.height + inset.bottom)
+    XCTAssertEqual(list.contentOffset.y, maximum, accuracy: 0.5)
+  }
+
+  private func makeScrollingList() throws -> NativeListView {
+    let view = NativeListView(frame: CGRect(x: 0, y: 0, width: 320, height: 708))
+    for index in 0..<3 { view.mountContainerSlot(UIView(), atIndex: index) }
+    view.setContainerSlotHeightsJson("[44,44,44]")
+    view.applySnapshotJson(try scrollingSnapshot(count: 40))
+    view.layoutIfNeeded()
+    let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+    list.layoutIfNeeded()
+    drainMainQueue()
+    return view
+  }
+
+  private func scrollingSnapshot(count: Int, refreshing: Bool = false) throws -> String {
+    let rows: [[String: Any]] = (0..<count).map {
+      ["key": "row-\($0)", "type": "action", "title": "Row", "height": 80]
+    }
+    let value: [String: Any] = [
+      "schemaVersion": 1, "generation": count + 1,
+      "layout": ["kind": "linear"], "rows": rows,
+      "capabilities": ["pullToRefresh": true, "refreshing": refreshing],
+    ]
+    return String(decoding: try JSONSerialization.data(withJSONObject: value), as: UTF8.self)
+  }
+
+  private func drainMainQueue() {
+    let settled = expectation(description: "Deferred content shrink correction")
+    DispatchQueue.main.async { settled.fulfill() }
+    wait(for: [settled], timeout: 1)
+  }
+
+  private func footerCell(in view: NativeListView) -> NativeListRowHost? {
+    view.subviews.lazy.compactMap { container in
+      container.subviews.compactMap { $0 as? NativeListRowHost }.first
+    }.first
+  }
+}

package/ios/tests/NativeListMediaVisibilityTests.swift

@@ -0,0 +1,42 @@
+import UIKit
+import XCTest
+@testable import NativeListModule
+
+@MainActor
+final class NativeListMediaVisibilityTests: XCTestCase {
+  func testRetainedPagerAndListCellsRequireViewportIntersection() {
+    let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
+    let controller = UIViewController()
+    window.rootViewController = controller
+    window.isHidden = false
+    defer { window.isHidden = true }
+    let pager = UIScrollView(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
+    pager.contentSize = CGSize(width: 640, height: 480)
+    controller.view.addSubview(pager)
+    let list = UIScrollView(frame: CGRect(x: 320, y: 0, width: 320, height: 480))
+    list.contentSize = CGSize(width: 320, height: 960)
+    pager.addSubview(list)
+    let tile = UIView(frame: CGRect(x: 10, y: 10, width: 100, height: 100))
+    list.addSubview(tile)
+
+    XCTAssertNotNil(tile.window, "Pager retains the offscreen cell in the window")
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    pager.contentOffset.x = 320
+    XCTAssertTrue(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.contentOffset.y = 110
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.contentOffset.y = 100
+    XCTAssertTrue(NativeListMediaPreviewSlot.intersectsViewport(tile), "Partially visible previews remain eligible")
+    list.transform = CGAffineTransform(translationX: 320, y: 0)
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.transform = .identity
+    XCTAssertTrue(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.isHidden = true
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.isHidden = false
+    list.alpha = 0
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    tile.removeFromSuperview()
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+  }
+}

package/ios/tests/NativeListScrollPositionTrackerTests.swift

@@ -0,0 +1,25 @@
+import XCTest
+@testable import NativeListModule
+
+final class NativeListScrollPositionTrackerTests: XCTestCase {
+  func testHysteresisAndDisabledLifecycle() {
+    var tracker = NativeListScrollPositionTracker()
+    XCTAssertNil(tracker.update(offset: 200))
+    tracker.configure(json: "{\"start\":48,\"end\":160}")
+    XCTAssertEqual(tracker.update(offset: 0), false)
+    XCTAssertNil(tracker.update(offset: 159))
+    XCTAssertEqual(tracker.update(offset: 160), true)
+    XCTAssertNil(tracker.update(offset: 100))
+    XCTAssertEqual(tracker.update(offset: 48), false)
+    XCTAssertNil(tracker.update(offset: 49))
+    tracker.configure(json: "")
+    XCTAssertNil(tracker.update(offset: 200))
+    tracker.configure(json: "{\"start\":48,\"end\":160}")
+    XCTAssertEqual(tracker.update(offset: 200), true)
+    tracker.resetDelivery()
+    XCTAssertEqual(tracker.update(offset: 200), true)
+    XCTAssertNil(tracker.update(offset: .nan))
+    tracker.configure(json: "{\"start\":48,\"end\":48}")
+    XCTAssertNil(tracker.update(offset: 48))
+  }
+}

package/lib/module/NativeList.js

@@ -1,8 +1,9 @@
 "use strict";
 
-import React, { forwardRef, useEffect, useImperativeHandle, useMemo, useRef } from 'react';
+import React, { forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
 import { OneKeyImageCache, OneKeyImageCachePolicy } from '@onekeyfe/react-native-image';
 import { NativeAvatarPrefetchModel, NativeAvatarPrefetchQueue } from "./avatarPrefetch.js";
+import { View } from 'react-native';
 import { callback, getHostComponent } from 'react-native-nitro-modules';
 import { isSelectableRow } from "./selection.js";
 import { normalizeIndexScroll, normalizeKeyScroll, normalizePositionScroll, resolveLocationIndex, scrollFailure, validateOffset } from "./scrolling.js";
@@ -26,6 +27,10 @@ function parsePayload(payloadJson) {
 }
 export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   snapshot,
+  listHeader,
+  listFooter,
+  listEmpty,
+  scrollPositionThresholds,
   webVirtualizationEnabled: _webVirtualizationEnabled,
   webSectionIndexContainerRef: _webSectionIndexContainerRef,
   keyboardDismissMode = 'none',
@@ -36,6 +41,7 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   onReorder,
   onEndReached,
   onVisibleRangeChanged,
+  onScrollPositionThresholdChange,
   onRefresh,
   onScrollToIndexFailed,
   initialScrollIndex,
@@ -44,6 +50,13 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   initialScrollViewOffset,
   ...viewProps
 }, forwardedRef) {
+  const [slotHeights, setSlotHeights] = useState([0, 0, 0]);
+  const containerSlotHeightsJson = JSON.stringify(slotHeights);
+  const slotInset = snapshot.layout.contentPaddingHorizontal ?? snapshot.layout.contentPadding ?? 0;
+  if (snapshot.layout.orientation === 'horizontal' && (listHeader || listEmpty || listFooter)) {
+    throw new Error('NativeList container slots require vertical orientation');
+  }
+  const slotContents = [listHeader, listEmpty, listFooter];
   const normalizedKeyboardShouldPersistTaps = keyboardShouldPersistTaps === true ? 'always' : keyboardShouldPersistTaps === false ? 'never' : keyboardShouldPersistTaps;
   const nativeRef = useRef(null);
   const callbacksRef = useRef({
@@ -53,6 +66,7 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     onReorder,
     onEndReached,
     onVisibleRangeChanged,
+    onScrollPositionThresholdChange,
     onRefresh,
     onScrollToIndexFailed
   });
@@ -63,9 +77,24 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     onReorder,
     onEndReached,
     onVisibleRangeChanged,
+    onScrollPositionThresholdChange,
     onRefresh,
     onScrollToIndexFailed
   };
+  const scrollPositionThresholdsJson = useMemo(() => {
+    if (!scrollPositionThresholds || scrollPositionThresholds.enabled === false) return '';
+    const {
+      start,
+      end
+    } = scrollPositionThresholds;
+    if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end <= start) {
+      throw new Error('scrollPositionThresholds requires 0 <= start < end and finite values');
+    }
+    return JSON.stringify({
+      start,
+      end
+    });
+  }, [scrollPositionThresholds]);
   const snapshotJson = useMemo(() => serializeSnapshot(snapshot), [snapshot]);
   const snapshotRef = useRef(snapshot);
   const previousSnapshotJsonRef = useRef(snapshotJson);
@@ -235,7 +264,10 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     }),
     onRowAction: callback(payloadJson => {
       const payload = parsePayload(payloadJson);
-      if (payload.actionKey === 'nativeList.refresh') callbacksRef.current.onRefresh?.();
+      if (payload.actionKey === 'nativeList.refresh' && payload.rowKey === undefined) {
+        callbacksRef.current.onRefresh?.();
+        return;
+      }
       callbacksRef.current.onRowAction?.(payload);
     }),
     onActionAnchorInvalidated: callback(payloadJson => {
@@ -264,6 +296,11 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     onEndReached: callback(payloadJson => {
       callbacksRef.current.onEndReached?.(parsePayload(payloadJson));
     }),
+    onScrollPositionThresholdChange: callback(isBeyondThreshold => {
+      callbacksRef.current.onScrollPositionThresholdChange?.({
+        isBeyondThreshold
+      });
+    }),
     onVisibleRangeChanged: callback(payloadJson => {
       const payload = parsePayload(payloadJson);
       const previous = avatarRangeRef.current;
@@ -280,8 +317,24 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     ...viewProps,
     ...nativeCallbacks,
     snapshotJson: snapshotJson,
+    containerSlotHeightsJson: containerSlotHeightsJson,
+    scrollPositionThresholdsJson: scrollPositionThresholdsJson,
     keyboardDismissMode: keyboardDismissMode,
-    keyboardShouldPersistTaps: normalizedKeyboardShouldPersistTaps
+    keyboardShouldPersistTaps: normalizedKeyboardShouldPersistTaps,
+    children: slotContents.map((content, index) => /*#__PURE__*/_jsx(View, {
+      collapsable: false,
+      style: {
+        position: 'absolute',
+        left: slotInset,
+        right: slotInset,
+        top: 0
+      },
+      onLayout: event => {
+        const height = Math.ceil(event.nativeEvent.layout.height);
+        setSlotHeights(previous => previous[index] === height ? previous : previous.map((value, slot) => slot === index ? height : value));
+      },
+      children: content
+    }, index))
   });
 });
 //# sourceMappingURL=NativeList.js.map

package/lib/module/NativeList.web.js

@@ -22,6 +22,11 @@ export function preloadNativeListAvatarImages(sources) {
 }
 export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   snapshot,
+  listHeader: _listHeader,
+  listEmpty: _listEmpty,
+  listFooter: _listFooter,
+  scrollPositionThresholds: _scrollPositionThresholds,
+  onScrollPositionThresholdChange: _onScrollPositionThresholdChange,
   webVirtualizationEnabled = true,
   webSectionIndexContainerRef,
   keyboardDismissMode: _keyboardDismissMode,

package/lib/module/validation.js

@@ -128,13 +128,13 @@ const TEXT_STYLE_KEYS_BY_ROW_TYPE = {
   identity: ['title', 'subtitle', 'tertiary', 'badge', 'value', 'valueSecondary'],
   walletGroup: [],
   rail: ['title', 'badge', 'status'],
-  activity: ['title', 'description', 'status', 'primaryAmount', 'secondaryAmount'],
+  activity: ['title', 'description', 'status', 'amounts', 'badges', 'presentation', 'fee', 'descriptionActionKey', 'primaryAmount', 'secondaryAmount'],
   message: ['title', 'body', 'time'],
   dataRow: ['columns', 'columnSecondary', 'index'],
   market: ['title', 'subtitle', 'price', 'change'],
   mediaTile: ['title', 'subtitle', 'badge'],
   metricCard: ['title', 'value', 'subtitle', 'trend'],
-  sectionHeader: ['title', 'subtitle', 'value'],
+  sectionHeader: ['titleLoading', 'title', 'subtitle', 'value'],
   action: ['title', 'value'],
   system: ['title', 'message', 'actionText']
 };
@@ -517,6 +517,46 @@ function assertVisual(row, path) {
   });
 }
 function assertActivity(row, path) {
+  assertText(row.title, `${path}.title`);
+  assertText(row.description, `${path}.description`);
+  if (row.presentation !== undefined && !['stacked', 'table'].includes(row.presentation)) fail(`${path}.presentation`, 'must be stacked or table');
+  if (row.descriptionActionKey !== undefined) assertKey(row.descriptionActionKey, `${path}.descriptionActionKey`);
+  if ((row.amounts?.length ?? 0) > 32) fail(`${path}.amounts`, 'supports at most 32 amount lines');
+  const amountKeys = new Set();
+  row.amounts?.forEach((amount, index) => {
+    const amountPath = `${path}.amounts[${index}]`;
+    assertKey(amount.key, `${amountPath}.key`);
+    if (amountKeys.has(amount.key)) fail(amountPath, 'duplicate amount key');
+    amountKeys.add(amount.key);
+    assertText(amount.text, `${amountPath}.text`);
+    assertLeadingVisual(amount.leading, `${amountPath}.leading`);
+    assertText(amount.secondaryText, `${amountPath}.secondaryText`);
+    if (amount.tone !== undefined && !['primary', 'secondary', 'positive', 'negative'].includes(amount.tone)) fail(`${amountPath}.tone`, 'invalid text tone');
+    amount.textSegments?.forEach((segment, segmentIndex) => {
+      assertText(segment.text, `${amountPath}.textSegments[${segmentIndex}].text`);
+      if (segment.style !== undefined && segment.style !== 'subscript') fail(amountPath, 'invalid text segment style');
+    });
+  });
+  const assertActivitySegments = (segments, segmentPath) => segments?.forEach((segment, index) => {
+    assertText(segment.text, `${segmentPath}[${index}].text`);
+    if (segment.style !== undefined && segment.style !== 'subscript') fail(segmentPath, 'invalid text segment style');
+  });
+  row.amounts?.forEach((amount, index) => assertActivitySegments(amount.secondaryTextSegments, `${path}.amounts[${index}].secondaryTextSegments`));
+  assertActivitySegments(row.fee?.primaryTextSegments, `${path}.fee.primaryTextSegments`);
+  assertActivitySegments(row.fee?.secondaryTextSegments, `${path}.fee.secondaryTextSegments`);
+  assertText(row.fee?.label, `${path}.fee.label`);
+  assertText(row.fee?.primary, `${path}.fee.primary`);
+  assertText(row.fee?.secondary, `${path}.fee.secondary`);
+  if ((row.badges?.length ?? 0) > 4) fail(`${path}.badges`, 'supports at most 4 activity badges');
+  const badgeKeys = new Set();
+  row.badges?.forEach((badge, index) => {
+    assertKey(badge.key, `${path}.badges[${index}].key`);
+    if (badgeKeys.has(badge.key)) fail(`${path}.badges`, 'duplicate badge key');
+    badgeKeys.add(badge.key);
+    assertText(badge.text, `${path}.badges[${index}].text`);
+    if (badge.tone !== undefined && !['neutral', 'info', 'success', 'warning', 'danger'].includes(badge.tone)) fail(`${path}.badges`, 'invalid badge tone');
+  });
+  if (row.fee?.hidden !== undefined && typeof row.fee.hidden !== 'boolean') fail(`${path}.fee.hidden`, 'must be boolean');
   if ((row.footerActions?.length ?? 0) > MAX_FOOTER_ACTIONS) {
     fail(`${path}.footerActions`, `supports at most ${MAX_FOOTER_ACTIONS} actions`);
   }
@@ -634,12 +674,13 @@ function assertRow(row, index, path = `rows[${index}]`) {
       assertMarketRow(row, path);
       break;
     case 'mediaTile':
+      assertMediaPreview(row.media, `${path}.media`);
       assertImage(row.image, `${path}.image`);
       if (row.imageState !== undefined && !['empty', 'error'].includes(row.imageState)) {
         fail(`${path}.imageState`, 'must be empty or error when provided');
       }
-      if (row.imageState === undefined && row.image === undefined) {
-        fail(`${path}.image`, 'is required unless imageState is empty or error');
+      if (row.imageState === undefined && row.image === undefined && row.media === undefined) {
+        fail(`${path}.image`, 'is required unless media is provided or imageState is empty or error');
       }
       assertImage(row.networkImage, `${path}.networkImage`);
       assertText(row.title, `${path}.title`);
@@ -668,6 +709,7 @@ function assertRow(row, index, path = `rows[${index}]`) {
       }
       break;
     case 'sectionHeader':
+      if (row.titleLoading !== undefined && typeof row.titleLoading !== 'boolean') fail(`${path}.titleLoading`, 'must be boolean');
       assertKey(row.sectionKey, `${path}.sectionKey`);
       if (row.presentation !== undefined && row.presentation !== 'networkSelector') {
         fail(`${path}.presentation`, 'must be networkSelector when provided');
@@ -746,12 +788,27 @@ function assertGroups(rows) {
     }
   }
 }
+function assertMediaPreview(value, path) {
+  if (value === undefined) return;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail(path, 'must be a media descriptor');
+  const media = value;
+  assertImage(media.source, `${path}.source`);
+  if (!media.source) fail(`${path}.source`, 'is required');
+  const order = media.probeOrder;
+  if (!Array.isArray(order) || order.length < 1 || order.length > 2 || order.some(kind => kind !== 'image' && kind !== 'video') || new Set(order).size !== order.length) {
+    fail(`${path}.probeOrder`, 'must contain one or two distinct image/video candidates');
+  }
+}
 export function validateSnapshot(snapshot) {
+  if (snapshot.capabilities?.refreshTriggerDistance !== undefined && (!Number.isFinite(snapshot.capabilities.refreshTriggerDistance) || snapshot.capabilities.refreshTriggerDistance <= 0)) fail('capabilities.refreshTriggerDistance', 'must be a positive finite number');
   assertPlainSerializable(snapshot, 'snapshot', new Set());
   if (snapshot.schemaVersion !== 1) fail('snapshot.schemaVersion', 'must be 1');
   if (!Number.isSafeInteger(snapshot.generation) || snapshot.generation < 0) {
     fail('snapshot.generation', 'must be a non-negative safe integer');
   }
+  if (snapshot.layout.gridColumns !== undefined && (!Number.isInteger(snapshot.layout.gridColumns) || snapshot.layout.gridColumns < 2 || snapshot.layout.gridColumns > 7)) {
+    fail('snapshot.layout.gridColumns', 'must be an integer from 2 to 7');
+  }
   if (snapshot.layout.kind === 'grid' && !snapshot.layout.gridColumns) {
     fail('snapshot.layout.gridColumns', 'is required for grid layout');
   }
@@ -880,6 +937,7 @@ function assertPatchChanges(patch, index) {
       assertLeadingVisual(patch.changes.visual, `${path}.visual`);
       break;
     case 'activity':
+      assertActivity(patch.changes, path);
       assertText(patch.changes.title, `${path}.title`);
       assertText(patch.changes.description, `${path}.description`);
       assertText(patch.changes.status, `${path}.status`);
@@ -933,6 +991,7 @@ function assertPatchChanges(patch, index) {
       }, path);
       break;
     case 'mediaTile':
+      assertMediaPreview(patch.changes.media, `${path}.media`);
       assertImage(patch.changes.image, `${path}.image`);
       if (patch.changes.imageState !== undefined && !['empty', 'error'].includes(patch.changes.imageState)) {
         fail(`${path}.imageState`, 'must be empty or error when provided');
@@ -965,6 +1024,7 @@ function assertPatchChanges(patch, index) {
       }
       break;
     case 'sectionHeader':
+      if (patch.changes.titleLoading !== undefined && typeof patch.changes.titleLoading !== 'boolean') fail(`${path}.titleLoading`, 'must be boolean');
       assertSectionHeaderVariant(patch.changes.variant, `${path}.variant`);
       assertText(patch.changes.title, `${path}.title`);
       assertText(patch.changes.subtitle, `${path}.subtitle`);