Thread

The FLOORPLAN for conversational records (`design-system/components/floorplans/ThreadScreen.d.ts`): a feed of post blocks with their replies, a composer, and the events and rules between them. What it always owns: * **The bar, on every state, empty included.** In a destinations-mode AppScaffold the chrome projects into the shell's bar through the contributor tier (AppHeaderActions, via RecordsChrome) — the resting search glyph below 960, the resting field at ≥960, search MODE in between; the shell owns the title, the scope and sync. Pushed (no bar host) the floorplan stands up its OWN bar, an AppHeaderBar carrying title in a body-mode AppScaffold, so the contributed chrome still lands in a bar rather than resting a toolbar in the body. * **The composer's placement** (composer) — the pinned bar at the block-end edge, or the resting strip at the head of the feed opening the focused compose surface. Never both; a new entry is never drafted inline in the feed. A send that FAILS keeps its draft and says so. * **The faces** — error (error + onRetry), loading (skeleton blocks — loading, ORed with a null items), empty (empty) and narrowed-to-zero, each in the body UNDER the chrome with the composer still present, and in the contract's RANK: ERROR > LOADING > EMPTY > NARROWED-TO-ZERO > the feed. EMPTY is decided by the DATA (a zero-length feed — nothing to narrow) and narrowed-to-zero by the NARROWING. * **The zone grammar** — paper blocks on the `sur` canvas, the 720 reading measure (kAppThreadMeasure) centered. * **The scroll** — the feed scrolls; the composer bar and the chrome do not. ```dart ThreadScreen<PostRow>( title: 'Discussion', items: posts, // null = loading · [] = empty entry: (p) => ThreadEntry(key: p.id, author: nameOf(p), text: p.comment, timestamp: p.at), empty: const ThreadEmpty(title: 'No posts yet'), composer: ThreadComposer.strip(onPost: post, onReply: reply), cardMenu: (p) => postMenu(p), syncStatus: const SyncStatusButton(), // required; null = no channel ) ``` **Every prop here is the contract's own** since pin e04afca: entry — the item adapter both kits minted independently and the contract adopted verbatim — plus syncStatus, loading, error and onRetry.

The design-system ThreadCard — one feed post block. ```dart AppThreadCard( author: 'R. Barnes', meta: 'Supervisor · 08-10 08:12 · edited', footerChips: const [AppMetaChip(label: 'Issue')], replyCount: 2, onReply: reply, onOpen: openConversation, body: const [AppThreadSegment('Forklift left in aisle 4 again.')], ) ```

The design-system MessageRow — one message in an open conversation, a bounded block (`Thread.d.ts` `MessageRowProps`). The host renders a conversation as a flat time-ordered column of these with 8px gaps (an AppReplyRun provides the gaps for the reply run). Actions ride the ALWAYS-VISIBLE menu ⋯ on the header line — the actions door — with onLongPress as an accelerator opening the same sheet (exposed to assistive tech through a labeled custom action). A gesture is never the only path to an action: the 2026-08-15 hover-revealed trailing control was undiscoverable to non-technical users, and replying to a reply had no visible entry at all. ```dart AppMessageRow( author: 'R. Barnes', time: '09:41', quote: const AppMessageQuote(author: 'Carla', excerpt: 'Tomorrow…'), onQuoteTap: scrollToQuoted, onReply: targetReply, menu: AppIconButton(glyph: KitGlyph.dots, onPressed: openActionsSheet), onLongPress: openActionsSheet, body: const [AppThreadSegment('Agreed, moving it up.')], ) ```

The replies to one post, bound by a single inline-start rule (`Thread.d.ts` `ReplyRun`). **One level, never a ladder.** The retired `AppThreadReplies` nested a level per depth and produced the staircase this family deleted; this binds the WHOLE reply run at ONE inset regardless of how deep any reply's parent chain runs. Flat rows alone left a conversation reading as N identical blocks with nothing saying which post it is *about* — the rule is what makes "this is the post, these are the replies" legible without reintroducing depth. **The run states itself in words.** label is a quiet head above the rule, and a host that has a count always passes one. The rule and the inset are a *drawn* claim about structure, and a drawn claim is the weakest thing on a screen someone is meeting for the first time — unlabeled, the opening message and its replies are typographically identical, and the only thing separating "the post" from "the chatter" is a 2px line and 20px of inset. Deliberately not solved by inflating the root message's type: the constitution puts emphasis in weight, ink and position, never in size. **The head can be the toggle.** With onToggle set the label becomes the expand/collapse tap target (state contract, DesignTokens.touch floor, a trailing ▸/▾ data-font chevron); collapsed renders the head ALONE — the rule and children are hidden. A run that can hide its replies must say how many it is hiding, so collapse requires label. ```dart AppReplyRun( label: '5 replies', collapsed: closed, onToggle: toggle, children: [for (final r in replies) AppMessageRow(...)], ) ```

The system-event line item — a status change reads as timeline furniture, never a card (`Thread.d.ts` `ThreadEvent`). **An event never truncates** — the text wraps. An event line exists to state what happened, and "Marked this post as r…" states nothing (observed on device 2026-08-16). **An event is not a message**: a host never counts one in a reply count and never renders one inside a reply run as a reply — the count and the rows agree by excluding events from both. Pass pill only when the surface's own chrome does NOT already state the status; an event line under a header wearing ✓ RESOLVED duplicates the encoding. ```dart AppThreadEvent(text: 'Adeyemi marked this resolved', time: '09:41') ```

