Files
hex/ios/docs/typing-logs.md
Ryan Vogel be49c35f2b iOS: privacy and support links in the app, Continue before the mic prompt, typing logs consent (#2063)
* iOS Privacy: Privacy policy and Support links, for App Review 5.1.1(i)

App Review requires a privacy policy link inside the app. The Privacy page
now has a card with two rows between Learn how I type and Advanced:
- Privacy policy opens https://dev.anoma.ly/hex/privacy.
- Support opens https://dev.anoma.ly/hex/iphone.

Both open in Safari inside Hex (SFSafariViewController, SafariSheet).

The URLs come from one base in HexLinks.swift (HexLinks.site). Moving to
https://anoma.ly/hex is a one-line change once the site's production deploy
serves those pages; https://anoma.ly/hex/privacy returns 404 today, while
both dev.anoma.ly pages return 200. README's Privacy page entry says so.

Verified: the build passes on an iPhone 18 Pro simulator (iOS 27.2). I looked
at the settings-privacy render. A temporary, uncommitted hook opened the
Privacy policy row's Safari sheet, which loaded the live dev.anoma.ly page.

* iOS setup sheet: Continue, not Allow, before the microphone prompt

App Review 5.1.1(iv) rejects a custom button that says "Allow" right before
iOS's own permission prompt. The setup sheet's Microphone row had one. It now
matches onboarding's Set up Hex page (#2058): the row says why ("For
dictation", replacing "Required") and its button says Continue. Tapping
Continue still calls requestMicrophone, so iOS asks right after. Allowed and
Off are unchanged, and Off still shows Open Settings.

New scene: --snap-state setup-sheet-microphone, the setup sheet before iOS
has asked for the microphone. README's Setup and scene notes are updated.

Verified: the build passes on an iPhone 18 Pro simulator (iOS 27.2). I looked
at the setup-sheet-microphone render (For dictation, Continue) and the
setup-sheet render (Allowed, no button).

* iOS Privacy: Record typing logs says what it records and asks before turning on

App Review 2.5.14 requires explicit consent before recording what people
type.

- The description now says what the feature records: "Records taps and the
  text you type for 14 days, on this iPhone, to export. Off by default." It
  replaces "Off by default. Stays on this iPhone to export" and fits on two
  lines.
- Turning it on opens an alert before anything changes. Title: "Record
  typing logs?". Message: "Hex's keyboard will record each tap and the text
  you type or dictate with it, including the text around the cursor, for 14
  days. The logs stay on this iPhone for you to export or delete. Password,
  code and card fields are never recorded." Turn On switches it on; Cancel
  leaves it off. Turning it off needs no dialog. The switch still writes only
  TypingLogSettings.isEnabled.
- Every claim matches docs/typing-logs.md: touches on Hex's keys, the text
  each key produced, the text around the cursor, dictations, 14 days in the
  App Group, export and delete from Typing logs, and a "skipped" line only for
  password, one-time code and card fields.

New scene: --snap-state settings-privacy-confirm opens the dialog
(SettingsSnapshotFixture.confirmsTypingLogs). README and docs/typing-logs.md
now describe the consent and the new path (Privacy › Advanced, no longer
Experiments).

Verified: the build passes on an iPhone 18 Pro simulator (iOS 27.2). I looked
at the settings-privacy, settings-privacy-confirm and settings-privacy-on
renders.

* iOS home: Privacy policy and Support join Acknowledgements

#2059 added an Acknowledgements row at the bottom of home's utility card. The
privacy policy and support links read better beside it than on the Privacy
page. Home's last card now has Privacy policy (hand.raised, ↗), Support
(questionmark.circle, ↗) and Acknowledgements (doc.text, ›). Keyboard settings
and Run setup again keep their own card above it.

- Moved, not duplicated: the Privacy page's links card is removed. That page
  is back to "Everything stays on this iPhone", Learn how I type, and
  Advanced.
- Links still come from HexLinks (dev.anoma.ly until production serves
  anoma.ly/hex/privacy) and open in Safari inside Hex.
- README's Settings section now lists the links on home.

Verified: the build passes on an iPhone 18 Pro simulator (iOS 27.2). I looked
at the settings-home render, which still fits one screen without scrolling,
and the settings-privacy render.
2026-11-20 16:23:37 +00:00

15 KiB
Raw Permalink Blame History

Typing logs (Record typing logs)

Settings › Privacy › Advanced › Record typing logs (off by default, asks for consent in a dialog before it turns on, App Group key experiments.typingLogs) makes Hex's keyboard write raw logs of everything it sees: every touch with its position and timing, the key it pressed, what that did to the text, the text around the cursor, and dictations. They are for testing and training keyboard prediction and per-user touch models on a Mac. Nothing is sent anywhere; Privacy › Advanced › Typing logs shares a day's file (or all of them) through the share sheet, for example by AirDrop.

It is separate from Learn how I type, which keeps only word pairs and per-key averages and is unchanged.

Files

  • TypingLogs/yyyy-MM-dd.ndjson in the App Group container (group.anomaly.hex.mobile), one per local day (Gregorian date in the iPhone's time zone). Each event goes to the file of the day its t falls in.
  • NDJSON: one JSON object per line, UTF-8, \n after every line.
  • Kept 14 days (today and the 13 before). Older files are deleted when the keyboard starts a logger and when the Typing logs screen opens.
  • At most 64 MB a day. The first event that would cross the cap is replaced by one cap_reached line and nothing more is written that day.
  • The keyboard writes nothing without Full Access (it can't reach the App Group) and nothing while the experiment is off. The app's keyboard preview and simulator fixtures never write logs.

Writing: events are appended to an in-memory buffer on the main thread and handed to one serial utility queue every 2 s (and when the keyboard goes away, on a memory warning, and at 1,500 buffered events), which encodes them and appends them with FileHandle. Lines from one session are in order; a session ends with session_end unless the keyboard process was killed first.

Common fields

Every line starts with these, in this order:

key type meaning
v int Schema version, 1.
t int Wall clock, ms since 1970 (UTC).
mt number Monotonic ms (CACurrentMediaTime, time since boot without sleep). Use it for intervals; UITouch.timestamp (ts) is on the same clock.
type string Event type, below.
session string 12 hex digits, new each time the keyboard appears or moves to another field.
seq int 1, 2, 3… within a session. A gap means lines were lost (only the cap does that).

Units and spaces:

  • Positions and sizes are points in the keyboard view's coordinates: origin at the top-left of Hex's keyboard view (the suggestion strip's top edge), x to the right, y down. The strip is y 0–44 in portrait, the keys below it.
  • A rect is [x, y, width, height]. Insets are [top, left, bottom, right]. Points have 2 decimals, ms 3.
  • Character counts are Swift Characters (grapheme clusters), what one backspace removes.
  • A key id is the character itself for character keys (always one character: "a", "7", "@"; letters lowercase) and a word for the others: shift, delete, space, return, hex, globe, layer:numbers, layer:symbols, layer:letters.

Events

session_start

The keyboard appeared (trigger: appear), the field changed while it showed (field), or the experiment was turned on while it showed (enabled).

  • surface: full (Hex's keys) or bar (the dictation bar; no touches).
  • document: UITextDocumentProxy.documentIdentifier, which changes with the field. The host app is not knowable from a keyboard and is never guessed.
  • traits: keyboardType, returnKeyType, autocapitalization, autocorrection, spellChecking, smartQuotes, smartDashes, smartInsertDelete, inlinePrediction, keyboardAppearance (UIKit case names, e.g. "emailAddress", "send", "no"), textContentType (its raw value or null), secure, enablesReturnKeyAutomatically.
  • bounds [w, h] and safeArea of the keyboard's root view when the session started (may be before layout; layout lines carry the real size), orientation (portrait/landscape), appearance (light/dark).
  • device (iPhone17,1; Simulator:… in the simulator), system (iOS 26.1), version and build of Hex, locale, languages (first four preferred), keyboardLanguage (the keyboard's primaryLanguage), inputMode (the field's input mode language), fullAccess.
  • settings: autocorrect (Hex's), spatialAutocorrect, key_popups, haptics, learnHowIType, cleanupTagger, hexKeyPlacement, dictationLanguage (BCP 47, or automatic), keyboardLayout (en/nb/es/de, empty for the dictation bar), style (dictation style).

A context line follows at once with the text already in the field.

skipped

Instead of session_start in a field that must not be logged; nothing else is written for that session, not even session_end. reason is secureTextEntry or textContentType:<raw value> for password, newPassword, oneTimeCode and every creditCard… content type. Also trigger, surface, keyboardType, textContentType, secure. Every other field is logged, including ones with autocorrection off.

session_end

reason: disappear, field_changed, disabled, or replaced. durationMS, and counts of touches (began), edits, dictations. A context line (when the text changed since the last one) and any unwritten candidates come just before it.

layout

Written when the key layout or shift changes, and when a session starts.

  • hash: 16 hex digits over every key's id, frame and hit frame and the strip. Touches name it in layout.

  • cause: session, field, layout (width, orientation, globe), geometry (view size or safe area only), layer_key (123/#+=/ABC pressed), layer_auto (space or return went back to letters), layer_slide (hold 123, slide, let go), shift_key, typed (a one-shot shift turned off), auto (auto-capitalization), cancel, language (the keyboard layout changed).

  • layer (letters/numbers/symbols), shift (off/on/locked), shiftHeld (only when true), field (text/url/email), orientation, width, height (the keys' layout), view [w, h], safeArea, horizontalInset (landscape), globe, hexPlacement, language (en/nb/es/de).

  • The first time a hash appears in a day's file the line also has:

    • letterWidth (a 10-key row's; 11-key Norwegian and German letters are narrower, see keys), metrics (side, gap, rowGap, keyHeight, stripHeight, keysBottom, cornerRadius),
    • strip: the suggestion strip's rect, and slots: its three suggestion slots (left, centre, right),
    • keys: [{id, label, row, frame, hitFrame}]. frame is the drawn keycap, hitFrame the touch target; hit frames tile the key area (row 0 to 3) with no gaps. The Hex key in the strip has row -1.

    Later lines with the same hash in that file say "repeat": true instead, so look the keys up by hash. Every touch's hash appears in full earlier in the same file.

touch

One finger sample on the keys (not the strip, whose buttons log ui/edit).

  • phase: began, moved, ended, cancelled. id: the finger, stable from began to ended.
  • x, y: the raw touch location. r: majorRadius, rt: majorRadiusTolerance (pt). force and maxForce only on devices with force. ts: UITouch.timestamp in ms (monotonic, same clock as mt).
  • layout: the layout hash at the time.
  • key: the key the engine resolves. For began, the key under the point (what the engine presses). For moved and ended, the key the finger is held on: sliding across character keys moves it; any other key keeps the key it went down on. null when the finger went down outside every key.
  • under: on moved/ended/cancelled, the key under the raw point when it differs from key (null: outside every key). The engine has no touch correction model today: it uses the hit frames, so key on began always equals the key under the point.
  • moved is throttled: a sample is written once the finger has moved at least 2 pt and 8 ms since the last line for it, or when it slides onto another key.

Order: began and ended lines come before the edits they cause (a character types on release; delete and shift act on press; a press commits the characters of fingers still down, which is rollover). A moved line comes after what the move did (trackpad cursor steps, accent selection).

edit

What the keys did to the text, with op. To rebuild the text before the cursor, for every edit (and dictation) line remove deleted (a string; deletedCount characters when the text wasn't known) from the end, then append inserted. cursor moves need the context lines to resync.

op fields
insert inserted, src: key (a character or space), accent (long-press pick), slide (hold 123, slide, let go), bar (the dictation bar's space)
delete deleted (the character), src: key (on press), repeat (held, 75 ms), repeat_fast (after 0.85 s, two at a time), bar
delete_word deleted, src: repeat_word (held past 1.4 s)
autocorrect from, to, deleted (= from), inserted (to + space). Applied on space.
autocorrect_undo deleted (the correction and its space), inserted (what was typed): one backspace right after a correction undid it.
suggestion slot (0 left, 1 centre, 2 right), text (as shown), deleted (the word being typed), inserted (the replacement + space), candidates (as in candidates)
double_space_period deleted: " ", inserted: ". "
return inserted: "\n", returnKeyType, send (the key said Send); ignored: true and no inserted when the key was disabled (empty field)
paste inserted: the strip's Paste chip
undo_dictation deleted (the dictation), or deletedCount when the host showed only its end
cursor offset: characters the spacebar trackpad moved the cursor (negative is left)

candidates

The suggestions the strip offers: items: [{slot, text, replacement?, kind, auto?}], kind literal (left, what you typed), primary (centre; auto: space will apply it), secondary. Written only when they changed, lazily: just before the next touch goes down and at session end, so each line is what was on screen when a finger next went down. The strip hides them while it shows Undo dictation, a status, or the clipboard chips.

context

The host's text around the cursor, as documentContextBeforeInput / AfterInput give it. why: session_start, space, return, suggestion, delete_word, autocorrect_undo, paste, trackpad, undo_dictation, dictation, session_end, or text_did_change (the host changed the text or moved the cursor: written once things settle for 0.3 s, at once when the field emptied). before (the last 200 characters), after (the first 200), beforeLength and afterLength (before capping; hosts often cut the context short themselves), hasText. cleared: true when the field had text and now has none (most apps clear it when they send). An unchanged context is not written again.

ui

Taps that aren't text: action:

  • accent_open (id, key, options), accent_pick (id, index, chosen, rollover when another key committed it), accent_cancel;
  • trackpad_start (id), trackpad_end (id, offset: total characters);
  • hex_key (dictation: warm, keyboard, open_hex), hex_menu, style (style, from: hex_menu or recording_panel), dictation_language (language: BCP 47 or automatic, from the Hex menu), dictation_stop (from: hex_key_release when lifting a push-to-talk hold ends it), dictation_cancel;
  • next_keyboard (strip chip), globe, undo_dictation (applied: false when the text had changed), touches_cancelled (count).

dictation

Hex inserted a dictation (from the full keyboard or the dictation bar).

  • source: keyboard (in-keyboard dictation) or app (a warm session or a handoff to Hex). resultID, style.
  • Each step, when it ran (a step that didn't run is missing): engine, locale (in-keyboard) or language (the app), recordedMS, transcribeMS, raw (as heard), fixed (after Learn how I type's fixes), spelled (after custom vocabulary, app), tagged (after Clean up what I say), cleaned (after Apple Intelligence, app), translated, formatted (after the style, app).
  • text: the transcript Hex delivered; inserted: what went into the field (with the spacing TranscriptFormatter.insertionText added).

A context line follows.

dictation_outcome

What became of a dictation, from DictationEditTracker (the same inference Learn how I type uses, run separately). dictationSession and dictation (its seq) name the dictation line it is about. outcome: kept, edited, rewritten, undone, deleted, redictated. words, changed, pairs: [{kind, heard, inserted, meant, before, after}]. It settles within 60 s, when the keyboard goes away or moves to another field, or on a Send return key, so it can be in a later session than its dictation.

cap_reached

The day's file hit 64 MB. bytes (file size before this line), cap; seq and session are those of the first event not written.

Size and cost

Measured in the simulator (Debug build, TypingLogTests.testLoggingOverheadAndSize, 3,000 taps of ordinary words): about 1 KB per tap, about 5.2 lines (a began, one moved, an ended, an edit, a candidates, plus a context per word and a layout when shift changes). Steady typing at 200 characters a minute is about 12 MB an hour, so the 64 MB cap is about 5 hours of nonstop typing in a day. On the main thread logging added about 12 µs per tap (35 µs without it, 48 µs with); encoding and appending run on the utility queue. Real fingers may produce more moved lines than the test's one per tap.

Reading a day on a Mac

import json
layouts, text = {}, ""
for line in open("2026-11-19.ndjson"):
    e = json.loads(line)
    if e["type"] == "layout" and "keys" in e:
        layouts[e["hash"]] = e["keys"]
    elif e["type"] in ("edit", "dictation"):
        if "deleted" in e: text = text[: len(text) - len(e["deleted"])]
        elif "deletedCount" in e: text = text[: len(text) - e["deletedCount"]]
        text += e.get("inserted", "")
    elif e["type"] == "touch" and e["phase"] == "ended":
        keys = layouts[e["layout"]]   # where the finger lifted, against every key's frame

(Python counts code points, not grapheme clusters; use a grapheme library for emoji and combining marks.)