ReadonlybackGoes back, as the system back does: closes this screen and answers the screen below it, typed as the screens that can open this one.
ReadonlychangeTypes in the search field (query): looks the text up. Answers the field shown again over
the fresh data (the query, its results and the rank token); continue from it for the next
keystroke, which carries on the same typing session. A text this typing session already
answered shows that answer and sends nothing.
ReadonlycheckpointTakes a checkpoint of the process with this screen on top: what a fresh
process needs to continue from it (restoreCheckpoint), the stack below
included, without opening any screen again.
ReadonlyclearClears the field's text: the person tapped its clear (X). Sends no
request and answers the field's live handle — the same typing session, an
empty text, no suggestions, no rank token ('', the empty open's own value)
and the recent accounts the field holds from its open, which an empty field
shows again — so the next change starts from an empty field and
carries only the new text.
Recorded: android-451/follow-two-from-search — after the first follow the
person returned to the field still holding the first name, tapped its clear
once, and no request went out between the follow (#122) and the second
typing (#124); the second typing's requests carry the same typeahead
session id as the first's. The app registers a client event for the tap
(ig_search_clear_query_x_icon_tap), not a request, and the library logs
it (search.telemetry.ts); the library emits no search_viewport_view
(null_state_recent) after it, because the recording logs none there.
Observed by screenshot, not recorded: on our emulator (app 451, 2026-10-30) the field is empty right after the tap and the Recent accounts list is back with the keyboard open, and it stays so 3 s later. The packet recording carries no screen for it.
ReadonlydataWhat the screen shows: its data, as its data schema types it.
Readonlyquery: stringReadonlyrankToken: stringReadonlyrecentAccounts: readonly {The recent accounts the field lists as items while its text is empty (the
ones it was opened with); a keystroke replaces them with the suggestions,
and clear() lists them again.
Readonlyresults: readonly (Optional Readonlysession?: {The search session the field's open started (empty or typed); the typing session continues it.
ReadonlyidWhich screen this is: its id in the screen catalog (an item's: its item id).
ReadonlykindWhat kind of thing the screen is: a screen, a tab, an inner tab, a feed or an item.
ReadonlyopenOpening an account of the field's Recent list by its user id, without a submit: the same walk
a Recent row's openProfile takes (the account is cached, the click registers, the info stream
is the bare entry_point=profile form). A scene whose person returns to the field and taps a
Recent row continues from here (android-451/follow-from-search). Answers the profile handle.
ReadonlyoriginThe handle this one was opened from: the screen (or the item of its list)
whose call opened it, typed as what can open this screen; undefined for a
launch's or a tab's root.
ReadonlypipePasses the handle through the functions you give, left to right: handle.pipe(f, g) is g(f(handle)).
ReadonlyrawThe answers this visit received from the server, before any decoding; empty on a handle a checkpoint rebuilt.
ReadonlyrecentYour recent searches, shown while the field is empty.
ReadonlyresultsThe results for the text in the field: keywords, accounts and hashtags, told apart by
__typename.
ReadonlysearchTaps the keyboard's search key with query: opens the Top results of the search. Answers
its handle.
ReadonlytailWaits until the background work handed over while this screen was entered
has finished: a launch returns once the feed is drawn and keeps sending the
rest of its requests in the process's background, and yield* feed.tail
waits for them. A screen that handed over nothing — and a handle a
checkpoint rebuilt, whose handed-over fibers belonged to the process that
took the checkpoint — has a tail that is already complete.
One request's ordinary failure is that request's outcome and does not fail
the tail; a session-fatal answer (a checkpoint, a lost login, a suspended
or disabled account) fails it with the same typed error, as it ends the
process. Not waiting for it changes nothing, and interrupting the wait
interrupts nothing the process runs. Inside an action or an otherwise
branch (the process's screen turn) it returns at once, like the wait for
the whole background.
ReadonlytoThe handle as JSON: its data.
The handle of SearchInputScreen: what you hold while the screen is open — its
data, its actions (SearchInputActions) and its lists (SearchInputItems).