feat: schedule self-drawn long press

Author: Roy Lin

README.md

@@ -294,9 +294,10 @@ independently.
   exposure, published only after host commit, and discarded on rejection
 - retained resize, fractional-scale, damage, occlusion, redraw, delayed
   acknowledgement, and surface-loss replay without changing semantic identity
-- raw pointer, keyboard, Tab-focus, hover, press, cancellation, wheel, stable
-  action bubbling, and reducer dispatch over `PlatformElementId`; failed
-  reducers restore the complete staged interaction session
+- raw pointer, keyboard, Tab-focus, hover, press, cancellation, wheel, and
+  scheduled long-press routing over `PlatformElementId`; event-loop deadlines,
+  release-time fallback, stable action bubbling, and reducer rollback share one
+  staged interaction session
 - an identical-frame fast path that performs no layout, scene, host, or
   presentation work, plus semantic-only commits that skip pixel presentation
 - a software Graphics presenter and interactive shared
@@ -314,7 +315,7 @@ independently.
 | M3 · Layout and Scene | Current | Generic calculator rectangle slice landed; full flex, stacking, redraw scheduling, cross-platform fingerprints, and thin-host presentation remain |
 | M4 · Text and interaction cutover | Planned | Shaping, glyphs, GUI-owned input, IME, accessibility bridges, overlays, and complete calculator scenarios |
 | M5 · Default cutover | Planned | Make self-drawn content the default, then delete the three legacy widget renderers |
-| H0-H5 · Thin platform hosts | H0 complete; H1 in progress | Atomic frames, lifecycle recovery, stable-id raw input/reducer routing, zero-toolkit firewalls, and an interactive calculator landed; a real raw-surface presenter remains |
+| H0-H5 · Thin platform hosts | H0 complete; H1 in progress | Atomic frames, lifecycle recovery, stable-id raw input/reducers, scheduled long press, zero-toolkit firewalls, and an interactive calculator landed; the Graphics raw-surface edge remains |
 | T0-T5 · TSX native authoring | Proposed | Automatic JSX runtime, versioned Node-to-host session, state/event runtime, self-drawn native window, packages, and stable SDK |
 | M6-M8 · React Aria components | Catalog pinned; conformance planned | 51/51 families mapped, eight public parts explicitly missing, Button scene smoke only; full software and three-OS self-drawn evidence required |
 

docs/platform-hosts.md

@@ -212,6 +212,7 @@ src/platform_runtime/
 |- interaction.rs       portable state, actions, changes, and event context
 |- input.rs             pointer capture, hover, press, and cancellation
 |- keyboard_input.rs    keyboard activation, Tab focus, and wheel routing
+|- long_press_input.rs  event-loop deadlines and terminal hold recognition
 |- presenter.rs         raw-surface prepare/publish contract and recorder
 |- reference_presenter.rs
 |                       transactional software Graphics evidence
@@ -241,6 +242,17 @@ The new modules are created beside the legacy directories rather than by
 renaming a control backend. This makes accidental content-widget reuse visible
 and lets each old backend be deleted after its replacement evidence exists.
 
+### Graphics surface capability gate
+
+The pinned Graphics commit `8748fab` currently renders to a
+surface-independent texture and supports deterministic readback; it does not
+yet expose its planned safe window-surface attachment API. GUI therefore does
+not import `wgpu`, create a second device/queue owner, or place raw handles in
+`PlatformHost` records. H1's remaining presenter can land only after Graphics
+provides host-owned attachment, configure/acquire/present, resize/suspend, and
+surface/device recovery while retaining Graphics resource identity. The H1
+firewall pins that dependency and rejects a direct GUI `wgpu` dependency.
+
 ## H0 Transaction and Thread Contract
 
 `PlatformHost` is intentionally thread-affine. The trait does not require
@@ -355,10 +367,14 @@ Landed evidence:
   route through committed hit regions and stable `PlatformElementId` paths;
   ordered action batches retain frame revision, event sequence, bubbling
   target, input context, and static action payload
+- callback-driven and style-only long press exposes the next monotonic host
+  deadline, cancels and restarts across pointer boundaries, falls back to
+  release-time recognition, and routes the terminal action through the same
+  rollback-aware reducer path
 - reducer errors restore the staged interaction state and sequence before the
   event is exposed as successful; successful frame reconciliation preserves
   focused stable ids, while rejected frames do not touch them
-- 20 focused runtime/software tests and three recursive feature/source
+- 26 focused runtime/software tests and four recursive feature/source
   firewall tests pass without any legacy renderer or OS toolkit dependency
 - `self_drawn_calculator` reproduces layout fingerprint
   `16529597026056060935`, scene fingerprint `2100550662756266801`, and
@@ -369,7 +385,8 @@ Remaining before H1 is complete:
 
 - implement the Graphics raw-surface presenter used by H2-H4; the landed
   presenter contract and software implementation deliberately expose no raw
-  handle to components or common host records
+  handle to components or common host records, and pinned Graphics commit
+  `8748fab` must first supply its planned safe surface attachment API
 
 Gates:
 