The design-system ThreadZone — a full-width collapsible zone of SECONDARY thread content (`Thread.d.ts` `ThreadZoneProps`): the drill-through's "More posts on this record (N)". Deliberately NOT an AppReplyRun: the run's rule + inset are a drawn claim of a reply relationship, and this zone's children are full post blocks — no rule, no inset, just a quiet micro-label head with a leading ▸/▾ data-font chevron. With onToggle the head is the expand/collapse tap target (state contract, DesignTokens.touch floor); collapsed renders the head alone. ```dart AppThreadZone( label: 'More posts on this record (2)', collapsed: closed, onToggle: toggle, children: [for (final c in siblings) ...blocks], ) ```

The pinned composer bar — paper behind a block-start structural hairline (`Thread.d.ts` `ThreadComposerBar`). ```dart AppThreadComposerBar( avatar: const AppAvatar(name: 'You', hue: AppAvatarHue.mono), actions: [photoButton, tagButton, const Spacer(), postSlab], child: AppTextArea(label: null, minLines: 2, maxLines: 5, ...), ) ```

The design-system ConversationHeader — the scope stated once at the top of its screen (`Thread.d.ts` `ConversationHeaderProps`). chips render through an AppChipRow whose `+N` pill EXPANDS IN PLACE — the header is the surface where every chip is shown, so the tap reveals the full set as a plain wrap and the pill goes away. The expansion is one-way and ephemeral: there is no collapse-again control, and a remounted header starts collapsed. The record-banner posture (title + description + thumb + onOpen) makes the whole band a quiet open affordance to the record; the menu ⋯ and any tappable chips win the hit test over it. ```dart AppConversationHeader( title: 'Obs #72', description: 'Spill near dock 4 — north apron containment breached.', thumb: AppImage(...), onOpen: openObservation, chips: const [AppMetaChip(label: 'Issue')], menu: rootActionsMenu, ) ```

The chip-zone contract (`Thread.d.ts` `ChipRow`): greedy row packing at a 6px gap, at most maxRows rows, tail overflow collapsed into a `+N` data-font outline pill (AppMetaChip in the file face) sized to the exact hidden count. A chip renders whole or not at all — never clipped mid-label; collapsed chips are absent from paint, semantics, and hit testing. The pill packs like one more chip — inline, or opening a fresh row inside the budget; only when neither placement exists does it evict trailing chips (the count grows instead) — it is never dropped, and a chip that fits alongside it stays visible. Collapsed chips stay INFLATED by design — their state survives a resize, and any ticker or animation inside one keeps running; they are only withheld from paint, semantics, and hit testing. Tests therefore assert visibility with `.hitTestable()` or measured geometry, never a bare finder, which still matches a collapsed chip's widget. The row computes no intrinsic dimensions — packing (and the pill it mints) exists only in a real layout pass — so wrapping it in IntrinsicHeight or IntrinsicWidth throws in debug, exactly as LayoutBuilder does. Mount it in a normally bounded slot (a column, a card body) instead.

The design-system Thread meta chip — a bordered micro-label in a card's metadata row. Inert by default; onSelect (for AppMetaChipVariant.ref and AppMetaChipVariant.file) makes it a real focusable target with the state contract, tap target expanded to DesignTokens.touch. ```dart const AppMetaChip(label: 'Issue') const AppMetaChip(variant: AppMetaChipVariant.fill, glyph: '◈', label: 'Internal') AppMetaChip( variant: AppMetaChipVariant.ref, glyph: '⌖', label: 'OBS-0142', detail: 'Spill near dock', onSelect: openRecord, ) ```

The design-system AttachmentCard — one file attachment, stated in full (`Thread.d.ts` `AttachmentCardProps`). ```dart AppFileAttachmentCard( name: 'aisle-4-walk.pdf', detail: 'PDF · 1.2 MB', onOpen: openFile, ) ```

The design-system ComposeSurface — the focused drafting anatomy (`Thread.d.ts` `ComposeSurfaceProps`): ✕ · optional title · the surface's ONE accent slab up top, the expanding body, and the optionsBar pinned above the keyboard behind a block-start hairline. Host it through showAppComposeSurface, which morphs by window class; the widget itself is a plain body that never knows which host it is in, so a test (or a composed call site) can mount it directly. **Focus is the host's.** The whole point of the surface is that drafting is frictionless, so the body's field should carry `autofocus: true` — the spec says "the host's autofocused field". The scaffold never forces focus on a body it doesn't own. **Draft protection is the host's, via `PopScope`.** The dialog's barrier tap, Esc, and Android (predictive) back all resolve through the hosting route's `maybePop`, so a host with a dirty draft wraps its body in a `PopScope` (or reuses its form machinery) and gates those at once. The surface itself cannot know whether the draft is dirty. **The ✕ is only gated if onClose routes through `maybePop`.** `Navigator.pop()` BYPASSES `PopScope` entirely, so a host that wires the close affordance to `pop()` gets a guarded barrier and a ✕ that discards a dirty draft without asking — the one dismissal route the guard cannot reach on its own. Wire `maybePop()`, as the example does. ```dart showAppComposeSurface<void>( context, builder: (context) => AppComposeScaffold( // maybePop, never pop: pop() skips the PopScope below. onClose: () => Navigator.of(context).maybePop(), title: 'New post', submit: AppButton(variant: AppButtonVariant.slab, label: 'Post', ...), optionsBar: typeSegmentsAndAttachControls, body: PopScope( canPop: !draftIsDirty, onPopInvokedWithResult: (didPop, _) { if (!didPop) confirmDiscard(context); }, child: draftField, // autofocus: true ), ), ) ```