eleven / messenger Public

ios: the native chat feed rebuilt — measured stock collection view, owned gestures, profiled-flat rows (#1246)

* ios: flipped UICollectionView chat feed — the anchor/settle machinery goes

The native feed's scroll container is now a flipped UICollectionView
(scaleX 1, y -1; cells counter-flipped; SwiftUI rows via
UIHostingConfiguration) — the Telegram approach. Bottom-start, arrival
pinning, keyboard lift, composer growth and scroll-back stability are
structural properties of the container instead of hand-built pins, so
the #1209/#1210/#1211 settle/anchor bug class dies at the root:

- Opening lands settled at the newest message in the FIRST layout pass;
  no settle phase, no opacity hold, no estimated-height scrollTo.
- Scroll-back prepends are data-source APPENDS past the far end — no
  offset compensation, no stranded viewport.
- Arrivals while scrolled up hold the viewport via a real-layout anchor
  restore; your own send and composing-time growth still pin.
- Keyboard and composer insets are ordinary contentInset changes,
  animated on the keyboard's own curve.

Rows are unchanged SwiftUI (MessageBubble + context menu, swipe
quick-reply, times peek, jump wave, Quick Look zoom anchors) hosted per
cell; cross-row state moves to FeedInteraction, observed by rows only,
so drags re-render visible cells and never the screen.

Flipped-list taxes paid: VoiceOver reads visually (accessibilityElements
override), the scroll indicator is hidden (it would run backwards),
scrollsToTop is off. iOS-scoped by design — the Mac feed is its own
container.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: fix the flipped feed's launch-day trio — cell flip, layout recursion, inset timing

- Upside-down rows: assigning a contentConfiguration REPLACES the cell's
  contentView, so the counter-flip set in the registration handler
  vanished on (re)configure. FlippedCell now enforces the flip in
  layoutSubviews, after every configuration swap. The mixed-orientation
  overlap was also the washed-out 'faded' rendering.
- Crash (MetricKit payloads 19:25/19:26Z): performInitialAnchor ran
  scrollToItem + a second super.layoutSubviews INSIDE the layout pass —
  recursive collection-view layout, UIKit trap. It now only writes
  insets/offset (dirties the same commit, never forces a nested pass);
  the unread-cutoff open gets one exact correction after the pass.
- contentSize KVO fired mid-batch-update; its inset write now defers a
  turn.
- Reconfigure only rows whose content (or previous-neighbour boundary)
  actually changed, not every row every publish.
- FeedLab.plainRows: a bisect switch rendering bare Text rows in the
  same container, to separate container cost from bubble cost.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: flipped feed round 3 — kill all batch animations and needless offset writes

Every diffable apply is now non-animated, and offset writes happen only
when strictly needed. UIKit batch animations in the transformed
collection view were behind the remaining field reports:
- 'faded bubbles' = interrupted insert/reconfigure alpha animations
  stranding cells half-transparent,
- 'arriving from the top' = the default insert animation mirrored
  through the flip,
- 'locked'/janky scrolling = anchor-restore + layoutIfNeeded on every
  publish writing contentOffset mid-gesture, killing deceleration.

Applies now classify the diff: far-end history appends and
reconfigure-only passes touch nothing (position holds by construction);
at-bottom arrivals hold structurally with NO write; only
scrolled-up-with-content-shifts runs the anchor restore, and never
while tracking/decelerating. Sinks removeDuplicates so unchanged
publishes stop re-hosting cells. Arrival-entrance delight will return
as our own cell animation, never performBatchUpdates'.

Also: /plainrows (Debug) toggles FeedLab bare-text rows live — the
strip-and-layer bisect, same container, to split container cost from
bubble cost on the perf ledger.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: flipped feed round 4 — reuse identity, keyboard belt, stuck-offset clamp, feed-dump

- Hosted row identity pins to the message id: cell reuse was UPDATING
  one message's SwiftUI tree into another's and animating the layout
  diff — bubbles visibly morphing mid-scroll.
- The representable now ignores the keyboard safe area directly too, so
  SwiftUI can never double-compensate on top of the container's own
  keyboard inset (the feed-floating-over-an-empty-band geometry in
  Paul's screenshot).
- updateInsets clamps a negative gap: a shrinking top inset could leave
  the offset beyond the rest position, stuck high, and UIKit never
  self-corrects that.
- DEBUG feed-dump: every 4s while the feed is on screen, write the
  UIKit truth (cv metrics, visible cells' frames/alpha/transforms, all
  ancestors+siblings to the window) to Library/Logs/feed-dump.txt —
  pullable over devicectl, so the remaining 'faded' report becomes
  numbers.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: feed-lab ladder — climb from bare rows to full bubbles at runtime

/plainrows proved the flipped container smooth with trivial rows, so the
strip-and-layer method becomes a runtime ladder over the SAME container:

  /feedlab 1  bare text rows
  /feedlab 2  bubble shells (fills + alignment, no MessageBubble)
  /feedlab 3  real MessageBubble, inert (no gestures/separators/actions/blobs)
  /feedlab 4  everything except the long-press menu
  /feedlab 0  the full experience

Rungs 1-3 are plain structs that don't observe FeedInteraction, so each
rung adds exactly one layer's cost; the rung where lag or fade first
appears names the culprit on device, with the perf ledger underneath.
Debug builds only.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: /freshpane — the from-scratch stock pane over the same model

Paul's call: a completely fresh pane. FreshChatPane (Debug) is a stock,
UNFLIPPED UICollectionView over the same ChatFeedModel with none of the
chat screen's clothes — no header/composer glass, no ignoresSafeArea,
no transforms, no gestures, no custom insets. The UIKit feed-dump
proved every cell in the real feed renders at alpha 1.0 with no
translucent overlay, so the wash is composited inside SwiftUI: if this
pane is crisp, the screen's difference list is the suspect pool (added
back one at a time); if it's washed too, the cause sits below both.
Rows follow the /feedlab ladder (rung 3 shown at level 0 so real
bubbles render). Opened with /freshpane from any chat; read-only.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: fresh pane climbs — full interactive rows in the stock container

/feedlab 0 (and 4) in the fresh pane now hosts the real FeedMessageRow —
gestures, overlays, interaction observation, image loading, and at 0 the
long-press menu — inside the stock unflipped list. The final bisect:
smooth here = rows exonerated, the old screen's dressing is the cost;
laggy here = the row layers are, and 3→4→0 names which.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: StockChatFeed is the default feed — the fresh pane, promoted

Every chat now opens on the stock, unflipped container the /freshpane
experiment proved silky on device, grown into a full feed:

- Opens at the bottom on the first real layout (offset-only writes
  inside layoutSubviews — the no-forced-layout contract).
- Arrivals reveal via a scroll only when at the tail / own send /
  composing; reading history never yanks (appends can't move an
  unflipped viewport).
- Scroll-back prepends compensate by the REAL laid-out height delta,
  and pages buffer while a fling is live, flushing when the scroll
  settles — the compensation write never kills deceleration.
- Keyboard/composer ride standard SwiftUI safe areas; height changes
  keep the bottom anchored iff the reader was on it.
- Rows are the same FeedMessageRow ladder; /feedlab and /freshpane
  remain as Debug diagnostics, no longer needed to get the good path.

The flipped container stays in-tree, dormant, pending the cleanup
pass; FeedScrollController now speaks to either through FeedScrolling.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: bring-back step 1 — content scrolls under the composer glass again

One layout change on the stock feed: ignore the container's bottom safe
area (keyboard stays live), letting messages slide beneath the composer
glass and home bar with UIKit's automatic adjustment providing the rest
inset. The first fade suspect, reintroduced in isolation.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: bring-back step 2 (under-header glass) + the stick-to-bottom latch

- Content now scrolls under the header pill too (container top edge
  ignored; automatic adjustment keeps the rest position below it).
- Opens land at the bottom FOR REAL: a stick-to-bottom latch re-lands
  the tail on every layout pass from open until the reader scrolls —
  estimated row heights settle to real ones over several passes (worst
  with images), and the one-shot pin drifted out from under them.
  Released on drag, re-armed when a scroll settles on the tail, never
  fights an animated pin (iMessage-sticky bottom).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: rest insets — content rests between the header and composer glass

The screen measures both glass overlays (probes on the header VStack and
the composer cluster) and the container turns them into deterministic
content insets, plus the window's status/home bars — the home-bar term
handing off to the keyboard when it's up. Content scrolls under both
glasses but RESTS clear of them; the stick-to-bottom latch keeps the
tail landed through inset changes (composer growth included).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: cell placement never inherits ambient animation transactions

The rest-inset round's measurement probes write state during SwiftUI's
animated updates; a collection layout pass reached inside such a
transaction animates cell placement — materialising bubbles bounced
into place mid-scroll. layoutSubviews now runs inside
UIView.performWithoutAnimation: layout is instant always, deliberate
motion stays scroll animation only.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: measured layout — no estimated self-sizing, nothing left to correct

Every scroll symptom of the night (bubbles bouncing in, flying from the
top, snap-jank, opens drifting off the bottom) was UIKit's estimated
self-sizing correcting materialised cells, surfacing through whatever
animation context it inherited. FeedMeasuredLayout removes the disease:
rows are measured up front (one offscreen sizing cell running the SAME
UIHostingConfiguration the live cell gets, cached per row, dropped
exactly when a row's content or the width/theme/type-size changes), and
the layout only ever places exact frames — a running sum + binary
search. Late unfurl growth re-measures its row via a wrapped hook, with
model.cachedUnfurl making the re-measure see the resolved card (the
peekUnfurl seam MessageBubble carried for precisely this). Also: the
overlay-probe deadband (sub-point jitter was invalidating the whole
layout mid-scroll every render).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: measure each row on a fresh content view — heights can't be borrowed

The persistent sizing cell reconfigured across rows swaps its hosted
tree asynchronously (the .id identity change), so the fitting pass
could answer with the PREVIOUS row's height — tall markdown bubbles
rendered truncated mid-sentence inside frames borrowed from shorter
neighbours, reading as bubbles shrinking/growing with scroll direction.
Each measurement now builds a fresh content view with exactly one
identity to size, plus a degenerate-height clamp.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: no structural applies inside the display pass; prepends reload clean

Overlapping rows at the top edge: a buffered history page was flushed
from INSIDE willDisplay — a structural batch update mid-display leaves
visible cells wearing pre-update frames. Flushes now defer a turn, and
structural changes that shift existing rows (prepends, deletions) apply
via applySnapshotUsingReloadData instead of batch-update diffing — the
visible handful of cells rebuild cleanly, off the hot path (pages
buffer to scroll-settle; buffering now covers a tracking finger too).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: measure ideal heights (sizeThatFits) + flush pages at rest only

Two stubborn top-edge defects, two exact causes:
- systemLayoutSizeFitting finds the SMALLEST satisfying height and
  SwiftUI Text satisfies compression by TRUNCATING — tall bubbles
  measured short and rendered cut off. sizeThatFits(width, unbounded)
  asks for the ideal height instead.
- The deferred page flush still ran mid-fling; a structural reload
  racing the deceleration animator composites cells from two offsets
  (the ghost-doubled rows). flushPending now refuses to run unless the
  scroll is fully at rest; scrollSettled re-fires it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: opt out of the system scroll edge effects on the feed

The liquid-glass edge treatment compresses and fades content passing
under bars; with a full-bleed feed and manual insets it infers its
regions wrong — bubbles visibly squashed and stacked as they left the
top of the screen, and a mis-sized region reads as a washed-out feed.
topEdgeEffect/bottomEdgeEffect hidden: rows scroll off unmolested, the
glass overlays do their own work.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: /bareedges — the glass-vs-list bisect

Every remaining top-edge artifact sits exactly where bubbles pass under
the header glass. /bareedges (Debug) renders the feed BETWEEN the bars
with zero insets — nothing ever under the glass — so one look separates
'the list corrupts rows at its edge' from 'the glass distorts what
passes beneath it'.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: the header pill stops lensing the feed — scrollSafeGlass

The /bareedges bisect convicted the glass: every ghosted/stacked/
compressed bubble sat in the band passing under the header pill, and
the list was clean once nothing rendered beneath it. The liquid-glass
lens refracts and duplicates content moving under it. New
scrollSafeGlass modifier (the material fallback, on every OS) for glass
that floats over the scroll path; the header pill adopts it. The lens
stays everywhere it floats over static chrome.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: enforce the edge-effect opt-out every layout pass + strip bar interactions

The pill swap changed nothing and /bareedges stayed clean — the
corruption engages with FULL-BLEED itself: the nav-bar integration
attaches its under-bar edge treatment AFTER build time, overriding the
one-shot opt-out. The collection view now re-asserts hidden edge
effects on every layout pass and removes any scroll-edge interaction
the bar machinery hangs on it or its ancestors.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: cede the top band to the system — bottom-only bleed

Paul's Messages comparison + 'bubbles disappear halfway up the island'
pinned the last corruption: SwiftUI composites the under-bar squash/
fade in the BAR's own layer, sampling the feed from a sibling branch no
view-side opt-out reaches (edge-effect hiding, interaction stripping
and the pill's material swap all changed nothing). The feed now starts
below the header (the /bareedges top, proven clean) and keeps the
composer under-scroll (clean all night). headerHeight stays measured
for the day a real opt-out exists.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: full-bleed the Messages way — real safe areas, system fade allowed

Paul's read was right: Messages is a plain UIKit list whose content
runs to the top with the standard subtle fade — because its scroll
view has honest safe-area geometry. Ours squashed rows over half the
screen because .never + hand insets + no UIKit-visible safe areas fed
the edge treatment garbage. The feed is now hosted by a view
controller declaring the measured glass overlays as
additionalSafeAreaInsets with automatic adjustment; the edge-effect
suppression and interaction stripping are gone — the system fade is
WANTED, it just needed real geometry to degrade to the subtle
Messages-grade band. Full-bleed top restored (bottom-only bleed
rejected).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: tighten the rest gap above the composer (10pt trim)

The measured composer cluster carries its own breathing room, so the
newest message rested doubly padded above the glass. A 10pt trim on the
rest inset, both keyboard states.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: layering step 1 — pill liquid glass only

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: layering step 2 — jump caret fix + own pin curve

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: layering step 2b — the caret becomes a UIKit control

A SwiftUI overlay button loses touch arbitration while the list moves —
taps stopped the scroll instead of firing. The caret is now a UIButton
in the host controller's container view (blur circle, 44pt, floating
above the composer via the safe-area guide in both keyboard states),
always tappable mid-fling; a tap kills live deceleration first, then
pins. The onJumpVisible plumbing to the screen goes — the container
owns the caret's whole life now, so scrolling never re-renders SwiftUI.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: caret polish — 36pt liquid glass, 20pt lower, flush with the composer edge

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: layering step 3 — arrival entrance beat (own cell animation)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: equal message-to-composer gap in both keyboard states

The resting and keyboard-up states reach the bottom inset through
different machinery (home-bar handoff vs keyboard avoidance), so one
trim constant read ~3pt at rest and ~20pt with the keyboard up.
Per-state trims, both dialled to ~10pt above the glass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: caret 10pt back up after the trim recalibration moved its anchor

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: DEBUG height dump for the frozen-chat triage

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: every structural apply is a clean reload — batch updates carry nothing

The short-chat stacking report pinned the last stale-frame breeder: tail
changes (arrivals, and above all the typing row's constant churn in
agent chats) still rode performBatchUpdates, whose mid-update window
computes frames against a half-transitioned item list on a custom
layout. Structural applies of every shape now reload cleanly; the batch
path survives only for reconfigure-only applies, which move nothing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: permanent typing row + the height dump goes quiet

The typing row is now always the tail item, measured at zero height
when nobody's typing — typing beats never cause a structural apply
again (the churn was a reload or batch every few seconds in agent
chats: stacked cells before, scroll delay after). Appearing at the
tail still pins for a reader at the bottom or composing. The triage
height dump now writes at first layout only — it was walking every row
and writing a file on the main thread per publish.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: the pill lens comes off — refraction cost scales with the backdrop

The lab-level discovery invalidated the morning's rung verdicts: rung 1
(pill liquid glass) was only ever scroll-tested over plain lab rows.
Real bubbles under the lens = the felt delay, on both days it was
tried; material blurs at fixed cost and was silky under real bubbles
last night. Lens off, everything else in the stack unchanged — the
single-variable test.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Revert "ios: the pill lens comes off — refraction cost scales with the backdrop"

This reverts commit 8d8df545d70a3e79ce9bef0738d8c4f8299ade52.

* ios: short-chat bunching — hosted cells escape the safe area; honest insets

Short chats rendered truncated, overlapping, mid-screen-floating rows and
looked frozen. Two root causes, both reproduced by the new in-process
LChatFeedTests harness (real StockChatFeed in a window, fake model):

- UIHostingConfiguration cell content PARTICIPATES in the window's safe
  areas: cells intersecting the top band had their SwiftUI content evicted
  downward and compressed to fewer lines, permanently. Long chats never
  showed it (visible cells sit at the bottom; wedged top cells heal on
  recycle). Fix: cells own a UIHostingController with safeAreaRegions = []
  (no UIHostingConfiguration switch exists; .ignoresSafeArea() inside it
  only half-pushes back). Reuse now swaps rootView in place.

- Inset geometry: .automatic stops adjusting when content fits on screen
  (alwaysBounceVertical keeps it honest + chat feeds should bounce), and
  updateInsets was adding the window safe areas AGAIN on top of the host
  controller's inherited ones — the mid-screen float, and the reason the
  resting trim had to be dialled to 38 (= double-counted 34 + 4). Trims
  re-derived to 4/0; long-chat geometry unchanged by construction.

Harness: new LChatFeedTests unit-test target (TEST_HOST = LChat) +
ChatFeedModel._testInject (DEBUG-only publisher injection).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: the long-press menu becomes the collection view's context menu

A SwiftUI .contextMenu inside UIKit-hosted cells never fired (the dead
long-press report). The menu now lives on the UIKit list itself via the
context-menu delegate — Messages-grade preview and scroll arbitration —
mirroring MessageBubble's menuItems exactly: reaction palette, Reply/
Copy/Edit, Mute/Report, mine-only Delete. The hosted bubble passes
actions: nil in the feed; the reply-thread overlay (plain SwiftUI)
keeps the SwiftUI menu.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: the long-press menu becomes ours — FeedMenuOverlay + a real-touch sim rig

Every system context-menu route proved broken for bubbles on device
(2026-07-21): the collection item pipeline platters the whole CELL (the
'aura', immune to every preview API — targeted previews, visiblePath,
shadowPath, clear backgrounds, hover styles), a manual interaction on the
list is starved by the built-in one, per-cell interactions never fire
under the hosted SwiftUI gesture graph, and the SwiftUI row long-press is
starved by scroll arbitration (real synthesized presses never fired it;
taps flow fine). Dermot's call: we don't need the preview. Paul's call:
the press belongs to the bubble.

So the menu is drawn by US (FeedMenuOverlay): dim the feed, float the
bubble's own pixels in place (rect computed the same deterministic way row
heights are), reaction palette above, labelled card below — the web app's
long-press menu. The trigger is a plain UIKit long-press recognizer on the
list (the one layer that reliably sees held touches), row resolved by
location; whole-row presses answer as the bubble's.

Verified UNATTENDED with real synthesized touches: new FeedMenuUITests
drives the actual app in the simulator against the local dev server —
open menu, react, dismiss, reopen, outside-tap dismiss — via a new
DEBUG-only LCHAT_DEV_JOIN launch-env door (AppState seeds a space
natively from a dev join link; empty installs only). The rig reproduced
the device's dead press before the fix and passes after it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: the feed lab is stripped — the ladder's job is done, its footgun isn't

FeedLab (the strip-and-layer diagnostic ladder), FeedLabRow, FreshChatPane,
and the /feedlab /plainrows /freshpane /bareedges debug commands are gone.
The level persisted in UserDefaults across builds and twice wedged a real
phone into the diagnostic renderer — raw markdown, no bubble rects, a dead
long-press menu — while looking close enough to real bubbles to burn hours
(2026-07-20 and again today, found by the menu breadcrumbs: lab=1). The
LChatFeedTests harness and the FeedMenuUITests real-touch rig now cover
everything the ladder was for.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ios: the open-freeze — no double measure, and heights survive the screen

The 2026-07-21 evening freezes, by the ledger: feed.mount 3.1s for 201
messages, feed.openThread spans to 11s, main-thread hangs to 884ms. The
harness put a number on it — a 200-row publish blocked the main thread
278ms in the SIM (a multiple of that on a Debug device build). Two causes,
both ours:

- Every open measured every row TWICE: makeUIViewController left the
  ConfigKey dummy, so the first updateUIViewController 'changed' it and
  reconfigured the world. Seeded at make now.
- Heights died with the coordinator, so every RE-open of a parked chat
  re-measured all rows with fresh UIHostingControllers. FeedHeightCache is
  the cross-open answer — keyed by content + relation + width + type
  settings (deterministic), refreshed by rowGrewLate when an unfurl lands,
  bounded by a dumb reset.

Harness numbers: cold open 278ms → ~200ms; re-open 241ms → 8-11ms with
byte-identical content height. testTwoHundredMessageMountCost pins both
paths (re-open must beat half the cold cost; heights must match exactly).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: row-content ladder + the .id remount fix — 28% off per-row scroll cost

The container ladder (RowLadderTests, test-only row override) bisected the
scroll jank per materialised row: plain 4.9ms -> +3.7 bubble chrome -> +5.7
MessageBubble internals -> +2.2 row overlays -> +6.8 for the per-message
.id remount. Fixes:

- Drop .id(m.id) on feed rows; recycle swaps rootView in a no-animation
  transaction instead, and attachment/link views reset their loaded state
  on identity reuse (onChange guards) so a recycled cell can never show
  another message's photo/poster/card.
- Gate the touch .contextMenu on actions existing — the feed passes nil
  (UIKit list owns the long-press menu) and paid ~1ms/recycle for a menu
  that could never show.
- .textSelection(.enabled) is Mac-only now: on touch the long-press menu
  owns Copy (matching the web convention), and the selection machinery
  cost ~0.6ms/recycle.

prod rung: 23.3 -> 16.7ms/row, all correctness tests green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: persist the feed height cache — first opens stop paying the measure pass

Paul's device ledger showed the enter-a-chat lag directly: feed.mount
3.1s for 201 messages — ~200 fresh SwiftUI measurements on first open,
paid again for every chat on every launch because the cache was
process-local. FeedHeightCache now persists to Library/Caches (loaded
async at boot via warm(), debounced saves), stamped with the binary's
mtime so a new install can never serve heights measured by different
layout code. Harness: relaunch first open 205ms -> 18ms, heights
identical; all correctness tests green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: the Contributors fast-scroll freeze — row swipe moves to a direction-gated UIKit pan

Scroll forensics (DEBUG crumb file, pulled off the device) caught the
freeze in the act: 575pt of vertical finger travel consumed by the rows'
SwiftUI rowSwipe DragGesture with the scroll pan never reaching .began.
The DragGesture activated on ANY direction >=18pt (its horizontal-only
filter ran inside the handler, after the claim), and when it won the
arbitration race against the scroll pan, fast flicks died entirely —
repeatedly on consecutive touches.

Same migration as the long-press menu: the swipe is now a UIKit pan on
the collection view whose gestureRecognizerShouldBegin requires
horizontally-dominant velocity, so vertical motion structurally cannot
be claimed away from the scroll pan. Rows keep rendering replyDrag/
timesReveal; the crumb instrumentation stays (DEBUG-only) for the next
field pull.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: times-peek gutter fits the timestamp; typing dots stop painting through the collapsed row

Two field findings from Paul's device pass (2026-07-21):

- The times peek shifted bubbles a fixed 64pt while the timestamp needs
  ~35 — a dead ~30pt channel between bubble edge and time (screenshot
  vs Messages). The gutter now measures the widest localized time
  (20:55 sample covers 24h and AM/PM locales) plus a Messages-tight
  gap; time font 11 -> 12.

- The typing row hides by collapsing to zero height, but its hosted
  SwiftUI view never clipped, so the dots painted straight through the
  collapsed cell — 'typing seems stuck and always visible'. The typing
  cell's hosted view now clips (message rows self-clip already); pinned
  in testTypingChurnKeepsCellsDisjoint.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: the typing-to-message handoff — dots fade out, the arrival actually rises in

The arrival entrance animation targeted the LAST item — which is the
permanent typing row, a zero-height cell — so it animated nothing and
every arrival snapped into place. It now targets the newest message
(count-2). And when the typing indicator clears, the dots fade out over
120ms before their row collapses instead of blinking off next to the
rise-in. Both respect Reduce Motion.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: a typer's arriving message retires their dots in the same apply

The handoff played as two motions — the arrival grew the pane (animated
pin + entrance), then the separate typing-off event collapsed the dots
row a beat later: the jump Paul saw. The coordinator now clears the
sender's local typing state inside applyMessages, so items and heights
change once and pin + rise + dot removal read as one replacement (the
Messages feel). The fade-then-collapse remains for stopped-without-
sending. Pinned in testArrivalReplacesTypersDots.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: flatten the row layout tree — 35% off per-row scroll cost today

The sample-tool profile of a live container sweep (testProfilePadProdSweep
+ the marker-file sampler) showed ~95% of scroll-path time inside
SwiftUICore StackLayout.sizeThatFits recursion — layout NODES are the
cost, and release SwiftUICore means device Release pays it too. Cuts:

- Rows align the bubble with padding + frame alignment instead of
  HStack + Spacers (two unary nodes vs the stack algorithm); same
  geometry, bubbleRect math unchanged.
- MessageBubble: a simple-text fast path (no attachments/reply/
  reactions/tags/card/link) skips the wrapper VStack and tag
  scaffolding — most feed rows. Actions chrome unified into one
  ActionsChrome modifier that adds NO nodes when actions are nil.
- FeedMessageRow only wraps in a VStack when a separator exists.
- Plain single-run paragraphs render as plain Text instead of building
  an AttributedString — most messages; also cut the measure pass
  (cold 200-row mount 214 -> 152ms).

prod rung: 16.7 -> 14.3ms/row (22.0 at the day's start); heights
byte-identical (contentH pinned by the harness).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: height-audit crumbs + stable persisted-cache hash + separator repro pins

Paul's App-test-group screenshot shows date separators painting over
neighbouring rows — a cell measured without content it renders. Clean
harness sequences (group separators, boundary-changing prepends) don't
reproduce it, so the DEBUG build now audits on every scroll settle:
any visible cell whose laid-out height disagrees with its content's
ideal gets crumbed with its cache key — one device pull names the rows.

Also found en route: heightCacheKey used String.hashValue, which is
seeded per process — persisted heights silently never matched across
real launches. Now FNV-1a, so the disk cache actually works on device.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* native: unfurl card image slot is a fixed 280x150 window — measured height is load-independent

The device height audit named the overlap row exactly: cell 227 vs
ideal 366 — the 139pt delta the unfurl card's image. AsyncImage's
placeholder phase contributed no height in the measure pass (which
never loads images), so image-bearing cards measured short and painted
over the rows below once the image landed, with nothing re-measuring
on load. The slot is now a fixed frame whenever imageURL exists —
identical before and after load. Pinned:
testUnfurlCardMeasuresImageSlotBeforeLoad (bare 160 / with-image 310).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>