docs/react-aria-native.md

@@ -123,14 +123,18 @@ The first shared interaction milestone is available in the portable runtime:
 
 - `SelfDrawnWindowRuntime` builds its hit/focus/action index from the atomically
   committed Native IR and layout snapshot. Raw pointer, keyboard, Tab-focus,
-  hover, press, cancellation, wheel, bubbling, and reducer dispatch retain
-  stable `PlatformElementId` identity without importing a widget blueprint or
-  platform content-control runtime.
+  hover, press, cancellation, wheel, scheduled long press, bubbling, and
+  reducer dispatch retain stable `PlatformElementId` identity without
+  importing a widget blueprint or platform content-control runtime.
 - `SelfDrawnActionInvocation` carries the committed frame revision, monotonic
   event sequence, target/current-target pair, modality and input context, plus
   static action payloads. Reducer failure restores the staged interaction
   session and sequence; keyed successful frames reconcile focus and transient
   state by stable id.
+- `next_interaction_deadline_micros` lets a thin OS host schedule its native
+  event-loop timer without exporting a toolkit timer into portable state.
+  Deadline recognition and release-time fallback share the same ordering and
+  reducer rollback, while pointer leave/re-entry cancels and restarts the hold.
 
 - `NativeInputModality` represents keyboard, mouse, touch, pen, virtual, and
   unknown input.
@@ -564,7 +568,7 @@ props:
 | Priority | Area | Required outcome |
 | --- | --- | --- |
 | P0 | Self-drawn component accounting | Keep all 51 React Aria 1.19.0 families in the executable matrix, implement the eight recorded public-part gaps, and require every upstream catalog delta to update code, matrix, tests, and milestones together. |
-| P0 | Shared self-drawn interaction | Extend the landed stable-id pointer, keyboard, Tab-focus, hover, press, cancellation, wheel, bubbling, and reducer path with long press, move/drag, focus-scope restoration, overlay gestures, text editing/IME, and accessibility activation. |
+| P0 | Shared self-drawn interaction | Extend the landed stable-id pointer, keyboard, Tab-focus, hover, press, scheduled generic long press, cancellation, wheel, bubbling, and reducer path with move/drag, collection long-press selection mode, focus-scope restoration, overlay gestures, text editing/IME, and accessibility activation. |
 | P0 | Native input conformance | WinUI's complete 98-case V1 manifest passes real OS automation. Populate the AppKit and GTK4 manifests with platform-run mouse, pen, touch where applicable, keyboard, assistive activation, disabled, cancellation, and keyed-rerender fixtures for every role currently marked native; then close or retain evidence-backed menu/item exceptions. |
 | P1 | Event propagation | Add platform-run conformance fixtures for conditional `Stop`/`Continue` across nested native controls. |
 | P1 | Focus management | Add platform-run conformance fixtures for post-mount `autoFocus`, nested containment, and restoration. |

docs/roadmap.md

@@ -486,17 +486,24 @@ Landed evidence:
 - ordered action batches carry the hit-tested frame revision and monotonic
   event sequence, preserve bubbling current targets and static payloads, and
   restore staged interaction state if an application reducer fails
+- long press exposes a monotonic event-loop deadline, tracks style-only and
+  callback-driven targets, resets across pointer leave/re-entry, recognizes at
+  the deadline or on release as a scheduling fallback, and atomically emits
+  `LongPressEnd`, `PressCancel`, then terminal `LongPress`
 - the shared 410x620 calculator preserves its reviewed layout and scene
   fingerprints, routes eight fake-host events through four reducer actions,
   commits the resulting frames, and reaches display value `10`
-- 20 focused runtime/software tests plus three recursive H1 firewall tests are
+- 26 focused runtime/software tests plus four recursive H1 firewall tests are
   included in `just verify`
 
 Remaining H1 work:
 
 - a Graphics raw-surface presenter implementation for the H2-H4 OS shells;
-  richer text editing, IME, overlay gestures, and component-specific
-  interaction conformance remain explicit M4 and M6-M8 work
+  pinned Graphics commit `8748fab` owns only a surface-independent texture and
+  readback today, so its safe host-owned surface attachment/recovery contract
+  must land before GUI can implement this edge without duplicating `wgpu`
+- richer move/drag, text editing, IME, overlay gestures, and
+  component-specific interaction conformance remain explicit M4 and M6-M8 work
 
 Gates:
 

src/event/press.rs

@@ -1115,13 +1115,7 @@ fn is_number_field_stepper(blueprint: &NativeWidgetBlueprint) -> bool {
 }
 
 fn long_press_threshold(metadata: &BTreeMap<String, String>) -> Duration {
-    ["threshold", "data-long-press-threshold"]
-        .into_iter()
-        .find_map(|name| metadata.get(name))
-        .and_then(|value| value.trim().parse::<u64>().ok())
-        .filter(|value| *value > 0)
-        .map(|value| Duration::from_millis(value.min(60_000)))
-        .unwrap_or(DEFAULT_LONG_PRESS_THRESHOLD)
+    Duration::from_micros(crate::semantic_event::long_press_threshold_micros(metadata))
 }
 
 #[cfg(test)]

