@blario/react-native 0.1.5 → 0.1.7

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.
@@ -405,7 +407,10 @@ If trusted publishing is not wanted, a granular npm token (Read and write, scope
 Like the web widget, the SDK reports its own contained failures to Blar's Sentry, through a client that is isolated from
 the host app: it installs no global error handler and no native crash hook, never touches the app's own Sentry, and
 only sees errors the SDK catches itself (the agent runtime, the backend transport and a boundary around the SDK's own
-UI, never the app's components). Events carry the SDK version, platform, publishable key, `source_id`, session id and
+UI, never the app's components). An error in a socket callback, timer, native listener, animation callback or press
+handler would otherwise end the app in a release build, or on Android's bridgeless runtime leave it on a white screen
+with the process alive, so each goes through `contain()` (`src/telemetry/contain.ts`) and a test fails on one that
+doesn't. A native crash can't be contained from JS and isn't reported here: it shows up in the app's own crash reporting. Events carry the SDK version, platform, publishable key, `source_id`, session id and
 the user's external id; emails, bearer tokens and identity tokens are scrubbed from messages. Network failures and
 refused credentials only become breadcrumbs, and at most 50 events are sent per launch. Without a DSN (the repo
 default, set only by the release job) nothing is sent. `enabled={false}` stops the SDK, and its reporting with it.

package/dist/BlarProvider.d.ts

@@ -42,17 +42,22 @@ 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;
     private readonly attachCursor;
     private readonly detachCursor;
+    private readonly noteInteraction;
     componentDidMount(): void;
     componentDidUpdate(previous: BlarProviderProps): void;
     componentWillUnmount(): void;
+    private startContained;
+    private syncProps;
     private startSdk;
     private stopSdk;
     render(): React.JSX.Element;
+    private renderOverlay;
     private renderAgentLayer;
     private renderChat;
     private chatOptions;
@@ -62,6 +67,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/telemetry/contain.d.ts

@@ -0,0 +1,5 @@
+type Report = (context: string, error: unknown) => void;
+export declare function setContainmentReporter(reporter: Report): void;
+export declare function attempt<T>(context: string, run: () => T): T | undefined;
+export declare function contain<Args extends unknown[]>(context: string, callback: (...args: Args) => unknown): (...args: Args) => void;
+export {};

package/dist/version.d.ts

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

package/package.json

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

package/src/BlarProvider.tsx

@@ -1,5 +1,5 @@
 import React, { Component, createRef, type ReactNode } from 'react';
-import { AccessibilityInfo, AppState, Dimensions, Keyboard, StyleSheet, View } from 'react-native';
+import { AccessibilityInfo, AppState, type AppStateStatus, Dimensions, Keyboard, StyleSheet, View } from 'react-native';
 
 import { createAgentController } from './agent/compose.ts';
 import { SYSTEM_CLOCK } from './actions/settle.ts';
@@ -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';
@@ -29,7 +31,9 @@ import { visibleViewport } from './host/visible-area.ts';
 import { AgentOverlay } from './overlay/AgentOverlay.tsx';
 import { CAPTURE_BACKEND } from './screenshot/screenshotter.ts';
 import { countOpenModals } from './snapshot/modals.ts';
+import { attempt, contain } from './telemetry/contain.ts';
 import { SdkErrorBoundary } from './telemetry/SdkErrorBoundary.tsx';
+import { reportSdkError } from './telemetry/sdk-reporter.ts';
 import { resolveConnectionOptions, type ConnectionConfig } from './transport/connection-options.ts';
 import { RelayTransport } from './transport/relay-transport.ts';
 import type { AgentTransport } from './transport/transport.ts';
@@ -104,6 +108,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';
@@ -114,17 +120,37 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
 
   private readonly detachCursor = (): void => this.cursor.detach();
 
+  private readonly noteInteraction = contain('BlarProvider.touch', () => this.backend?.noteInteraction());
+
   override componentDidMount(): void {
     if (this.props.enabled !== false) {
-      this.startSdk();
+      this.startContained();
     }
   }
 
   override componentDidUpdate(previous: BlarProviderProps): void {
+    attempt('BlarProvider.update', () => this.syncProps(previous));
+  }
+
+  override componentWillUnmount(): void {
+    attempt('BlarProvider.unmount', () => this.stopSdk());
+  }
+
+  // A failed start leaves the host app running, without the SDK.
+  private startContained(): void {
+    try {
+      this.startSdk();
+    } catch (error) {
+      reportSdkError('BlarProvider.start', error);
+      attempt('BlarProvider.stop', () => this.stopSdk());
+    }
+  }
+
+  private syncProps(previous: BlarProviderProps): void {
     const enabled = this.props.enabled !== false;
     if (enabled !== (previous.enabled !== false)) {
       if (enabled) {
-        this.startSdk();
+        this.startContained();
       } else {
         this.stopSdk();
         this.setState({ chat: null, agentMode: null, spotlight: this.spotlight.getSnapshot(), cursor: this.cursor.getSnapshot() });
@@ -141,10 +167,6 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
     void Blar.setUser(this.props.user);
   }
 
-  override componentWillUnmount(): void {
-    this.stopSdk();
-  }
-
   private startSdk(): void {
     this.connection = resolveConnectionOptions(this.props, typeof __DEV__ !== 'undefined' && __DEV__);
     const transport = this.createTransport();
@@ -163,6 +185,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,
@@ -199,25 +222,29 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
   }
 
   override render(): React.JSX.Element {
-    const strings = resolveStrings(this.props.language ?? 'es', this.props.strings);
-    const phase = this.state.agentMode?.phase ?? 'idle';
     return (
-      <View style={styles.root} collapsable={false} onTouchStart={() => this.backend?.noteInteraction()}>
+      <View style={styles.root} collapsable={false} onTouchStart={this.noteInteraction}>
         <View ref={this.contentRef} style={styles.root} collapsable={false}>
           {this.props.children}
         </View>
-        <SdkErrorBoundary context="BlarProvider.overlay">
-          <AgentOverlay>
-            {this.renderChat(strings)}
-            <AgentLayerHost visible={phase !== 'idle'} generation={this.state.layerGeneration} onRequestClose={() => this.agentMode?.stop()}>
-              {this.renderAgentLayer(strings)}
-            </AgentLayerHost>
-          </AgentOverlay>
-        </SdkErrorBoundary>
+        <SdkErrorBoundary context="BlarProvider.overlay">{attempt('BlarProvider.render', () => this.renderOverlay())}</SdkErrorBoundary>
       </View>
     );
   }
 
+  private renderOverlay(): React.JSX.Element {
+    const strings = resolveStrings(this.props.language ?? 'es', this.props.strings);
+    const phase = this.state.agentMode?.phase ?? 'idle';
+    return (
+      <AgentOverlay>
+        {this.renderChat(strings)}
+        <AgentLayerHost visible={phase !== 'idle'} generation={this.state.layerGeneration} onRequestClose={() => this.agentMode?.stop()}>
+          {this.renderAgentLayer(strings)}
+        </AgentLayerHost>
+      </AgentOverlay>
+    );
+  }
+
   private renderAgentLayer(strings: UiStrings): React.JSX.Element | null {
     const { agentMode } = this.state;
     if (agentMode === null || agentMode.phase === 'idle') {
@@ -275,17 +302,20 @@ export class BlarProvider extends Component<BlarProviderProps, BlarProviderState
   }
 
   private watchForeground(): void {
-    const subscription = AppState.addEventListener('change', (state) => {
-      if (state !== 'active') {
-        this.spotlight.backgrounded();
-      }
-    });
+    const subscription = AppState.addEventListener(
+      'change',
+      contain('BlarProvider.foreground', (state: AppStateStatus) => {
+        if (state !== 'active') {
+          this.spotlight.backgrounded();
+        }
+      }),
+    );
     this.releases.push(() => subscription.remove());
   }
 
   private watchMotionPreference(): void {
     void AccessibilityInfo.isReduceMotionEnabled().then((reduceMotion) => this.setState({ reduceMotion }));
-    const subscription = AccessibilityInfo.addEventListener('reduceMotionChanged', (reduceMotion) => this.setState({ reduceMotion }));
+    const subscription = AccessibilityInfo.addEventListener('reduceMotionChanged', contain('BlarProvider.motion', (reduceMotion: boolean) => this.setState({ reduceMotion })));
     this.releases.push(() => subscription.remove());
   }
 
@@ -316,8 +346,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 +405,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,15 +428,22 @@ 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;
     }
     this.stackingCheckQueued = true;
-    requestAnimationFrame(() => {
-      this.stackingCheckQueued = false;
-      this.keepLayerOnTop();
-    });
+    requestAnimationFrame(
+      contain('BlarProvider.stacking', () => {
+        this.stackingCheckQueued = false;
+        this.keepLayerOnTop();
+      }),
+    );
   }
 
   private keepLayerOnTop(): void {

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,35 @@
+import { contain } from '../telemetry/contain.ts';
+
+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 = contain('KeyboardGuard.dismiss', () => this.keyboard.dismiss());
+    this.subscriptions = [this.keyboard.addListener('keyboardWillShow', dismiss), this.keyboard.addListener('keyboardDidShow', dismiss)];
+    dismiss();
+  }
+}

package/src/agent-mode/timers.ts

@@ -1,3 +1,5 @@
+import { contain } from '../telemetry/contain.ts';
+
 export interface Timers {
   set: (callback: () => void, milliseconds: number) => unknown;
   clear: (handle: unknown) => void;
@@ -5,7 +7,7 @@ export interface Timers {
 }
 
 export const SYSTEM_TIMERS: Timers = {
-  set: (callback, milliseconds) => setTimeout(callback, milliseconds),
+  set: (callback, milliseconds) => setTimeout(contain('Timers', callback), milliseconds),
   clear: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
   now: () => Date.now(),
 };