Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(mobile): preserve keyboard suggestions while typing (#6323)
Julius Marmingeb3b4b5779447
diff --git a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.ktindex e13c0a521..3010b5240 100644--- a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt+++ b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt@@ -252,6 +252,9 @@ class T3ComposerEditorView(context: Context, appContext: AppContext) : ExpoView(val textLength = editor.text?.length ?: 0val safeStart = start.coerceIn(0, textLength)val safeEnd = end.coerceIn(0, textLength)+ // Re-applying an unchanged selection resets the keyboard's suggestion+ // state, so a no-op assignment must be skipped.+ if (editor.selectionStart == safeStart && editor.selectionEnd == safeEnd) returneditor.setSelection(safeStart, safeEnd)}@@ -281,6 +284,10 @@ class T3ComposerEditorView(context: Context, appContext: AppContext) : ExpoView()private fun emitSelectionChange(start: Int, end: Int) {+ // Caret moves advance the revision counter like text edits do: a+ // controlled payload computed before this move is stale and must fail the+ // revision guard instead of yanking the caret back mid-typing.+ nativeEventCount += 1onComposerSelectionChange(mapOf("value" to editor.text.toString(),diff --git a/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift b/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swiftindex ec5b54aa8..2a8fb8c4e 100644--- a/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift+++ b/apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift@@ -489,6 +489,12 @@ public final class T3ComposerEditorView: ExpoView, UITextViewDelegate, UITextDroreturn}restoreBaseTypingAttributes()+ // UIKit moves the selection before textViewDidChange runs. Emitting here+ // would pair the post-edit text with a pre-edit revision counter, so let+ // the change event that follows carry both; only pure caret moves emit.+ guard self.textView.serializedText() == value else {+ return+ }emitSelection()}@@ -774,8 +780,12 @@ public final class T3ComposerEditorView: ExpoView, UITextViewDelegate, UITextDro}private func emitSelection() {+ // Caret moves advance the revision counter like text edits do: a+ // controlled payload computed before this move is stale and must fail the+ // revision guard instead of yanking the caret back mid-typing.let currentValue = textView.serializedText()let selection = sourceSelection()+ nativeEventCount += 1onComposerSelectionChange(["value": currentValue,"selection": ["start": selection.start, "end": selection.end],@@ -817,10 +827,16 @@ public final class T3ComposerEditorView: ExpoView, UITextViewDelegate, UITextDroNSMaxRange(nextRange) <= textView.attributedText.length else {return}+ self.requestedSelection = nil+ // Programmatically assigning selectedRange resets the keyboard's+ // autocorrect and predictive-text context even when the range is+ // unchanged, so a no-op assignment must be skipped.+ guard !NSEqualRanges(nextRange, textView.selectedRange) else {+ return+ }isApplyingControlledValue = truetextView.selectedRange = nextRangeisApplyingControlledValue = false- self.requestedSelection = nil}private func updatePlaceholderVisibility() {diff --git a/apps/mobile/src/native/T3ComposerEditor.ios.tsx b/apps/mobile/src/native/T3ComposerEditor.ios.tsxindex 4e9d62ad2..32094109b 100644--- a/apps/mobile/src/native/T3ComposerEditor.ios.tsx+++ b/apps/mobile/src/native/T3ComposerEditor.ios.tsx@@ -19,6 +19,7 @@ import { useFontFamily } from "../lib/useFontFamily";import { useScaledTextRole } from "../features/settings/appearance/useScaledTextRole";import {acknowledgeComposerNativeEvent,+ assumeComposerControlledState,isComposerNativeEcho,pruneAcknowledgedComposerNativeEvents,resolveComposerControlledEventCount,@@ -102,11 +103,11 @@ export function ComposerEditor({const nativeRef = useRef<NativeComposerEditorRef>(null);const mostRecentEventCountRef = useRef(0);const [mostRecentEventCount, setMostRecentEventCount] = useState(0);- const [nativeEventSequence, setNativeEventSequence] = useState(0);- const previousRenderedEventSequenceRef = useRef(0);- const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([- { eventCount: 0, value: props.value, selection: selection ?? null },- ]);+ const [, forceNativeEventRender] = useState(0);+ // The native editor mounts empty, so the snapshot history starts empty: the+ // first controlled payload must be a non-echo so a restored draft (or a+ // recycled native view) is applied rather than skipped.+ const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([]);const confirmedTokensRef = useRef(collectComposerInlineTokens(props.value));const bodyText = useScaledTextRole("body");const textColor = useThemeColor("--color-foreground");@@ -154,15 +155,16 @@ export function ComposerEditor({})),);}, [props.value, skillLabels]);- const includesNativeEvent = nativeEventSequence !== previousRenderedEventSequenceRef.current;- const controlledEventCount = includesNativeEvent- ? resolveComposerControlledEventCount(- props.value,- selection ?? null,- mostRecentEventCount,- nativeEventSnapshotsRef.current,- )- : mostRecentEventCount;+ // Every render resolves against the snapshot history, so a render whose+ // (value, selection) lags the acknowledged native state is stamped behind+ // the native revision and rejected by the editor instead of re-applying a+ // stale caret or stale text mid-typing.+ const controlledEventCount = resolveComposerControlledEventCount(+ props.value,+ selection ?? null,+ mostRecentEventCount,+ nativeEventSnapshotsRef.current,+ );const acknowledgesLatestNativeEvent = isComposerNativeEcho(props.value,selection ?? null,@@ -170,9 +172,7 @@ export function ComposerEditor({nativeEventSnapshotsRef.current,);const isNativeEcho =- includesNativeEvent &&- controlledEventCount === mostRecentEventCount &&- acknowledgesLatestNativeEvent;+ controlledEventCount === mostRecentEventCount && acknowledgesLatestNativeEvent;const controlledDocumentJson = JSON.stringify({value: props.value,selection: isNativeEcho ? null : (selection ?? null),@@ -180,9 +180,6 @@ export function ComposerEditor({mostRecentEventCount: controlledEventCount,isNativeEcho,});- useEffect(() => {- previousRenderedEventSequenceRef.current = nativeEventSequence;- }, [nativeEventSequence]);useEffect(() => {if (!acknowledgesLatestNativeEvent) return;nativeEventSnapshotsRef.current = pruneAcknowledgedComposerNativeEvents(@@ -190,6 +187,18 @@ export function ComposerEditor({mostRecentEventCount,);}, [acknowledgesLatestNativeEvent, mostRecentEventCount]);+ const assumedValue = props.value;+ useEffect(() => {+ // A native event that arrived after this render was committed moves the+ // acknowledged revision forward; the editor rejects this payload, so the+ // snapshot history must not assume it applied.+ if (isNativeEcho || controlledEventCount !== mostRecentEventCountRef.current) return;+ nativeEventSnapshotsRef.current = assumeComposerControlledState(+ nativeEventSnapshotsRef.current,+ controlledEventCount,+ assumedValue,+ );+ }, [assumedValue, controlledEventCount, isNativeEcho, controlledDocumentJson]);const acceptNativeEvent = useCallback((eventCount: number, value: string, nextSelection: ComposerEditorSelection) => {const acknowledgedEventCount = acknowledgeComposerNativeEvent(@@ -257,7 +266,7 @@ export function ComposerEditor({onChangeText(event.nativeEvent.value);onSelectionChange?.(event.nativeEvent.selection);setMostRecentEventCount(acknowledgedEventCount);- setNativeEventSequence((sequence) => sequence + 1);+ forceNativeEventRender((sequence) => sequence + 1);}}onComposerSelectionChange={(event) => {const acknowledgedEventCount = acceptNativeEvent(@@ -266,9 +275,16 @@ export function ComposerEditor({event.nativeEvent.selection,);if (acknowledgedEventCount === false) return;+ // A selection change that raced a text mutation can carry post-edit+ // text. It must reach the parent alongside the acknowledged revision,+ // or the next render stamps the stale draft at that revision and can+ // re-apply it over the newer native text.+ if (event.nativeEvent.value !== props.value) {+ onChangeText(event.nativeEvent.value);+ }onSelectionChange?.(event.nativeEvent.selection);setMostRecentEventCount(acknowledgedEventCount);- setNativeEventSequence((sequence) => sequence + 1);+ forceNativeEventRender((sequence) => sequence + 1);}}onComposerPasteImages={(event) => onPasteImages?.(event.nativeEvent.uris)}onComposerFocus={onFocus}diff --git a/apps/mobile/src/native/T3ComposerEditor.native.tsx b/apps/mobile/src/native/T3ComposerEditor.native.tsxindex e78f90a7d..ff177abf1 100644--- a/apps/mobile/src/native/T3ComposerEditor.native.tsx+++ b/apps/mobile/src/native/T3ComposerEditor.native.tsx@@ -21,6 +21,7 @@ import { useFontFamily } from "../lib/useFontFamily";import { useThemeColor } from "../lib/useThemeColor";import {acknowledgeComposerNativeEvent,+ assumeComposerControlledState,isComposerNativeEcho,pruneAcknowledgedComposerNativeEvents,resolveComposerControlledEventCount,@@ -103,11 +104,11 @@ export function ComposerEditor({const nativeRef = useRef<NativeComposerEditorRef>(null);const mostRecentEventCountRef = useRef(0);const [mostRecentEventCount, setMostRecentEventCount] = useState(0);- const [nativeEventSequence, setNativeEventSequence] = useState(0);- const previousRenderedEventSequenceRef = useRef(0);- const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([- { eventCount: 0, value: props.value, selection: selection ?? null },- ]);+ const [, forceNativeEventRender] = useState(0);+ // The native editor mounts empty, so the snapshot history starts empty: the+ // first controlled payload must be a non-echo so a restored draft (or a+ // recycled native view) is applied rather than skipped.+ const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([]);const [initialConfirmedTokens] = useState(() => collectComposerInlineTokens(props.value));const confirmedTokensRef = useRef(initialConfirmedTokens);const textColor = useThemeColor("--color-foreground");@@ -155,15 +156,16 @@ export function ComposerEditor({})),);}, [props.value, skillLabels]);- const includesNativeEvent = nativeEventSequence !== previousRenderedEventSequenceRef.current;- const controlledEventCount = includesNativeEvent- ? resolveComposerControlledEventCount(- props.value,- selection ?? null,- mostRecentEventCount,- nativeEventSnapshotsRef.current,- )- : mostRecentEventCount;+ // Every render resolves against the snapshot history, so a render whose+ // (value, selection) lags the acknowledged native state is stamped behind+ // the native revision and rejected by the editor instead of re-applying a+ // stale caret or stale text mid-typing.+ const controlledEventCount = resolveComposerControlledEventCount(+ props.value,+ selection ?? null,+ mostRecentEventCount,+ nativeEventSnapshotsRef.current,+ );const acknowledgesLatestNativeEvent = isComposerNativeEcho(props.value,selection ?? null,@@ -171,9 +173,7 @@ export function ComposerEditor({nativeEventSnapshotsRef.current,);const isNativeEcho =- includesNativeEvent &&- controlledEventCount === mostRecentEventCount &&- acknowledgesLatestNativeEvent;+ controlledEventCount === mostRecentEventCount && acknowledgesLatestNativeEvent;const controlledDocumentJson = JSON.stringify({value: props.value,selection: isNativeEcho ? null : (selection ?? null),@@ -181,9 +181,6 @@ export function ComposerEditor({mostRecentEventCount: controlledEventCount,isNativeEcho,});- useEffect(() => {- previousRenderedEventSequenceRef.current = nativeEventSequence;- }, [nativeEventSequence]);useEffect(() => {if (!acknowledgesLatestNativeEvent) return;nativeEventSnapshotsRef.current = pruneAcknowledgedComposerNativeEvents(@@ -191,6 +188,18 @@ export function ComposerEditor({mostRecentEventCount,);}, [acknowledgesLatestNativeEvent, mostRecentEventCount]);+ const assumedValue = props.value;+ useEffect(() => {+ // A native event that arrived after this render was committed moves the+ // acknowledged revision forward; the editor rejects this payload, so the+ // snapshot history must not assume it applied.+ if (isNativeEcho || controlledEventCount !== mostRecentEventCountRef.current) return;+ nativeEventSnapshotsRef.current = assumeComposerControlledState(+ nativeEventSnapshotsRef.current,+ controlledEventCount,+ assumedValue,+ );+ }, [assumedValue, controlledEventCount, isNativeEcho, controlledDocumentJson]);const acceptNativeEvent = useCallback((eventCount: number, value: string, nextSelection: ComposerEditorSelection) => {const acknowledgedEventCount = acknowledgeComposerNativeEvent(@@ -263,7 +272,7 @@ export function ComposerEditor({onChangeText(event.nativeEvent.value);onSelectionChange?.(event.nativeEvent.selection);setMostRecentEventCount(acknowledgedEventCount);- setNativeEventSequence((sequence) => sequence + 1);+ forceNativeEventRender((sequence) => sequence + 1);}}onComposerSelectionChange={(event) => {const acknowledgedEventCount = acceptNativeEvent(@@ -272,9 +281,17 @@ export function ComposerEditor({event.nativeEvent.selection,);if (acknowledgedEventCount === false) return;+ // Android emits the selection change mid-mutation, before the change+ // event, so the payload can carry post-edit text. It must reach the+ // parent alongside the acknowledged revision, or the next render+ // stamps the stale draft at that revision and can re-apply it over+ // the newer native text.+ if (event.nativeEvent.value !== props.value) {+ onChangeText(event.nativeEvent.value);+ }onSelectionChange?.(event.nativeEvent.selection);setMostRecentEventCount(acknowledgedEventCount);- setNativeEventSequence((sequence) => sequence + 1);+ forceNativeEventRender((sequence) => sequence + 1);}}onComposerPasteImages={(event) => onPasteImages?.(event.nativeEvent.uris)}onComposerFocus={onFocus}diff --git a/apps/mobile/src/native/composerEditorRevision.test.ts b/apps/mobile/src/native/composerEditorRevision.test.tsindex 9b255a547..ccc2214e2 100644--- a/apps/mobile/src/native/composerEditorRevision.test.ts+++ b/apps/mobile/src/native/composerEditorRevision.test.ts@@ -2,6 +2,7 @@ import { describe, expect, it } from "@effect/vitest";import {acknowledgeComposerNativeEvent,+ assumeComposerControlledState,isComposerNativeEcho,pruneAcknowledgedComposerNativeEvents,resolveComposerControlledEventCount,@@ -42,6 +43,19 @@ describe("isComposerNativeEcho", () => {it("matches value and revision when selection is uncontrolled", () => {expect(isComposerNativeEcho("native", null, 3, snapshots)).toBe(true);});++ it("does not claim a controlled selection against an assumed state without one", () => {+ // An echo payload serializes `selection: null`; classifying a controlled+ // selection as an echo of an assumed state would drop a parent caret move.+ const assumed = [{ eventCount: 3, value: "native", selection: null }];+ expect(isComposerNativeEcho("native", { start: 0, end: 0 }, 3, assumed)).toBe(false);+ expect(isComposerNativeEcho("other", { start: 0, end: 0 }, 3, assumed)).toBe(false);+ });++ it("matches an assumed state when selection is uncontrolled", () => {+ const assumed = [{ eventCount: 3, value: "native", selection: null }];+ expect(isComposerNativeEcho("native", null, 3, assumed)).toBe(true);+ });});describe("resolveComposerControlledEventCount", () => {@@ -95,7 +109,7 @@ describe("pruneAcknowledgedComposerNativeEvents", () => {selection: { start: eventCount, end: eventCount },}));- expect(pruneAcknowledgedComposerNativeEvents(snapshots, 999)).toEqual([]);+ expect(pruneAcknowledgedComposerNativeEvents(snapshots, 999)).toEqual([snapshots[999]]);});it("retains native events that arrive after the acknowledged render", () => {@@ -104,6 +118,77 @@ describe("pruneAcknowledgedComposerNativeEvents", () => {{ eventCount: 41, value: "ab", selection: { start: 2, end: 2 } },];- expect(pruneAcknowledgedComposerNativeEvents(snapshots, 40)).toEqual([snapshots[1]]);+ expect(pruneAcknowledgedComposerNativeEvents(snapshots, 40)).toEqual(snapshots);+ });++ it("retains the newest acknowledged snapshot so settled re-renders stay echoes", () => {+ const snapshots = [+ { eventCount: 40, value: "a", selection: { start: 1, end: 1 } },+ { eventCount: 41, value: "ab", selection: { start: 2, end: 2 } },+ { eventCount: 42, value: "abc", selection: { start: 3, end: 3 } },+ ];++ const pruned = pruneAcknowledgedComposerNativeEvents(snapshots, 42);+ expect(pruned).toEqual([snapshots[2]]);+ expect(isComposerNativeEcho("abc", { start: 3, end: 3 }, 42, pruned)).toBe(true);+ });++ it("keeps the newest of several snapshots sharing the acknowledged revision", () => {+ const snapshots = [+ { eventCount: 41, value: "ab", selection: { start: 2, end: 2 } },+ { eventCount: 41, value: "ab", selection: { start: 1, end: 1 } },+ ];++ expect(pruneAcknowledgedComposerNativeEvents(snapshots, 41)).toEqual([snapshots[1]]);+ });+});++describe("assumeComposerControlledState", () => {+ it("replaces the acknowledged history with the applied controlled state", () => {+ const snapshots = [{ eventCount: 3, value: "typed", selection: { start: 5, end: 5 } }];++ expect(assumeComposerControlledState(snapshots, 3, "")).toEqual([+ { eventCount: 3, value: "", selection: null },+ ]);+ });++ it("keeps native events that raced past the controlled revision", () => {+ const snapshots = [+ { eventCount: 3, value: "typed", selection: { start: 5, end: 5 } },+ { eventCount: 4, value: "typed!", selection: { start: 6, end: 6 } },+ ];++ expect(assumeComposerControlledState(snapshots, 3, "")).toEqual([+ { eventCount: 3, value: "", selection: null },+ snapshots[1],+ ]);+ });++ it("applies a parent caret move on the assumed value at the assumed revision", () => {+ // Same value, new caret: not an echo (so the selection is serialized) but+ // still stamped at the assumed revision so the editor accepts it.+ const snapshots = assumeComposerControlledState([], 3, "typed");++ expect(isComposerNativeEcho("typed", { start: 2, end: 2 }, 3, snapshots)).toBe(false);+ expect(resolveComposerControlledEventCount("typed", { start: 2, end: 2 }, 3, snapshots)).toBe(+ 3,+ );+ });++ it("re-applies a parent value that round-trips back to an acknowledged state", () => {+ // Native acknowledged "typed", the parent then controlled the editor to ""+ // (a send clearing the draft) and back to "typed" (the send failed and the+ // draft was restored). The restore must be a fresh non-echo edit stamped at+ // the current revision, not an echo the editor would drop.+ const snapshots = assumeComposerControlledState(+ [{ eventCount: 3, value: "typed", selection: { start: 5, end: 5 } }],+ 3,+ "",+ );++ expect(isComposerNativeEcho("typed", { start: 5, end: 5 }, 3, snapshots)).toBe(false);+ expect(resolveComposerControlledEventCount("typed", { start: 5, end: 5 }, 3, snapshots)).toBe(+ 3,+ );});});diff --git a/apps/mobile/src/native/composerEditorRevision.ts b/apps/mobile/src/native/composerEditorRevision.tsindex ea18d153d..45d68ac1b 100644--- a/apps/mobile/src/native/composerEditorRevision.ts+++ b/apps/mobile/src/native/composerEditorRevision.ts@@ -31,10 +31,7 @@ export function resolveComposerControlledEventCount(if (snapshot?.value !== value) continue;newestValueEventCount ??= snapshot.eventCount;- if (- selection === null ||- (snapshot.selection?.start === selection.start && snapshot.selection.end === selection.end)- ) {+ if (selection === null || snapshotSelectionMatches(snapshot, selection)) {return snapshot.eventCount;}}@@ -49,6 +46,21 @@ export function resolveComposerControlledEventCount(return mostRecentEventCount;}+// A snapshot without a selection describes a state the editor applied itself+// (an assumed controlled document, where the native side may have bounded the+// caret). Revision stamping treats it as matching any controlled selection so+// a parent caret move on the assumed value stays at the assumed revision and+// passes the editor's staleness guard. Echo detection must not reuse this+// wildcard: an echo payload serializes `selection: null`, which would drop+// that caret move instead of applying it.+function snapshotSelectionMatches(+ snapshot: ComposerNativeEventSnapshot,+ selection: ComposerEditorSelection,+): boolean {+ if (snapshot.selection === null) return true;+ return snapshot.selection.start === selection.start && snapshot.selection.end === selection.end;+}+export function isComposerNativeEcho(value: string,selection: ComposerEditorSelection | null,@@ -62,7 +74,9 @@ export function isComposerNativeEcho(snapshot.eventCount === eventCount &&snapshot.value === value &&(selection === null ||- (snapshot.selection?.start === selection.start && snapshot.selection.end === selection.end))+ (snapshot.selection !== null &&+ snapshot.selection.start === selection.start &&+ snapshot.selection.end === selection.end))) {return true;}@@ -70,9 +84,43 @@ export function isComposerNativeEcho(return false;}+/**+ * Records that a parent-driven controlled document was handed to the native+ * editor. From that point the acknowledged snapshot history describes a+ * superseded native state, so it is replaced with the assumed applied state;+ * a later parent update back to a previously acknowledged value must classify+ * as a fresh edit, not as a native echo the editor would drop. Native events+ * that raced past the controlled revision stay authoritative and are kept.+ */+export function assumeComposerControlledState(+ snapshots: ReadonlyArray<ComposerNativeEventSnapshot>,+ eventCount: number,+ value: string,+): ComposerNativeEventSnapshot[] {+ return [+ { eventCount, value, selection: null },+ ...snapshots.filter((snapshot) => snapshot.eventCount > eventCount),+ ];+}+export function pruneAcknowledgedComposerNativeEvents(snapshots: ReadonlyArray<ComposerNativeEventSnapshot>,acknowledgedEventCount: number,): ComposerNativeEventSnapshot[] {- return snapshots.filter((snapshot) => snapshot.eventCount > acknowledgedEventCount);+ // The newest acknowledged snapshot must survive pruning: it is what lets a+ // later, unrelated re-render classify the settled composer state as a native+ // echo instead of a parent-driven edit that would re-control the caret (and+ // reset the keyboard's autocorrect context on iOS).+ let latestAcknowledgedIndex = -1;+ for (let index = snapshots.length - 1; index >= 0; index -= 1) {+ const snapshot = snapshots[index];+ if (snapshot !== undefined && snapshot.eventCount <= acknowledgedEventCount) {+ latestAcknowledgedIndex = index;+ break;+ }+ }+ return snapshots.filter(+ (snapshot, index) =>+ index === latestAcknowledgedIndex || snapshot.eventCount > acknowledgedEventCount,+ );}