@blario/react-native 0.1.5 → 0.1.6

package/README.md

@@ -63,6 +63,7 @@ export default function App() {
 Screenshots use `react-native-view-shot` when it is installed, otherwise `@shopify/react-native-skia`
 (`makeImageFromView`) on iOS. Android requires view-shot: Skia's Android capture can raise a fatal native error
 when a view unmounts during capture. With no supported capture module, a screenshot answers `sdk_error`.
+Android on the New Architecture needs view-shot 4 or later: 3.x fails every capture there, while actions keep working.
 Each module is resolved once when the SDK loads:
 
 - view-shot leaves a host `Modal` out (it is a separate window), so the response carries `partial: true` and
@@ -230,7 +231,7 @@ A run looks and behaves like the web widget's agent mode (`web-sdk/src/managers/
   installed (both optional peers); without one this is a no-op, reported once with `debug`.
 
 Known differences from the web: the pending dim covers the whole screen (the web dims only the chat window); the
-layer takes window focus, so an open keyboard closes when a run starts; `session_closed` ends the run (the web only
+keyboard stays closed during a run, unless the chat is open; `session_closed` ends the run (the web only
 tears it down). Visual effects (dot grid, glow, slime) come in a later milestone.
 
 ### Test nudges without a real delivery
@@ -333,7 +334,8 @@ Wire envelope (mirrors the backend): `agent_command` / `request_dom_state` / `re
 | `highlight` | `duration_ms` (default 3000) | any element |
 
 `click`, `type`, `check` and `highlight` scroll the target into view first. Elements that sit beyond their scroll
-viewport are listed with `offscreen=above|below|left|right` (at most 30, nearest first). A wheel picker is a snapping
+viewport are listed with `offscreen=above|below|left|right`, however many there are. The page text also includes what a
+list holds off screen in any direction; only blocks parked beyond the window with no list behind them are left out. A wheel picker is a snapping
 list (`snapToInterval` or `snapToOffsets`) of plain text rows: each row is a `btn-N`, and all of them stay listed. Lists
 carry `list=<name>` from their own or their wrapper's `accessibilityLabel` or `testID`, and so do those rows. `select`
 needs no snap props: it reaches any list, so a wheel that snaps in JS works through it.

package/dist/BlarProvider.d.ts

@@ -42,6 +42,7 @@ export declare class BlarProvider extends Component<BlarProviderProps, BlarProvi
     private chatControls;
     private shownNudge;
     private readonly releases;
+    private readonly keyboardGuard;
     private stackingCheckQueued;
     private loggedPhase;
     private readonly stacking;
@@ -62,6 +63,7 @@ export declare class BlarProvider extends Component<BlarProviderProps, BlarProvi
     private createTransport;
     private createChat;
     private attachBackend;
+    private syncKeyboardGuard;
     private queueStackingCheck;
     private keepLayerOnTop;
     private countHostModals;

package/dist/actions/select.d.ts

@@ -11,6 +11,6 @@ export declare function scrollListTo(target: ResolvedTarget, list: Fiber, offset
 export declare function selectWheelOption(target: ResolvedTarget): Promise<HandlerResult>;
 export declare function rowsOf(list: Fiber): ListRow[];
 export declare function matchesRow(text: string, value: string): boolean;
-export declare function selectValue(target: ResolvedTarget, value: string, services: ActionServices): Promise<HandlerResult>;
+export declare function selectValue(target: ResolvedTarget, value: string, services: ActionServices, isCancelled?: () => boolean): Promise<HandlerResult>;
 export declare function walk(from: number, to: number, step: number): number[];
 export {};

package/dist/actions/text-input.d.ts

@@ -4,6 +4,7 @@ import type { AgentAction, HandlerResult } from './types.ts';
 type TypeAction = Extract<AgentAction, {
     type: 'type';
 }>;
+export declare function restoreKeyboards(): void;
 export declare function typeText(target: ResolvedTarget, action: TypeAction, services: ActionServices): HandlerResult;
 export declare function submitInput(target: ResolvedTarget): HandlerResult;
 export {};

package/dist/agent/compose.d.ts

@@ -11,6 +11,7 @@ export interface AgentEnvironment {
     transport: AgentTransport;
     getAnchorFiber: () => Fiber | null;
     getViewport: () => Size;
+    getWindow: () => Size;
     getNavigationRef: () => NavigationRefLike | null;
     getCaptureTarget: () => unknown;
     reading: ReadingPort;

package/dist/agent-mode/keyboard-guard.d.ts

@@ -0,0 +1,13 @@
+export interface KeyboardPort {
+    addListener: (event: 'keyboardWillShow' | 'keyboardDidShow', listener: () => void) => {
+        remove: () => void;
+    };
+    dismiss: () => void;
+}
+export declare class KeyboardGuard {
+    private readonly keyboard;
+    private readonly onRelease;
+    private subscriptions;
+    constructor(keyboard: KeyboardPort, onRelease?: () => void);
+    setActive(active: boolean): void;
+}

package/dist/snapshot/capture.d.ts

@@ -13,6 +13,7 @@ export interface SnapshotDependencies {
     getAnchorFiber: () => Fiber | null;
     registry: ElementRegistry;
     getViewport: () => Size;
+    getWindow: () => Size;
     getExtraRoutes: () => string[];
 }
 export type CaptureMode = 'register' | 'peek';

package/dist/snapshot/visibility.d.ts

@@ -9,9 +9,9 @@ export type Visibility = {
 } | {
     kind: 'offscreen';
     direction: Offscreen;
-    distance: number;
 } | {
     kind: 'hidden';
 };
 export declare function classifyVisibility(rect: Rect, window: Size, containers: Fiber[], geometries: ScrollGeometries): Visibility;
+export declare function markOffscreenText(visibility: Visibility, text: string): string;
 export declare function keepInTextTree(visibility: Visibility, rect: Rect, window: Size, viewportOnly: boolean): boolean;

package/dist/snapshot/wrappers.d.ts

@@ -5,7 +5,5 @@ export interface MeasuredCandidate {
     candidate: Candidate;
     rect: Rect;
     offscreen: Offscreen | null;
-    distance: number;
 }
 export declare function dropWrapperDuplicates(measured: MeasuredCandidate[]): MeasuredCandidate[];
-export declare function limitOffscreen(measured: MeasuredCandidate[]): MeasuredCandidate[];

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.1.5";
+export declare const SDK_VERSION = "0.1.6";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blario/react-native",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Blar agent SDK for React Native",
   "license": "MIT",
   "repository": {

package/src/BlarProvider.tsx

@@ -13,6 +13,8 @@ import type { AgentModePhase } from './agent-mode/state.ts';
 import { KEEP_AWAKE_ADAPTER, KeepAwake } from './agent-mode/keep-awake.ts';
 import { LayerStacking } from './agent-mode/layer-stacking.ts';
 import { AgentLayer } from './agent-mode/ui/AgentLayer.tsx';
+import { restoreKeyboards } from './actions/text-input.ts';
+import { KeyboardGuard } from './agent-mode/keyboard-guard.ts';
 import { AgentLayerHost } from './agent-mode/ui/AgentLayerHost.tsx';
 import { BackendTransport, type WidgetProof } from './backend/backend-transport.ts';
 import type { BlarIdentity } from './backend/identity.ts';
@@ -104,6 +106,8 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
 
   private readonly releases: Array<() => void> = [];
 
+  private readonly keyboardGuard = new KeyboardGuard(Keyboard, restoreKeyboards);
+
   private stackingCheckQueued = false;
 
   private loggedPhase: AgentModePhase = 'idle';
@@ -163,6 +167,7 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
       transport,
       getAnchorFiber: () => (this as WithReactInternals)._reactInternals ?? null,
       getViewport: () => visibleViewport(Dimensions.get('window'), Keyboard.metrics()?.height ?? 0),
+      getWindow: () => Dimensions.get('window'),
       getNavigationRef: () => this.props.navigationRef ?? null,
       getCaptureTarget: () => this.contentRef.current,
       reading: this.spotlight,
@@ -316,8 +321,10 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
           this.debug(`agent mode ${snapshot.phase}`);
         }
         this.setState({ agentMode: snapshot });
+        this.syncKeyboardGuard();
       }),
     );
+    this.releases.push(() => this.keyboardGuard.setActive(false));
     return agentMode;
   }
 
@@ -373,6 +380,7 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
       coordinator.subscribe((chat) => {
         this.noteNudge(chat);
         this.setState({ chat });
+        this.syncKeyboardGuard();
       }),
     );
     this.releases.push(backend.onFrame((frame) => coordinator.handleFrame(frame)));
@@ -395,6 +403,11 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
     Blar.attach(backend, (options) => controller.readMessageMetadata({ ...options, tabId: backend.getTabId() }));
   }
 
+  private syncKeyboardGuard(): void {
+    const running = this.agentMode?.getSnapshot().phase === 'active';
+    this.keyboardGuard.setActive(running && this.chatControls?.isOpen() !== true);
+  }
+
   private queueStackingCheck(): void {
     if (this.stackingCheckQueued || (this.agentMode?.getSnapshot().phase ?? 'idle') === 'idle') {
       return;

package/src/actions/executor.ts

@@ -41,6 +41,9 @@ export class ActionExecutor {
     if (command.action.type === 'navigate') {
       return { ok: true, target: null };
     }
+    if (command.action.type === 'press_key' && command.action.key !== 'Enter') {
+      return { ok: false, outcome: outcomeOf(failed('unsupported_action', `key ${command.action.key} is not supported: only Enter is. To move a list use scroll or select on its scr-N`)) };
+    }
     const target = this.resolveTarget(command);
     if (target === null) {
       return { ok: false, outcome: outcomeOf(this.missingTarget(command)) };
@@ -79,7 +82,7 @@ export class ActionExecutor {
       if (options.isCancelled()) {
         return failed('user_cancelled', CANCELLED_MESSAGE);
       }
-      return await this.dispatch(command, target);
+      return await this.dispatch(command, target, options);
     } catch (error) {
       return failedFromException(error);
     }
@@ -124,7 +127,7 @@ export class ActionExecutor {
     return failed('element_not_found', reason);
   }
 
-  private dispatch(command: AgentCommandData, target: ResolvedTarget): Promise<HandlerResult> | HandlerResult {
+  private dispatch(command: AgentCommandData, target: ResolvedTarget, options: ExecutionOptions): Promise<HandlerResult> | HandlerResult {
     const { action } = command;
     switch (action.type) {
       case 'click':
@@ -134,7 +137,7 @@ export class ActionExecutor {
       case 'check':
         return toggleSwitch(target, action.checked);
       case 'select':
-        return selectValue(target, action.value, this.services);
+        return selectValue(target, action.value, this.services, options.isCancelled);
       case 'press_key':
         return action.key === 'Enter' ? submitInput(target) : failed('unsupported_action', `key ${action.key} is not supported`);
       case 'scroll':

package/src/actions/select.ts

@@ -5,6 +5,7 @@ import { childrenOf, isHostComponent, propsOf } from '../fiber/reader.ts';
 import { collectText, TEXT_HOST_TYPE } from '../fiber/text.ts';
 import type { Fiber } from '../fiber/types.ts';
 import { measureHost } from '../host/measure.ts';
+import { scrollInstanceOf } from '../snapshot/classify.ts';
 import { maxScrollOffsetOf, measureScrollGeometry, offsetCentering, type ScrollGeometry, scrollOffsetOf, viewportExtentOf } from '../snapshot/scroll.ts';
 import { runBatched } from './batched.ts';
 import { failed, succeeded } from './result.ts';
@@ -20,6 +21,7 @@ const WALK_STEP_FRACTION = 3;
 const WALK_SETTLE_MS = 120;
 const MOUNT_POLL_MS = 150;
 const LISTED_OPTIONS = 30;
+const CANCELLED_MESSAGE = 'Cancelled by the user before the action ran';
 const MOVEMENT_TOLERANCE = 1;
 const SCROLL_ANIMATION_MS = 400;
 
@@ -38,7 +40,9 @@ function commitScrollEnd(list: Fiber, geometry: ScrollGeometry, offset: number):
   const { viewport, content, horizontal } = geometry;
   runBatched(() =>
     onMomentumScrollEnd({
+      persist: () => undefined,
       nativeEvent: {
+        contentInset: { top: 0, left: 0, bottom: 0, right: 0 },
         contentOffset: horizontal ? { x: offset, y: 0 } : { x: 0, y: offset },
         contentSize: { width: content.width, height: content.height },
         layoutMeasurement: { width: viewport.width, height: viewport.height },
@@ -81,6 +85,9 @@ export async function selectWheelOption(target: ResolvedTarget): Promise<Handler
 export function rowsOf(list: Fiber): ListRow[] {
   const rows: ListRow[] = [];
   const visit = (fiber: Fiber): void => {
+    if (fiber !== list && scrollInstanceOf(fiber) !== null) {
+      return;
+    }
     if (isHostComponent(fiber) && fiber.type === TEXT_HOST_TYPE) {
       const text = collectText(fiber, ROW_TEXT_LIMIT);
       if (text.length > 0) {
@@ -109,7 +116,7 @@ function listOf(target: ResolvedTarget): Fiber | null {
 
 // A virtualized list mounts its rows shortly after it opens, and a distant row only once scrolling gets near it: wait
 // a moment, then walk the list. A value that isn't there leaves the list where it was.
-export async function selectValue(target: ResolvedTarget, value: string, services: ActionServices): Promise<HandlerResult> {
+export async function selectValue(target: ResolvedTarget, value: string, services: ActionServices, isCancelled: () => boolean = () => false): Promise<HandlerResult> {
   const first = listOf(target);
   if (first === null) {
     return failed('element_not_interactable', 'select works on one open list: click this field to open its picker, then select each value on its list (scr-N)');
@@ -125,10 +132,13 @@ export async function selectValue(target: ResolvedTarget, value: string, service
     return rows.find((row) => matchesRow(row.text, value));
   };
   let row = findRow();
-  for (let waited = 0; row === undefined && waited < MOUNT_WAIT_MS; waited += MOUNT_POLL_MS) {
+  for (let waited = 0; row === undefined && waited < MOUNT_WAIT_MS && !isCancelled(); waited += MOUNT_POLL_MS) {
     await SYSTEM_CLOCK.sleep(MOUNT_POLL_MS);
     row = findRow();
   }
+  if (isCancelled()) {
+    return failed('user_cancelled', CANCELLED_MESSAGE);
+  }
   if (row !== undefined) {
     return centerInList(current, list, row.host);
   }
@@ -139,6 +149,10 @@ export async function selectValue(target: ResolvedTarget, value: string, service
     const end = maxScrollOffsetOf(geometry);
     const stops = [...walk(start, end, step), ...walk(start, 0, step)];
     for (const stop of stops) {
+      if (isCancelled()) {
+        await scrollListTo(current, list, start);
+        return failed('user_cancelled', CANCELLED_MESSAGE);
+      }
       await scrollListTo(current, list, stop);
       await SYSTEM_CLOCK.sleep(WALK_SETTLE_MS);
       row = findRow();

package/src/actions/text-input.ts

@@ -25,6 +25,33 @@ function isControlled(target: ResolvedTarget): boolean {
   return typeof target.props.value === 'string';
 }
 
+const noKeyboard = new Map<NativeInput, boolean>();
+
+interface NativeInput {
+  setNativeProps?: (props: { showSoftInputOnFocus: boolean }) => void;
+}
+
+// Focus without a keyboard: blurring a field to close it would dismiss what depends on its focus, like the suggestions
+// of a search box. The field gets its keyboard back when the run ends.
+function focusWithoutKeyboard(instance: NativeInput & { focus?: () => void }, target: ResolvedTarget): void {
+  if (!noKeyboard.has(instance)) {
+    noKeyboard.set(instance, target.props.showSoftInputOnFocus !== false);
+    instance.setNativeProps?.({ showSoftInputOnFocus: false });
+  }
+  instance.focus?.();
+}
+
+export function restoreKeyboards(): void {
+  noKeyboard.forEach((enabled, instance) => {
+    try {
+      instance.setNativeProps?.({ showSoftInputOnFocus: enabled });
+    } catch {
+      // The field is gone: nothing left to restore.
+    }
+  });
+  noKeyboard.clear();
+}
+
 export function typeText(target: ResolvedTarget, action: TypeAction, services: ActionServices): HandlerResult {
   if (target.element.kind !== 'text_input') {
     return failed('element_not_interactable', 'type needs a text input');
@@ -36,7 +63,9 @@ export function typeText(target: ResolvedTarget, action: TypeAction, services: A
   const next = action.clear_first ? action.value : currentTextOf(target) + action.value;
   const instance = target.host === null ? null : hostInstanceOf(target.host);
   try {
-    instance?.focus?.();
+    if (instance !== null) {
+      focusWithoutKeyboard(instance as NativeInput & { focus?: () => void }, target);
+    }
     if (!isControlled(target)) {
       if (Platform.OS === 'android') {
         const tag = findNodeHandle(instance as Parameters<typeof findNodeHandle>[0]);

package/src/agent/compose.ts

@@ -20,6 +20,7 @@ export interface AgentEnvironment {
   transport: AgentTransport;
   getAnchorFiber: () => Fiber | null;
   getViewport: () => Size;
+  getWindow: () => Size;
   getNavigationRef: () => NavigationRefLike | null;
   getCaptureTarget: () => unknown;
   reading: ReadingPort;
@@ -40,6 +41,7 @@ export function createAgentController(environment: AgentEnvironment): AgentContr
     getAnchorFiber: environment.getAnchorFiber,
     registry,
     getViewport: environment.getViewport,
+    getWindow: environment.getWindow,
     getExtraRoutes: (): string[] => navigation.listRefRoutePaths(),
   });
   const commitWatch = new CommitWatch(environment.getAnchorFiber, environment.onCommit);

package/src/agent/controller.ts

@@ -14,6 +14,8 @@ import { handleElementContext } from './handlers/element-context.ts';
 import { handleScreenshot } from './handlers/screenshot.ts';
 import { handleTextDom, readTextDom } from './handlers/text-dom.ts';
 
+const MESSAGE_TEXT_DOM_MAX_CHARS = 100_000;
+
 export interface ControllerDependencies {
   transport: AgentTransport;
   commitWatch: CommitWatch;
@@ -44,7 +46,7 @@ export class AgentController {
 
   async readMessageMetadata(options: { includeTextDom: boolean; tabId: string }): Promise<MessageMetadata> {
     const snapshot = await this.context.capturer.capture('peek');
-    const textDom = options.includeTextDom ? await readTextDom(this.context, { viewportOnly: false, maxChars: 0 }) : null;
+    const textDom = options.includeTextDom ? await readTextDom(this.context, { viewportOnly: false, maxChars: MESSAGE_TEXT_DOM_MAX_CHARS }) : null;
     return buildMessageMetadata({
       screen: snapshot.screen,
       tabId: options.tabId,

package/src/agent-mode/keyboard-guard.ts

@@ -0,0 +1,33 @@
+export interface KeyboardPort {
+  addListener: (event: 'keyboardWillShow' | 'keyboardDidShow', listener: () => void) => { remove: () => void };
+  dismiss: () => void;
+}
+
+// Nobody types during a run, and an open keyboard only covers what the agent is doing: an input that focuses itself would
+// otherwise leave it up. Android has no keyboardWillShow, so it hides a beat later. The agent's own typing never opens it
+// (focusWithoutKeyboard); ending the run closes the field it left focused, so the next tap opens a normal keyboard.
+export class KeyboardGuard {
+  private subscriptions: Array<{ remove: () => void }> = [];
+
+  constructor(
+    private readonly keyboard: KeyboardPort,
+    private readonly onRelease: () => void = () => undefined,
+  ) {}
+
+  setActive(active: boolean): void {
+    if (!active) {
+      if (this.subscriptions.length > 0) {
+        this.subscriptions.splice(0).forEach((subscription) => subscription.remove());
+        this.keyboard.dismiss();
+      }
+      this.onRelease();
+      return;
+    }
+    if (this.subscriptions.length > 0) {
+      return;
+    }
+    const dismiss = (): void => this.keyboard.dismiss();
+    this.subscriptions = [this.keyboard.addListener('keyboardWillShow', dismiss), this.keyboard.addListener('keyboardDidShow', dismiss)];
+    dismiss();
+  }
+}

package/src/chat/ChatSheet.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useRef } from 'react';
-import { Animated, BackHandler, Dimensions, Easing, KeyboardAvoidingView, Platform, Pressable, StyleSheet, View } from 'react-native';
+import { Animated, BackHandler, Dimensions, Easing, Keyboard, Platform, Pressable, StyleSheet, View } from 'react-native';
 
 import { useInsets } from '../ui/useInsets.ts';
 import type { UiStrings } from '../ui/strings.ts';
@@ -16,12 +16,38 @@ export interface ChatSheetProps {
 const TOP_GAP = 12;
 const ANIMATION_MS = 240;
 
+// iOS lifts the sheet over the keyboard while the chat is open. Not KeyboardAvoidingView: it reacts to every keyboard in
+// the app even with the chat closed, and its LayoutAnimation applies to the host's whole next commit, which aborted a
+// debug build as soon as a keyboard opened while the host mounted views. On Android the window resizes by itself.
+function useKeyboardInset(active: boolean, homeIndicator: number): Animated.Value {
+  const inset = useRef(new Animated.Value(0)).current;
+  useEffect(() => {
+    if (!active || Platform.OS !== 'ios') {
+      inset.setValue(0);
+      return undefined;
+    }
+    const subscription = Keyboard.addListener('keyboardWillChangeFrame', (event) => {
+      const covered = Dimensions.get('window').height - event.endCoordinates.screenY;
+      Animated.timing(inset, {
+        // The keyboard covers the home-indicator inset, so the sheet's bottom padding sits under it, not above it.
+        toValue: Math.max(0, covered - homeIndicator),
+        duration: event.duration,
+        easing: Easing.out(Easing.cubic),
+        useNativeDriver: false,
+      }).start();
+    });
+    return () => subscription.remove();
+  }, [active, homeIndicator, inset]);
+  return inset;
+}
+
 export function ChatSheet({ mode, mounted, strings, onClose, children }: ChatSheetProps): React.JSX.Element | null {
   const insets = useInsets();
   const windowHeight = Dimensions.get('window').height;
   const sheetHeight = windowHeight - insets.top - TOP_GAP;
   const progress = useRef(new Animated.Value(mode === 'open' ? 1 : 0)).current;
   const isOpen = mode === 'open';
+  const keyboardInset = useKeyboardInset(isOpen, insets.bottom);
 
   useEffect(() => {
     Animated.timing(progress, { toValue: isOpen ? 1 : 0, duration: ANIMATION_MS, easing: Easing.out(Easing.cubic), useNativeDriver: true }).start();
@@ -48,13 +74,7 @@ export function ChatSheet({ mode, mounted, strings, onClose, children }: ChatShe
       <Animated.View style={[styles.backdrop, { opacity: backdropOpacity }]}>
         <Pressable accessibilityLabel={strings.chatClose} style={StyleSheet.absoluteFill} onPress={onClose} />
       </Animated.View>
-      <KeyboardAvoidingView
-        style={[styles.container, { paddingTop: insets.top + TOP_GAP }]}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        // The keyboard covers the home-indicator inset, so the sheet's bottom padding sits under it, not above it.
-        keyboardVerticalOffset={-insets.bottom}
-        pointerEvents="box-none"
-      >
+      <Animated.View style={[styles.container, { paddingTop: insets.top + TOP_GAP, paddingBottom: keyboardInset }]} pointerEvents="box-none">
         <Animated.View
           accessibilityElementsHidden={!isOpen}
           importantForAccessibility={isOpen ? 'yes' : 'no-hide-descendants'}
@@ -62,7 +82,7 @@ export function ChatSheet({ mode, mounted, strings, onClose, children }: ChatShe
         >
           {children}
         </Animated.View>
-      </KeyboardAvoidingView>
+      </Animated.View>
     </View>
   );
 }

package/src/chat/ChatView.tsx

@@ -107,7 +107,7 @@ export function ChatView({ shell, unavailableText, getMetadata, getProof, onClos
       mixedContentMode="always"
       setSupportMultipleWindows={false}
       keyboardDisplayRequiresUserAction={false}
-      // The sheet's KeyboardAvoidingView already lifts the chat above the keyboard. WKWebView would also scroll its
+      // The sheet already lifts the chat above the keyboard. WKWebView would also scroll its
       // own page up to reveal the composer, pushing the widget out of the sheet; with scrolling off it resets that
       // offset (the message list is an overflow container and keeps scrolling). The form bar (^ v Done) is for
       // multi-field forms, not a one-field composer.