@onekeyfe/react-native-native-list 6.7.0-alpha.378 → 6.7.0-alpha.383

package/lib/module/validation.js

@@ -167,10 +167,13 @@ const TEXT_STYLE_KEYS_BY_ROW_TYPE = {
   metricCard: ['title', 'value', 'subtitle', 'trend'],
   sectionHeader: ['title', 'subtitle', 'value'],
   action: ['title', 'value'],
+  buttonGroup: [],
   system: ['title', 'message', 'actionText']
 };
 const EXTRA_STYLE_KEYS_BY_ROW_TYPE = {
-  market: ['titleBadgeLayout', 'contentTrailingGap', 'subtitleTrailingPadding', 'changeWidth', 'changeHeight', 'changeCornerRadius']
+  identity: ['leadingContentMaxWidthRatio'],
+  market: ['titleBadgeLayout', 'contentTrailingGap', 'subtitleTrailingPadding', 'changeWidth', 'changeHeight', 'changeCornerRadius'],
+  sectionHeader: ['valuePlacement', 'titleDecoration']
 };
 function assertTextStyle(style, path, additionalKeys = []) {
   if (style === undefined) return;
@@ -283,6 +286,15 @@ function assertRowStyle(row, path) {
   // Market keeps its own richer assertions, driven from assertMarketRow.
   if (row.type === 'market') return;
   assertBoxStyle(style, `${path}.style`);
+  if (row.type === 'identity') {
+    const ratio = style?.leadingContentMaxWidthRatio;
+    if (ratio !== undefined && (!Number.isFinite(ratio) || ratio <= 0 || ratio > 1)) fail(`${path}.style.leadingContentMaxWidthRatio`, 'must be within (0, 1]');
+  }
+  if (row.type === 'sectionHeader') {
+    const sectionStyle = style;
+    if (sectionStyle?.valuePlacement !== undefined && sectionStyle.valuePlacement !== 'afterTitle') fail(`${path}.style.valuePlacement`, 'must be afterTitle');
+    if (sectionStyle?.titleDecoration !== undefined && !['none', 'dashed'].includes(sectionStyle.titleDecoration)) fail(`${path}.style.titleDecoration`, 'must be none or dashed');
+  }
   const slots = style;
   textKeys.forEach(key => assertTextStyle(slots[key], `${path}.style.${key}`));
 }
@@ -572,15 +584,88 @@ function assertVisualShape(shape, path) {
 function assertTrailingAccessories(accessories, path) {
   accessories?.forEach((accessory, index) => {
     const accessoryPath = `${path}[${index}]`;
+    if (accessory.kind === 'button') {
+      assertUnknownKeys(accessory, ['kind', 'label', 'actionKey', 'disabled', 'testID', 'accessibilityLabel', 'textColor', 'backgroundColor', 'pressedBackgroundColor', 'hoverBackgroundColor', 'focusRingColor'], accessoryPath, 'button key');
+      if (typeof accessory.label !== 'string' || !accessory.label.trim()) fail(`${accessoryPath}.label`, 'must be non-blank');
+      assertKey(accessory.actionKey, `${accessoryPath}.actionKey`);
+      if (accessory.disabled !== undefined && typeof accessory.disabled !== 'boolean') fail(`${accessoryPath}.disabled`, 'must be boolean');
+      for (const field of ['textColor', 'backgroundColor', 'pressedBackgroundColor', 'hoverBackgroundColor', 'focusRingColor']) {
+        const value = accessory[field];
+        if (value !== undefined && (typeof value !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(value))) fail(`${accessoryPath}.${field}`, 'must be #RRGGBB or #RRGGBBAA');
+      }
+    }
+    if (accessory.kind === 'icon' && accessory.buttonStyle !== undefined && accessory.buttonStyle !== 'tertiary') fail(`${accessoryPath}.buttonStyle`, 'must be tertiary');
     if (accessory.kind === 'progress' && (accessory.value < 0 || accessory.value > 1)) {
       fail(`${accessoryPath}.value`, 'must be within 0...1');
     }
     if (accessory.kind === 'valuePair') {
+      if (accessory.primaryFontWeight !== undefined && accessory.primaryFontWeight !== 'medium') fail(`${accessoryPath}.primaryFontWeight`, 'must be medium when provided');
+      assertTextHelp(accessory.primaryHelp, `${accessoryPath}.primaryHelp`);
       assertTextTone(accessory.primaryTone, `${accessoryPath}.primaryTone`);
       assertTextTone(accessory.secondaryTone, `${accessoryPath}.secondaryTone`);
+      for (const field of ['primaryTextSegments', 'secondaryTextSegments']) {
+        const segments = accessory[field];
+        if (segments === undefined) continue;
+        const segmentPath = `${accessoryPath}.${field}`;
+        if (!Array.isArray(segments) || segments.length > 64) fail(segmentPath, 'must be an array of at most 64 segments');
+        let textLength = 0;
+        segments.forEach((segment, segmentIndex) => {
+          const path = `${segmentPath}[${segmentIndex}]`;
+          const entry = protocolObject(segment, path);
+          assertUnknownKeys(entry, ['text', 'style'], path, 'segment key');
+          if (typeof entry.text !== 'string' || entry.text.length > MAX_TEXT_LENGTH) fail(`${path}.text`, `must be a string no longer than ${MAX_TEXT_LENGTH} characters`);
+          if (entry.style !== undefined && entry.style !== 'subscript') fail(`${path}.style`, 'must be subscript when provided');
+          textLength += entry.text.length;
+        });
+        if (textLength > MAX_TEXT_LENGTH) fail(segmentPath, `total text must be at most ${MAX_TEXT_LENGTH} characters`);
+      }
+    }
+  });
+}
+function assertTextHelp(help, path) {
+  if (help === undefined) return;
+  const object = protocolObject(help, path);
+  assertUnknownKeys(object, ['actionKey', 'presentation', 'underline'], path, 'help key');
+  assertKey(help.actionKey, `${path}.actionKey`);
+  if (!['tooltip', 'popover'].includes(help.presentation)) fail(`${path}.presentation`, 'must be tooltip or popover');
+  if (help.underline !== undefined && help.underline !== 'dashed') fail(`${path}.underline`, 'must be dashed');
+}
+function assertButtonGroup(row, path) {
+  if (!Array.isArray(row.buttons) || row.buttons.length === 0) fail(`${path}.buttons`, 'must contain at least one button');
+  const keys = new Set();
+  row.buttons.forEach((button, index) => {
+    const itemPath = `${path}.buttons[${index}]`;
+    const object = protocolObject(button, itemPath);
+    assertUnknownKeys(object, ['key', 'label', 'actionKey', 'disabled', 'loading', 'testID', 'accessibilityLabel'], itemPath, 'button key');
+    assertKey(button.key, `${itemPath}.key`);
+    if (keys.has(button.key)) fail(`${itemPath}.key`, 'duplicate button key');
+    keys.add(button.key);
+    if (typeof button.label !== 'string' || !button.label.trim() || button.label.length > MAX_TEXT_LENGTH) fail(`${itemPath}.label`, 'must be non-blank bounded text');
+    assertKey(button.actionKey, `${itemPath}.actionKey`);
+    for (const field of ['disabled', 'loading']) {
+      if (button[field] !== undefined && typeof button[field] !== 'boolean') fail(`${itemPath}.${field}`, 'must be boolean');
+    }
+    for (const field of ['testID', 'accessibilityLabel']) {
+      if (button[field] !== undefined && typeof button[field] !== 'string') fail(`${itemPath}.${field}`, 'must be a string');
     }
   });
 }
+function assertIdentityExtras(row, path) {
+  for (const field of ['titleIcon', 'secondaryTitleIcon']) {
+    const titleIcon = row[field];
+    if (titleIcon === undefined) continue;
+    const iconPath = `${path}.${field}`;
+    const icon = protocolObject(titleIcon, iconPath);
+    assertUnknownKeys(icon, ['name', 'tintColor', 'accessibilityLabel', 'hoverActionKey'], iconPath, 'title icon key');
+    if (typeof titleIcon.name !== 'string' || !titleIcon.name.trim()) fail(`${iconPath}.name`, 'must be non-blank');
+    if (titleIcon.tintColor !== undefined && (typeof titleIcon.tintColor !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(titleIcon.tintColor))) fail(`${iconPath}.tintColor`, 'must be #RRGGBB or #RRGGBBAA');
+    if (titleIcon.accessibilityLabel !== undefined && typeof titleIcon.accessibilityLabel !== 'string') fail(`${iconPath}.accessibilityLabel`, 'must be a string');
+    if (titleIcon.hoverActionKey !== undefined) assertKey(titleIcon.hoverActionKey, `${iconPath}.hoverActionKey`);
+  }
+  const ratio = row.style?.leadingContentMaxWidthRatio;
+  if (ratio !== undefined && (typeof ratio !== 'number' || !Number.isFinite(ratio) || ratio <= 0 || ratio > 1)) fail(`${path}.style.leadingContentMaxWidthRatio`, 'must be within (0, 1]');
+  assertTrailingAccessories(row.trailing, `${path}.trailing`);
+}
 function assertImage(image, path) {
   if (!image) return;
   if (!image.uri.trim()) fail(`${path}.uri`, 'must not be empty');
@@ -625,6 +710,9 @@ function assertLeadingVisual(visual, path) {
     assertText(visual.cornerIcon?.name, `${path}.cornerIcon.name`);
     // OneKey patch: validate optional selector overlays at the JSON boundary.
     assertText(visual.fallbackIcon?.name, `${path}.fallbackIcon.name`);
+    if (visual.fallbackTextColor !== undefined && (typeof visual.fallbackTextColor !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(visual.fallbackTextColor))) fail(`${path}.fallbackTextColor`, 'must be a hex color');
+    if (visual.fallbackIcon?.size !== undefined && (!Number.isFinite(visual.fallbackIcon.size) || visual.fallbackIcon.size <= 0 || visual.fallbackIcon.size > 40)) fail(`${path}.fallbackIcon.size`, 'must be within (0, 40]');
+    if (visual.fallbackIcon?.backgroundColor !== undefined && !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(visual.fallbackIcon.backgroundColor)) fail(`${path}.fallbackIcon.backgroundColor`, 'must be a hex color');
     if ((visual.overlays?.length ?? 0) > 2) fail(`${path}.overlays`, 'supports at most two overlays');
     visual.overlays?.forEach((overlay, index) => {
       if (!['topLeft', 'bottomRight'].includes(overlay.position)) fail(`${path}.overlays[${index}].position`, 'must be topLeft or bottomRight');
@@ -641,7 +729,11 @@ function assertLeadingVisual(visual, path) {
       }
       if (overlay.padding !== undefined && overlay.padding * 2 >= Math.min(overlay.width ?? overlay.size ?? 20, overlay.height ?? overlay.size ?? 20)) fail(`${path}.overlays[${index}].padding`, 'must fit inside the overlay');
       assertImage(overlay.image, `${path}.overlays[${index}].image`);
+      if (overlay.fallbackIcon !== undefined && !overlay.image) fail(`${path}.overlays[${index}].fallbackIcon`, 'requires image');
+      if (overlay.fallbackIcon !== undefined && (typeof overlay.fallbackIcon.name !== 'string' || !overlay.fallbackIcon.name.trim())) fail(`${path}.overlays[${index}].fallbackIcon.name`, 'must be non-blank');
+      if (overlay.fallbackIcon?.tintColor !== undefined && !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(overlay.fallbackIcon.tintColor)) fail(`${path}.overlays[${index}].fallbackIcon.tintColor`, 'must be a hex color');
       assertText(overlay.text, `${path}.overlays[${index}].text`);
+      if (overlay.fontWeight !== undefined && !['regular', 'medium', 'semibold', 'bold'].includes(overlay.fontWeight)) fail(`${path}.overlays[${index}].fontWeight`, 'must be regular, medium, semibold, or bold');
     });
     if (visual.kind === 'token') {
       assertImage(visual.networkImage, `${path}.networkImage`);
@@ -655,6 +747,7 @@ function assertVisual(row, path) {
   });
 }
 function assertActivity(row, path) {
+  if (row.hideLeading !== undefined && typeof row.hideLeading !== 'boolean') fail(`${path}.hideLeading`, 'must be boolean');
   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');
@@ -751,10 +844,26 @@ function assertRow(row, index, path = `rows[${index}]`) {
       assertWalletGroup(row, path);
       break;
     case 'identity':
+      if (row.contentHeight !== undefined && row.contentHeight !== 'auto') {
+        fail(`${path}.contentHeight`, 'must be auto');
+      }
+      if (row.subtitleLines !== undefined && ![0, 1, 2].includes(row.subtitleLines)) {
+        fail(`${path}.subtitleLines`, 'must be 0, 1, or 2');
+      }
+      if (row.longPressActionKey !== undefined) {
+        assertKey(row.longPressActionKey, `${path}.longPressActionKey`);
+      }
       if (row.presentation !== undefined && row.presentation !== 'walletSidebar' && row.presentation !== 'accountSelector' && row.presentation !== 'networkSelector') {
         fail(`${path}.presentation`, 'must be walletSidebar, accountSelector, or networkSelector when provided');
       }
       assertText(row.title, `${path}.title`);
+      if ((row.titleSuffixes?.length ?? 0) > 3) fail(`${path}.titleSuffixes`, 'supports at most 3 suffixes');
+      row.titleSuffixes?.forEach((suffix, index) => {
+        assertText(suffix.text, `${path}.titleSuffixes[${index}].text`);
+        if (!['secondary', 'disabled'].includes(suffix.tone)) fail(`${path}.titleSuffixes[${index}].tone`, 'must be secondary or disabled');
+        if (suffix.maxWidth !== undefined && (!Number.isFinite(suffix.maxWidth) || suffix.maxWidth < 0 || suffix.maxWidth > 4096)) fail(`${path}.titleSuffixes[${index}].maxWidth`, 'must be finite within 0...4096');
+      });
+      assertIdentityExtras(row, path);
       assertText(row.subtitle, `${path}.subtitle`);
       // OneKey patch: selector text segments truncate independently.
       row.subtitleSegments?.forEach((segment, segmentIndex) => {
@@ -786,10 +895,13 @@ function assertRow(row, index, path = `rows[${index}]`) {
       assertActivity(row, path);
       break;
     case 'message':
+      if (row.presentation !== undefined && row.presentation !== 'inlineWarning') {
+        fail(`${path}.presentation`, 'must be inlineWarning');
+      }
       assertText(row.title, `${path}.title`);
       assertText(row.body, `${path}.body`);
-      if (![1, 2, 3].includes(row.bodyLines ?? 3)) {
-        fail(`${path}.bodyLines`, 'must be 1, 2, or 3');
+      if (![0, 1, 2, 3].includes(row.bodyLines ?? 3)) {
+        fail(`${path}.bodyLines`, 'must be 0, 1, 2, or 3');
       }
       assertImage(row.thumbnail, `${path}.thumbnail`);
       break;
@@ -800,6 +912,13 @@ function assertRow(row, index, path = `rows[${index}]`) {
       row.columns.forEach((column, columnIndex) => {
         assertKey(column.key, `${path}.columns[${columnIndex}].key`);
         assertText(column.text, `${path}.columns[${columnIndex}].text`);
+        assertIdentityExtras(column, `${path}.columns[${columnIndex}]`);
+        for (const field of ['textSegments', 'secondaryTextSegments']) {
+          column[field]?.forEach((segment, segmentIndex) => {
+            assertText(segment.text, `${path}.columns[${columnIndex}].${field}[${segmentIndex}].text`);
+            if (segment.style !== undefined && segment.style !== 'subscript') fail(`${path}.columns[${columnIndex}].${field}[${segmentIndex}].style`, 'must be subscript');
+          });
+        }
         assertText(column.secondaryLeadingText, `${path}.columns[${columnIndex}].secondaryLeadingText`);
         assertText(column.secondaryText, `${path}.columns[${columnIndex}].secondaryText`);
         assertTextTone(column.secondaryTone, `${path}.columns[${columnIndex}].secondaryTone`);
@@ -807,6 +926,10 @@ function assertRow(row, index, path = `rows[${index}]`) {
       if ((row.badges?.length ?? 0) > MAX_BADGES) {
         fail(`${path}.badges`, `supports at most ${MAX_BADGES} badges`);
       }
+      if ((row.trailing?.length ?? 0) > MAX_TRAILING_ACCESSORIES) {
+        fail(`${path}.trailing`, `supports at most ${MAX_TRAILING_ACCESSORIES} accessories`);
+      }
+      assertTrailingAccessories(row.trailing, `${path}.trailing`);
       break;
     case 'market':
       assertMarketRow(row, path);
@@ -857,6 +980,11 @@ function assertRow(row, index, path = `rows[${index}]`) {
       assertText(row.title, `${path}.title`);
       assertText(row.subtitle, `${path}.subtitle`);
       assertText(row.value, `${path}.value`);
+      if (row.leadingBadge) {
+        assertKey(row.leadingBadge.key, `${path}.leadingBadge.key`);
+        assertText(row.leadingBadge.text, `${path}.leadingBadge.text`);
+      }
+      assertTextHelp(row.valueHelp, `${path}.valueHelp`);
       if (row.valueActionKey !== undefined) {
         assertKey(row.valueActionKey, `${path}.valueActionKey`);
       }
@@ -877,6 +1005,9 @@ function assertRow(row, index, path = `rows[${index}]`) {
       }
       assertTrailingAccessories(row.trailing, `${path}.trailing`);
       break;
+    case 'buttonGroup':
+      assertButtonGroup(row, path);
+      break;
     case 'system':
       const presentation = 'presentation' in row ? row.presentation : undefined;
       if (presentation !== undefined && presentation !== 'market') {
@@ -938,9 +1069,22 @@ function assertMediaPreview(value, path) {
   }
 }
 function assertSnapshotContract(snapshot) {
+  if (snapshot.disclosure !== undefined) {
+    if (typeof snapshot.disclosure.expanded !== 'boolean') fail('snapshot.disclosure.expanded', 'must be a boolean');
+    const inset = snapshot.disclosure.expandedTrailingInset;
+    if (inset !== undefined && (!Number.isFinite(inset) || inset < 0)) fail('snapshot.disclosure.expandedTrailingInset', 'must be finite and nonnegative');
+  }
+  if (snapshot.structuralTransition) {
+    assertKey(snapshot.structuralTransition.id, 'snapshot.structuralTransition.id');
+    if (snapshot.structuralTransition.anchorKey !== undefined) assertKey(snapshot.structuralTransition.anchorKey, 'snapshot.structuralTransition.anchorKey');
+    const duration = snapshot.structuralTransition.durationMs;
+    if (duration !== undefined && (!Number.isFinite(duration) || duration < 0 || duration > 2000)) fail('snapshot.structuralTransition.durationMs', 'must be finite within 0...2000');
+  }
   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());
   assertText(snapshot.theme?.imageFallbackBackground, 'theme.imageFallbackBackground');
+  if (snapshot.theme?.successBackground !== undefined && (typeof snapshot.theme.successBackground !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(snapshot.theme.successBackground))) fail('theme.successBackground', 'must be a hex color');
+  if (snapshot.theme?.rowHoverBackground !== undefined && (typeof snapshot.theme.rowHoverBackground !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(snapshot.theme.rowHoverBackground))) fail('theme.rowHoverBackground', 'must be a hex color');
   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');
@@ -1018,8 +1162,8 @@ function protocolObject(value, path) {
 function protocolKey(value, path) {
   if (typeof value !== 'string' || value.trim().length === 0) fail(path, 'must be a non-blank string');
 }
-const PROTOCOL_ARRAY_FIELDS = new Set(['columns', 'cells', 'points', 'images', 'overlays', 'badges', 'trailing', 'footerActions', 'amounts', 'metrics', 'children', 'subtitleSegments', 'titleMatch', 'selectedKeys', 'segments', 'hoverSecondary', 'hoverImages', 'secondaryBadges', 'fallbackUris', 'probeOrder', 'priceSegments', 'textSegments', 'secondaryTextSegments', 'primaryTextSegments']);
-const PROTOCOL_NUMBER_FIELDS = new Set(['height', 'width', 'fontSize', 'lineHeight', 'opacity', 'offsetY', 'offsetX', 'cornerRadius', 'borderWidth', 'horizontalPadding', 'verticalPadding', 'leadingGap', 'lineGap', 'titleBadgeGap', 'trailingGap', 'start', 'end', 'padding', 'offset', 'overscan', 'minWidth', 'flex', 'paddingStart', 'paddingEnd', 'changeWidth', 'changeHeight', 'changeCornerRadius', 'contentTrailingGap', 'subtitleTrailingPadding', 'partGap', 'contentPadding', 'contentPaddingHorizontal', 'contentPaddingTop', 'contentPaddingBottom', 'itemSpacing', 'gridColumns']);
+const PROTOCOL_ARRAY_FIELDS = new Set(['columns', 'titleSuffixes', 'cells', 'points', 'images', 'overlays', 'badges', 'trailing', 'footerActions', 'buttons', 'amounts', 'metrics', 'children', 'subtitleSegments', 'titleMatch', 'selectedKeys', 'segments', 'hoverSecondary', 'hoverImages', 'secondaryBadges', 'fallbackUris', 'probeOrder', 'priceSegments', 'textSegments', 'secondaryTextSegments', 'primaryTextSegments']);
+const PROTOCOL_NUMBER_FIELDS = new Set(['leadingContentMaxWidthRatio', 'height', 'width', 'fontSize', 'lineHeight', 'opacity', 'offsetY', 'offsetX', 'cornerRadius', 'borderWidth', 'horizontalPadding', 'verticalPadding', 'leadingGap', 'lineGap', 'titleBadgeGap', 'trailingGap', 'start', 'end', 'padding', 'offset', 'overscan', 'minWidth', 'flex', 'paddingStart', 'paddingEnd', 'changeWidth', 'changeHeight', 'changeCornerRadius', 'contentTrailingGap', 'subtitleTrailingPadding', 'partGap', 'contentPadding', 'contentPaddingHorizontal', 'contentPaddingTop', 'contentPaddingBottom', 'itemSpacing', 'gridColumns']);
 
 /** Validate only shapes that renderers dereference, not display budgets. */
 function assertProtocolFields(value, path, parentField = '') {
@@ -1037,6 +1181,15 @@ function assertProtocolFields(value, path, parentField = '') {
     return;
   }
   const object = value;
+  if (parentField === 'fallbackIcon') {
+    protocolKey(object.name, `${path}.name`);
+    if (object.size !== undefined && (typeof object.size !== 'number' || !Number.isFinite(object.size) || object.size <= 0 || object.size > 40)) fail(`${path}.size`, 'must be within (0, 40]');
+    for (const field of ['tintColor', 'backgroundColor']) {
+      const color = object[field];
+      if (color !== undefined && (typeof color !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(color))) fail(`${path}.${field}`, 'must be a hex color');
+    }
+  }
+  if (parentField === 'overlays' && object.fallbackIcon !== undefined && !object.image) fail(`${path}.fallbackIcon`, 'requires image');
   if (!path.includes('.style.') && ['image', 'networkImage', 'thumbnail', 'images', 'hoverImages'].includes(parentField) && typeof object.uri !== 'string') fail(`${path}.uri`, 'must be a string');
   Object.entries(value).forEach(([field, item]) => {
     if (item === undefined) return;
@@ -1044,6 +1197,9 @@ function assertProtocolFields(value, path, parentField = '') {
     if (!path.endsWith('.style') && PROTOCOL_ARRAY_FIELDS.has(field) && !Array.isArray(item)) fail(fieldPath, 'must be an array');
     if (PROTOCOL_NUMBER_FIELDS.has(field) && typeof item !== 'number') fail(fieldPath, 'must be a finite number');
     if (PROTOCOL_NUMBER_FIELDS.has(field) && typeof item === 'number' && item < 0 && !['offsetX', 'offsetY'].includes(field)) fail(fieldPath, 'must be non-negative');
+    if (parentField === 'overlays' && field === 'fontWeight' && !['regular', 'medium', 'semibold', 'bold'].includes(item)) fail(fieldPath, 'must be regular, medium, semibold, or bold');
+    if (field === 'buttonStyle' && item !== 'tertiary') fail(fieldPath, 'must be tertiary');
+    if (field === 'hideLeading' && typeof item !== 'boolean') fail(fieldPath, 'must be boolean');
     if (field === 'key' || field === 'sectionKey' || field === 'actionKey' || field.endsWith('ActionKey')) protocolKey(item, fieldPath);
     if ((field === 'uri' || field === 'fallbackUri') && typeof item !== 'string') fail(fieldPath, 'must be a string');
     if (field === 'style' && !(item === 'subscript' && /[Ss]egments\[/.test(path)) || field === 'container') protocolObject(item, fieldPath);
@@ -1069,12 +1225,21 @@ function assertRowProtocol(row, path) {
   }
   if (row.height !== undefined && row.height < 0) fail(`${path}.height`, 'must be non-negative');
   if (row.type === 'identity') {
+    assertIdentityExtras(row, path);
+    if (row.titleSuffixes !== undefined && !Array.isArray(row.titleSuffixes)) fail(`${path}.titleSuffixes`, 'must be an array');
+    row.titleSuffixes?.forEach((suffix, index) => {
+      protocolObject(suffix, `${path}.titleSuffixes[${index}]`);
+      if (typeof suffix.text !== 'string' || !['secondary', 'disabled'].includes(suffix.tone)) fail(`${path}.titleSuffixes[${index}]`, 'invalid title suffix');
+      if (suffix.maxWidth !== undefined && (!Number.isFinite(suffix.maxWidth) || suffix.maxWidth < 0 || suffix.maxWidth > 4096)) fail(`${path}.titleSuffixes[${index}].maxWidth`, 'must be finite within 0...4096');
+    });
     let end = 0;
     row.titleMatch?.forEach(match => {
       if (!Number.isInteger(match.start) || !Number.isInteger(match.end) || match.start < end || match.end <= match.start || match.end > row.title.length) fail(`${path}.titleMatch`, 'invalid text range');
       end = match.end;
     });
   }
+  if (row.type === 'buttonGroup') assertButtonGroup(row, path);
+  if (row.type === 'sectionHeader') assertTextHelp(row.valueHelp, `${path}.valueHelp`);
   if (row.type === 'mediaTile' && row.media) {
     protocolObject(row.media.source, `${path}.media.source`);
     if (!Array.isArray(row.media.probeOrder)) fail(`${path}.media.probeOrder`, 'must be an array');
@@ -1091,7 +1256,15 @@ function assertRowProtocol(row, path) {
       keys.add(member.key);
     });
   }
-  if (row.type === 'dataRow' && !Array.isArray(row.columns)) fail(`${path}.columns`, 'must be an array');
+  if (row.type === 'dataRow') {
+    if (!Array.isArray(row.columns)) fail(`${path}.columns`, 'must be an array');
+    row.columns.forEach((column, index) => {
+      const columnPath = `${path}.columns[${index}]`;
+      protocolObject(column, columnPath);
+      assertIdentityExtras(column, columnPath);
+    });
+    assertTrailingAccessories(row.trailing, `${path}.trailing`);
+  }
   if (row.type === 'market') {
     protocolObject(row.change, `${path}.change`);
     if (row.webTable) {
@@ -1118,6 +1291,21 @@ function assertRowProtocol(row, path) {
 }
 function assertSnapshotProtocol(snapshot) {
   protocolObject(snapshot, 'snapshot');
+  if (snapshot.disclosure !== undefined) {
+    protocolObject(snapshot.disclosure, 'snapshot.disclosure');
+    if (typeof snapshot.disclosure.expanded !== 'boolean') fail('snapshot.disclosure.expanded', 'must be a boolean');
+    const inset = snapshot.disclosure.expandedTrailingInset;
+    if (inset !== undefined && (!Number.isFinite(inset) || inset < 0)) fail('snapshot.disclosure.expandedTrailingInset', 'must be finite and nonnegative');
+  }
+  if (snapshot.structuralTransition) {
+    protocolObject(snapshot.structuralTransition, 'snapshot.structuralTransition');
+    protocolKey(snapshot.structuralTransition.id, 'snapshot.structuralTransition.id');
+    if (snapshot.structuralTransition.anchorKey !== undefined) protocolKey(snapshot.structuralTransition.anchorKey, 'snapshot.structuralTransition.anchorKey');
+    const duration = snapshot.structuralTransition.durationMs;
+    if (duration !== undefined && (!Number.isFinite(duration) || duration < 0 || duration > 2000)) fail('snapshot.structuralTransition.durationMs', 'must be finite within 0...2000');
+  }
+  if (snapshot.theme?.successBackground !== undefined && (typeof snapshot.theme.successBackground !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(snapshot.theme.successBackground))) fail('theme.successBackground', 'must be a hex color');
+  if (snapshot.theme?.rowHoverBackground !== undefined && (typeof snapshot.theme.rowHoverBackground !== 'string' || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(snapshot.theme.rowHoverBackground))) fail('theme.rowHoverBackground', 'must be a hex color');
   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');
   protocolObject(snapshot.layout, 'snapshot.layout');
@@ -1174,6 +1362,53 @@ export function validateSnapshot(snapshot) {
   assertSnapshotProtocol(normalized);
   return normalizeSnapshotStyles(normalized);
 }
+const ownedNativeSnapshots = new WeakMap();
+function capturePlainData(value, seen = new Map()) {
+  if (value === null || typeof value !== 'object') return value;
+  const previous = seen.get(value);
+  if (previous) return previous;
+  const copy = Array.isArray(value) ? new Array(value.length) : Object.create(Object.getPrototypeOf(value));
+  seen.set(value, copy);
+  const captureKey = key => {
+    Object.defineProperty(copy, key, {
+      value: capturePlainData(value[key], seen),
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  };
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) {
+      if (index in value) captureKey(String(index));
+    }
+    Object.keys(value).forEach(key => {
+      const index = Number(key);
+      if (Number.isInteger(index) && index >= 0 && index < value.length && String(index) === key) return;
+      captureKey(key);
+    });
+  } else {
+    Object.keys(value).forEach(captureKey);
+  }
+  return copy;
+}
+function deepFreeze(value, seen = new WeakSet()) {
+  if (value === null || typeof value !== 'object' || seen.has(value)) return value;
+  seen.add(value);
+  Object.values(value).forEach(item => deepFreeze(item, seen));
+  return Object.freeze(value);
+}
+
+/** Capture caller data once before validation, including accessor values. */
+export function captureNativeListInput(value) {
+  return capturePlainData(value);
+}
+
+/** Private native-wrapper ownership; exported validators keep their public identity. */
+export function ownValidatedNativeSnapshot(snapshot) {
+  const owned = deepFreeze(snapshot);
+  ownedNativeSnapshots.set(owned, new Map(owned.rows.map((row, index) => [row.key, index])));
+  return owned;
+}
 
 /**
  * Resolves typography tokens to numbers. Returns the original snapshot when
@@ -1218,7 +1453,23 @@ function assertPatchChanges(patch, index) {
   }
   switch (patch.type) {
     case 'identity':
+      if (patch.changes.contentHeight !== undefined && patch.changes.contentHeight !== 'auto') {
+        fail(`${path}.contentHeight`, 'must be auto');
+      }
+      if (patch.changes.subtitleLines !== undefined && ![0, 1, 2].includes(patch.changes.subtitleLines)) {
+        fail(`${path}.subtitleLines`, 'must be 0, 1, or 2');
+      }
+      if (patch.changes.longPressActionKey !== undefined) {
+        assertKey(patch.changes.longPressActionKey, `${path}.longPressActionKey`);
+      }
       assertText(patch.changes.title, `${path}.title`);
+      if ((patch.changes.titleSuffixes?.length ?? 0) > 3) fail(`${path}.titleSuffixes`, 'supports at most 3 suffixes');
+      patch.changes.titleSuffixes?.forEach((suffix, index) => {
+        assertText(suffix.text, `${path}.titleSuffixes[${index}].text`);
+        if (!['secondary', 'disabled'].includes(suffix.tone)) fail(`${path}.titleSuffixes[${index}].tone`, 'must be secondary or disabled');
+        if (suffix.maxWidth !== undefined && (!Number.isFinite(suffix.maxWidth) || suffix.maxWidth < 0 || suffix.maxWidth > 4096)) fail(`${path}.titleSuffixes[${index}].maxWidth`, 'must be finite within 0...4096');
+      });
+      assertIdentityExtras(patch.changes, path);
       assertText(patch.changes.subtitle, `${path}.subtitle`);
       assertText(patch.changes.tertiary, `${path}.tertiary`);
       if (patch.changes.tertiaryTone !== undefined && !['secondary', 'info'].includes(patch.changes.tertiaryTone)) {
@@ -1252,11 +1503,14 @@ function assertPatchChanges(patch, index) {
       }
       break;
     case 'message':
+      if (patch.changes.presentation !== undefined && patch.changes.presentation !== 'inlineWarning') {
+        fail(`${path}.presentation`, 'must be inlineWarning');
+      }
       assertText(patch.changes.title, `${path}.title`);
       assertText(patch.changes.body, `${path}.body`);
       assertText(patch.changes.time, `${path}.time`);
-      if (patch.changes.bodyLines !== undefined && ![1, 2, 3].includes(patch.changes.bodyLines)) {
-        fail(`${path}.bodyLines`, 'must be 1, 2, or 3');
+      if (patch.changes.bodyLines !== undefined && ![0, 1, 2, 3].includes(patch.changes.bodyLines)) {
+        fail(`${path}.bodyLines`, 'must be 0, 1, 2, or 3');
       }
       assertImage(patch.changes.thumbnail, `${path}.thumbnail`);
       break;
@@ -1267,12 +1521,23 @@ function assertPatchChanges(patch, index) {
       patch.changes.columns?.forEach((column, columnIndex) => {
         assertKey(column.key, `${path}.columns[${columnIndex}].key`);
         assertText(column.text, `${path}.columns[${columnIndex}].text`);
+        assertIdentityExtras(column, `${path}.columns[${columnIndex}]`);
+        for (const field of ['textSegments', 'secondaryTextSegments']) {
+          column[field]?.forEach((segment, segmentIndex) => {
+            assertText(segment.text, `${path}.columns[${columnIndex}].${field}[${segmentIndex}].text`);
+            if (segment.style !== undefined && segment.style !== 'subscript') fail(`${path}.columns[${columnIndex}].${field}[${segmentIndex}].style`, 'must be subscript');
+          });
+        }
         assertText(column.secondaryText, `${path}.columns[${columnIndex}].secondaryText`);
         assertTextTone(column.secondaryTone, `${path}.columns[${columnIndex}].secondaryTone`);
       });
       if ((patch.changes.badges?.length ?? 0) > MAX_BADGES) {
         fail(`${path}.badges`, `supports at most ${MAX_BADGES} badges`);
       }
+      if ((patch.changes.trailing?.length ?? 0) > MAX_TRAILING_ACCESSORIES) {
+        fail(`${path}.trailing`, `supports at most ${MAX_TRAILING_ACCESSORIES} accessories`);
+      }
+      assertTrailingAccessories(patch.changes.trailing, `${path}.trailing`);
       break;
     case 'market':
       assertMarketRow({
@@ -1331,6 +1596,11 @@ function assertPatchChanges(patch, index) {
       assertText(patch.changes.title, `${path}.title`);
       assertText(patch.changes.subtitle, `${path}.subtitle`);
       assertText(patch.changes.value, `${path}.value`);
+      if (patch.changes.leadingBadge) {
+        assertKey(patch.changes.leadingBadge.key, `${path}.leadingBadge.key`);
+        assertText(patch.changes.leadingBadge.text, `${path}.leadingBadge.text`);
+      }
+      assertTextHelp(patch.changes.valueHelp, `${path}.valueHelp`);
       if (patch.changes.valueActionKey !== undefined) {
         assertKey(patch.changes.valueActionKey, `${path}.valueActionKey`);
       }
@@ -1344,6 +1614,11 @@ function assertPatchChanges(patch, index) {
       }
       assertTrailingAccessories(patch.changes.trailing, `${path}.trailing`);
       break;
+    case 'buttonGroup':
+      if (patch.changes.buttons !== undefined) assertButtonGroup({
+        buttons: patch.changes.buttons
+      }, path);
+      break;
     case 'system':
       assertText(patch.changes.message, `${path}.message`);
       break;
@@ -1363,6 +1638,7 @@ export function validatePatches(patches) {
     protocolObject(patch.changes, `patches[${index}].changes`);
     assertRowType(patch.type, `patches[${index}]`);
     assertProtocolFields(patch.changes, `patches[${index}].changes`);
+    if (patch.type === 'identity') assertIdentityExtras(patch.changes, `patches[${index}].changes`);
     if (!isDevelopment()) continue;
     assertKey(patch.key, `patches[${index}].key`);
     if (Object.keys(patch.changes).length === 0) {
@@ -1393,6 +1669,96 @@ function normalizePatchStyles(patches) {
   });
   return changed ? next : patches;
 }
+const EMPTY_ROW_PATCHES = Object.freeze([]);
+function sameJsonValue(left, right) {
+  if (left === right) return true;
+  if (left === null || right === null) return false;
+  if (typeof left !== 'object' || typeof right !== 'object') return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameJsonValue(value, right[index]));
+  }
+  const leftObject = left;
+  const rightObject = right;
+  const leftKeys = Object.keys(leftObject).filter(key => leftObject[key] !== undefined);
+  const rightKeys = Object.keys(rightObject).filter(key => rightObject[key] !== undefined);
+  return leftKeys.length === rightKeys.length && leftKeys.every(key => sameJsonValue(leftObject[key], rightObject[key]));
+}
+function sameOptionalPresence(left, right) {
+  return left === undefined === (right === undefined);
+}
+
+/** Plan value-only patches; callers own valid immutable snapshots and commit state. */
+export function planNativeListPatches(previous, next) {
+  if (previous === next) return EMPTY_ROW_PATCHES;
+  const {
+    rows: previousRows,
+    ...previousMetadata
+  } = previous;
+  const {
+    rows: nextRows,
+    ...nextMetadata
+  } = next;
+  if (previousRows.length !== nextRows.length || !sameJsonValue(previousMetadata, nextMetadata)) return undefined;
+  if (previousRows === nextRows) return EMPTY_ROW_PATCHES;
+  const patches = [];
+  for (let index = 0; index < nextRows.length; index += 1) {
+    const oldRow = previousRows[index];
+    const row = nextRows[index];
+    if (oldRow.key !== row.key || oldRow.type !== row.type) return undefined;
+    if (oldRow === row) continue;
+    if (oldRow.type === 'identity' && row.type === 'identity') {
+      const {
+        subtitle: oldSubtitle,
+        subtitleSegments: oldSubtitleSegments,
+        trailing: oldTrailing,
+        ...oldMetadata
+      } = oldRow;
+      const {
+        subtitle,
+        subtitleSegments,
+        trailing,
+        ...metadata
+      } = row;
+      if (!sameOptionalPresence(oldSubtitle, subtitle) || !sameOptionalPresence(oldSubtitleSegments, subtitleSegments) || !sameOptionalPresence(oldTrailing, trailing) || !sameJsonValue(oldMetadata, metadata)) return undefined;
+      if (!sameJsonValue(oldSubtitle, subtitle) || !sameJsonValue(oldSubtitleSegments, subtitleSegments) || !sameJsonValue(oldTrailing, trailing)) {
+        patches.push({
+          type: 'identity',
+          key: row.key,
+          changes: {
+            subtitle,
+            subtitleSegments,
+            trailing
+          }
+        });
+      }
+    } else if (oldRow.type === 'dataRow' && row.type === 'dataRow') {
+      const {
+        columns: oldColumns,
+        trailing: oldTrailing,
+        ...oldMetadata
+      } = oldRow;
+      const {
+        columns,
+        trailing,
+        ...metadata
+      } = row;
+      if (!sameOptionalPresence(oldTrailing, trailing) || !sameJsonValue(oldMetadata, metadata) || !sameJsonValue(oldColumns[0], columns[0])) return undefined;
+      if (!sameJsonValue(oldColumns.slice(1), columns.slice(1)) || !sameJsonValue(oldTrailing, trailing)) {
+        patches.push({
+          type: 'dataRow',
+          key: row.key,
+          changes: {
+            columns,
+            trailing
+          }
+        });
+      }
+    } else if (!sameJsonValue(oldRow, row)) {
+      return undefined;
+    }
+  }
+  return patches.length === 0 ? EMPTY_ROW_PATCHES : patches;
+}
 export function applyRowPatches(snapshot, patches) {
   const normalizedPatches = validatePatches(patches);
   const patchByKey = new Map(normalizedPatches.map(patch => [patch.key, patch]));
@@ -1419,6 +1785,53 @@ export function applyRowPatches(snapshot, patches) {
     rows
   });
 }
+
+/** Native wrapper only: preserve full public validation for unsupported patches. */
+export function applyOwnedNativePatches(snapshot, patches) {
+  const acceptedPatches = deepFreeze(validatePatches(capturePlainData(patches)));
+  const rowIndexes = ownedNativeSnapshots.get(snapshot);
+  const canPatchRows = rowIndexes !== undefined && acceptedPatches.every(patch => {
+    const index = rowIndexes.get(patch.key);
+    if (index === undefined || snapshot.rows[index].type !== patch.type) return false;
+    const allowed = patch.type === 'identity' ? ['subtitle', 'subtitleSegments', 'trailing'] : patch.type === 'dataRow' ? ['columns', 'trailing'] : undefined;
+    return allowed !== undefined && Object.entries(patch.changes).every(([key, value]) => allowed.includes(key) && (value !== undefined || snapshot.rows[index][key] === undefined));
+  });
+  if (!canPatchRows) {
+    const baseline = rowIndexes ? snapshot : capturePlainData(snapshot);
+    return {
+      patches: acceptedPatches,
+      snapshot: ownValidatedNativeSnapshot(applyRowPatches(baseline, acceptedPatches)),
+      json: JSON.stringify(acceptedPatches)
+    };
+  }
+  const nextRows = snapshot.rows.slice();
+  for (const patch of acceptedPatches) {
+    const index = rowIndexes.get(patch.key);
+    const previous = nextRows[index];
+    const merged = {
+      ...previous,
+      ...patch.changes,
+      key: previous.key,
+      type: previous.type
+    };
+    const path = `rows[${index}]`;
+    assertPlainSerializable(merged, path, new Set());
+    if (isDevelopment()) assertRow(merged, index);
+    const normalized = isDevelopment() ? merged : normalizeEmptyImages(merged);
+    assertRowProtocol(normalized, path);
+    nextRows[index] = deepFreeze(normalizeRowStyles(normalized));
+  }
+  const nextSnapshot = Object.freeze({
+    ...snapshot,
+    rows: Object.freeze(nextRows)
+  });
+  ownedNativeSnapshots.set(nextSnapshot, rowIndexes);
+  return {
+    patches: acceptedPatches,
+    snapshot: nextSnapshot,
+    json: JSON.stringify(acceptedPatches)
+  };
+}
 export function serializeSnapshot(snapshot) {
   return JSON.stringify(validateSnapshot(snapshot));
 }