src/platform_runtime/events.rs

@@ -111,31 +111,73 @@ where
         let SelfDrawnHostEventOutcome::Input(dispatch) = &mut outcome else {
             return Ok(outcome);
         };
-        let mut stopped_at = None;
-        for invocation in &dispatch.invocations {
-            if stopped_at
-                .as_ref()
-                .is_some_and(|target| invocation.current_target() != target)
-            {
-                continue;
-            }
-            match reducer(invocation) {
-                Ok(SelfDrawnActionPropagation::Continue) => {}
-                Ok(SelfDrawnActionPropagation::Stop) => {
-                    stopped_at = Some(invocation.current_target().clone());
-                }
-                Err(error) => {
-                    self.interaction = interaction;
-                    self.stats = stats;
-                    self.stats.reducer_failures = self.stats.reducer_failures.saturating_add(1);
-                    return Err(error);
-                }
-            }
+        if let Err(error) = reduce_dispatch(dispatch, &mut reducer) {
+            self.interaction = interaction;
+            self.stats = stats;
+            self.stats.reducer_failures = self.stats.reducer_failures.saturating_add(1);
+            return Err(error);
         }
-        dispatch.propagation_stopped_at = stopped_at;
         Ok(outcome)
     }
 
+    /// Earliest monotonic host-clock timestamp at which portable interaction
+    /// state needs another event-loop callback.
+    pub fn next_interaction_deadline_micros(&self) -> Option<u64> {
+        self.interaction.next_interaction_deadline_micros()
+    }
+
+    /// Advances scheduled portable interaction state without synthesizing an
+    /// operating-system input event. Hosts call this at or after the deadline
+    /// returned by [`Self::next_interaction_deadline_micros`]. Each call drains
+    /// one stable pointer deadline; call again while the next deadline is not
+    /// later than the current host timestamp.
+    pub fn advance_interaction_time(
+        &mut self,
+        timestamp_micros: u64,
+    ) -> GuiResult<Option<super::SelfDrawnInputDispatch>> {
+        self.ensure_running()?;
+        let Some(snapshot) = self.committed.as_ref() else {
+            return Ok(None);
+        };
+        let revision = snapshot.revision();
+        let tree = Arc::clone(snapshot.interaction_tree());
+        let dispatch =
+            self.interaction
+                .route_interaction_time(timestamp_micros, revision, &tree)?;
+        if let Some(dispatch) = &dispatch {
+            self.stats.interaction_ticks = self.stats.interaction_ticks.saturating_add(1);
+            self.stats.action_invocations = self
+                .stats
+                .action_invocations
+                .saturating_add(dispatch.invocations.len() as u64);
+        }
+        Ok(dispatch)
+    }
+
+    /// Advances a scheduled interaction deadline and applies its ordered
+    /// action batch transactionally to the portable interaction session.
+    pub fn advance_interaction_time_with_reducer<R>(
+        &mut self,
+        timestamp_micros: u64,
+        mut reducer: R,
+    ) -> GuiResult<Option<super::SelfDrawnInputDispatch>>
+    where
+        R: FnMut(&SelfDrawnActionInvocation) -> GuiResult<SelfDrawnActionPropagation>,
+    {
+        let interaction = self.interaction.clone();
+        let stats = self.stats;
+        let Some(mut dispatch) = self.advance_interaction_time(timestamp_micros)? else {
+            return Ok(None);
+        };
+        if let Err(error) = reduce_dispatch(&mut dispatch, &mut reducer) {
+            self.interaction = interaction;
+            self.stats = stats;
+            self.stats.reducer_failures = self.stats.reducer_failures.saturating_add(1);
+            return Err(error);
+        }
+        Ok(Some(dispatch))
+    }
+
     pub fn poll_event(&mut self) -> GuiResult<Option<SelfDrawnHostEventOutcome>> {
         let Some(event) = self.host.poll_event()? else {
             return Ok(None);
@@ -283,3 +325,29 @@ fn input_window(event: &PlatformInputEvent) -> PlatformWindowId {
         PlatformInputEvent::ModifiersChanged { window, .. } => *window,
     }
 }
+
+fn reduce_dispatch<R>(
+    dispatch: &mut super::SelfDrawnInputDispatch,
+    reducer: &mut R,
+) -> GuiResult<()>
+where
+    R: FnMut(&SelfDrawnActionInvocation) -> GuiResult<SelfDrawnActionPropagation>,
+{
+    let mut stopped_at = None;
+    for invocation in &dispatch.invocations {
+        if stopped_at
+            .as_ref()
+            .is_some_and(|target| invocation.current_target() != target)
+        {
+            continue;
+        }
+        match reducer(invocation)? {
+            SelfDrawnActionPropagation::Continue => {}
+            SelfDrawnActionPropagation::Stop => {
+                stopped_at = Some(invocation.current_target().clone());
+            }
+        }
+    }
+    dispatch.propagation_stopped_at = stopped_at;
+    Ok(())
+}