@userflow-tech/react-native 0.4.5 → 0.5.0

package/src/anchors/AutoAnchorRegistry.ts

@@ -1,7 +1,11 @@
 import type { SemanticRole, SemanticSegment, SiblingDescriptor } from '@userflow-tech/protocol';
 import type { MutableRefObject, RefObject } from 'react';
 
-import { getLiveHostProps, type AnyFiber } from './fiber/fiberInternals';
+import {
+  createCurrentFiberResolver,
+  getLiveHostProps,
+  type AnyFiber,
+} from './fiber/fiberInternals';
 import {
   createLazyHostFiberIndex,
   lookupHostFiber,
@@ -134,10 +138,20 @@ function contentSignature(inst: AutoAnchorInstance): string | undefined {
 }
 
 interface LiveContentCache {
+  /** The fiber of the pair that was committed when read. */
   fiber: AnyFiber;
-  /** Props object identity — React replaces it on every render. */
+  /** That fiber's props object. */
   props: Record<string, unknown> | undefined;
-  childText: string;
+  /** Undefined when the host shows no readable text (the hint stays). */
+  childText: string | undefined;
+}
+
+/** Twin evidence for one registry group, computed once per settle. */
+interface TwinGroup {
+  /** More than one member and none carries a manual id. */
+  unlabelled: boolean;
+  /** How many members show each content signature. */
+  signatures: Map<string, number>;
 }
 
 export class AutoAnchorRegistry {
@@ -148,6 +162,22 @@ export class AutoAnchorRegistry {
   private readonly liveContent = new Map<string, LiveContentCache>();
   private readonly listeners = new Set<AutoAnchorListener>();
   private notifyScheduled = false;
+  /** Settled {@link AutoAnchorInstance.ambiguous} verdicts by instance id. */
+  private readonly ambiguity = new Map<string, boolean>();
+  /**
+   * Groups whose verdicts are out of date: `r:` registry key, `t:` template
+   * path, `m:` manual id. Mounting a list or reading changed row labels marks
+   * a group once; it is settled once, on the next read of a verdict, instead
+   * of being recomputed for every member that changed.
+   */
+  private readonly staleGroups = new Set<string>();
+  /**
+   * Set instead of {@link staleGroups} once that outgrows the registry: with
+   * no flow or element condition reading verdicts, marks from list mounts
+   * would otherwise pile up for the whole session.
+   */
+  private allStale = false;
+  private settling = false;
 
   registerInstance(input: RegisterInstanceInput): { instanceId: string; dispose: () => void } {
     const instanceId = mintInstanceId();
@@ -200,6 +230,7 @@ export class AutoAnchorRegistry {
       childInstanceIds: [],
       ambiguous: false,
     };
+    this.defineAmbiguity(instance);
 
     this.instances.set(instanceId, instance);
     this.addIndex(this.byRegistryKey, input.registryKey, instanceId);
@@ -213,7 +244,7 @@ export class AutoAnchorRegistry {
       if (parent) parent.childInstanceIds.push(instanceId);
     }
 
-    this.recomputeAmbiguity(input.registryKey, templatePath, manualId);
+    this.markStale(instance);
     this.notify();
 
     return {
@@ -272,7 +303,7 @@ export class AutoAnchorRegistry {
       else delete inst.manualId;
     }
     this.refreshManualIndexes(inst, prevIds);
-    this.recomputeAmbiguity(inst.registryKey, inst.templatePath, inst.manualId);
+    this.markStale(inst, prevIds.manualId, prevIds.userflowId, prevIds.testID);
     this.notify();
   }
 
@@ -339,25 +370,32 @@ export class AutoAnchorRegistry {
    *
    * Direct fiber pointers are preferred; the scan-root index is built lazily
    * and only if some instance cannot reach its fiber that way (Paper release
-   * builds, mainly), then reused for the rest of the pass.
+   * builds, mainly), then reused for the rest of the pass. Finding which fiber
+   * of each pair is committed walks to the root; the pass shares one walk per
+   * ancestor across every instance.
    *
    * Silent — does not notify listeners.
    */
   refreshLiveContent(instances?: AutoAnchorInstance[]): void {
     const list = instances ?? this.allInstances();
     const getIndex = createLazyHostFiberIndex();
+    const resolveCurrent = createCurrentFiberResolver();
     const seen = new Set<string>();
     for (const inst of list) {
       if (seen.has(inst.instanceId)) continue;
       seen.add(inst.instanceId);
-      this.refreshOneLiveContent(inst, getIndex);
+      this.refreshOneLiveContent(inst, getIndex, resolveCurrent);
     }
   }
 
-  private refreshOneLiveContent(inst: AutoAnchorInstance, getIndex: () => HostFiberIndex): void {
+  private refreshOneLiveContent(
+    inst: AutoAnchorInstance,
+    getIndex: () => HostFiberIndex,
+    resolveCurrent: (fiber: AnyFiber) => AnyFiber,
+  ): void {
     let fiber: AnyFiber | null = null;
     try {
-      fiber = lookupHostFiber(getIndex, inst.ref.current);
+      fiber = lookupHostFiber(getIndex, inst.ref.current, resolveCurrent);
     } catch {
       fiber = null;
     }
@@ -370,12 +408,17 @@ export class AutoAnchorRegistry {
       props = undefined;
     }
 
+    // Same committed fiber and same props object means nothing was committed
+    // here since the last read, so the subtree walk would return what we
+    // already have. A commit that re-renders this host or anything inside it
+    // makes the other fiber of the pair current, even when the host keeps its
+    // props object. Both only change at commit, unlike Fabric's
+    // `canonical.currentProps`, which is written during render and stays the
+    // same object when only a child changed. Matters because resolution polls
+    // this for every registered instance.
     const cached = this.liveContent.get(inst.instanceId);
-    // Same fiber and same props object means no re-render since the last read,
-    // so the subtree walk would return what we already have. Matters because
-    // resolution polls this for every registered instance.
     if (cached && cached.fiber === fiber && props !== undefined && cached.props === props) {
-      inst.childText = cached.childText;
+      if (cached.childText !== undefined) inst.childText = cached.childText;
       return;
     }
 
@@ -391,17 +434,14 @@ export class AutoAnchorRegistry {
       live = undefined;
     }
 
-    if (live) {
-      const changed = inst.childText !== live;
+    // A host with no readable text is cached too, so it is not walked again
+    // until it re-renders; its build-time hint stays.
+    this.liveContent.set(inst.instanceId, { fiber, props, childText: live });
+    if (live && inst.childText !== live) {
       inst.childText = live;
-      this.liveContent.set(inst.instanceId, { fiber, props, childText: live });
       // Text is what separates helper-rendered twins, so the group's ambiguity
       // verdict is only trustworthy once it has been read.
-      if (changed) this.recomputeAmbiguity(inst.registryKey, inst.templatePath, inst.manualId);
-      return;
-    }
-    if (cached && cached.fiber !== fiber) {
-      this.liveContent.delete(inst.instanceId);
+      this.markStale(inst);
     }
   }
 
@@ -421,7 +461,7 @@ export class AutoAnchorRegistry {
       inst.manualId = liveTestID;
     }
     this.refreshManualIndexes(inst, prev);
-    this.recomputeAmbiguity(inst.registryKey, inst.templatePath, inst.manualId);
+    this.markStale(inst, prev.manualId, prev.userflowId, prev.testID);
   }
 
   subscribe(listener: AutoAnchorListener): () => void {
@@ -462,6 +502,9 @@ export class AutoAnchorRegistry {
     this.byManualId.clear();
     this.byTemplatePath.clear();
     this.liveContent.clear();
+    this.ambiguity.clear();
+    this.staleGroups.clear();
+    this.allStale = false;
     this.notifyScheduled = false;
     nextInstanceSeq = 1;
   }
@@ -483,13 +526,14 @@ export class AutoAnchorRegistry {
 
     this.instances.delete(instanceId);
     this.liveContent.delete(instanceId);
+    this.ambiguity.delete(instanceId);
     this.removeIndex(this.byRegistryKey, inst.registryKey, instanceId);
     this.removeIndex(this.byTemplatePath, inst.templatePath, instanceId);
     if (inst.manualId) this.removeIndex(this.byManualId, inst.manualId, instanceId);
     if (inst.userflowId) this.removeIndex(this.byManualId, inst.userflowId, instanceId);
     if (inst.testID) this.removeIndex(this.byManualId, inst.testID, instanceId);
 
-    this.recomputeAmbiguity(inst.registryKey, inst.templatePath, inst.manualId);
+    this.markStale(inst);
     this.notify();
   }
 
@@ -533,29 +577,116 @@ export class AutoAnchorRegistry {
     return false;
   }
 
+  /**
+   * Back {@link AutoAnchorInstance.ambiguous} with a verdict that is settled on
+   * read, so callers holding an instance always see the current value.
+   */
+  private defineAmbiguity(inst: AutoAnchorInstance): void {
+    const id = inst.instanceId;
+    Object.defineProperty(inst, 'ambiguous', {
+      configurable: true,
+      enumerable: true,
+      get: () => {
+        this.settleAmbiguity();
+        return this.ambiguity.get(id) ?? false;
+      },
+      set: (value: boolean) => {
+        this.ambiguity.set(id, value);
+      },
+    });
+  }
+
+  /** Every group `inst` belongs to, plus ids it was indexed under before a change. */
+  private markStale(inst: AutoAnchorInstance, ...previousIds: Array<string | undefined>): void {
+    if (this.allStale) return;
+    this.staleGroups.add(`r:${inst.registryKey}`);
+    this.staleGroups.add(`t:${inst.templatePath}`);
+    for (const id of [inst.manualId, inst.userflowId, inst.testID, ...previousIds]) {
+      if (id) this.staleGroups.add(`m:${id}`);
+    }
+    // Settling every instance is linear in the registry, so past this size
+    // tracking groups no longer saves work.
+    if (this.staleGroups.size > this.instances.size) {
+      this.allStale = true;
+      this.staleGroups.clear();
+    }
+  }
+
+  private groupIds(groupKey: string): Set<string> | undefined {
+    const value = groupKey.slice(2);
+    if (groupKey.startsWith('r:')) return this.byRegistryKey.get(value);
+    if (groupKey.startsWith('t:')) return this.byTemplatePath.get(value);
+    return this.byManualId.get(value);
+  }
+
   /**
    * Instances sharing a template path are only twins while they look alike.
    * Four rows from one `field()` helper are indistinguishable at register time
    * and separate once their labels are read, so ambiguity is decided on
    * content, not on the shared path alone. An instance stays ambiguous when it
    * carries no content of its own, or when a peer carries the same content.
+   * An instance with a manual id is ambiguous only when another shares the id.
+   *
+   * Each stale group is settled once, in time linear in its size: recomputing
+   * a whole group for every member that changed made a list whose labels all
+   * changed cost the cube of its length.
    */
-  private recomputeAmbiguity(registryKey: string, templatePath: string, manualId?: string): void {
-    const mark = (list: AutoAnchorInstance[]) => {
-      for (const i of list) {
-        i.ambiguous =
-          this.isTwinWithin(i, list) ||
-          (i.manualId ? this.getInstancesByManualId(i.manualId).length > 1 : false);
+  private settleAmbiguity(): void {
+    if ((this.staleGroups.size === 0 && !this.allStale) || this.settling) return;
+    this.settling = true;
+    try {
+      const affected = new Set<string>(this.allStale ? this.instances.keys() : []);
+      for (const groupKey of this.staleGroups) {
+        const ids = this.groupIds(groupKey);
+        if (ids) for (const id of ids) affected.add(id);
       }
-    };
-    mark(this.getInstancesByRegistryKey(registryKey));
-    mark(this.getInstancesByTemplatePath(templatePath));
-    if (manualId) {
-      const list = this.getInstancesByManualId(manualId);
-      for (const i of list) i.ambiguous = list.length > 1;
+      this.staleGroups.clear();
+      this.allStale = false;
+
+      const twinGroups = new Map<string, TwinGroup>();
+      for (const id of affected) {
+        const inst = this.instances.get(id);
+        if (!inst) continue;
+        this.ambiguity.set(id, this.computeAmbiguous(inst, twinGroups));
+      }
+    } finally {
+      this.settling = false;
     }
   }
 
+  private computeAmbiguous(inst: AutoAnchorInstance, twinGroups: Map<string, TwinGroup>): boolean {
+    if (inst.manualId) return (this.byManualId.get(inst.manualId)?.size ?? 0) > 1;
+    return (
+      this.isTwinInGroup(inst, `r:${inst.registryKey}`, twinGroups) ||
+      this.isTwinInGroup(inst, `t:${inst.templatePath}`, twinGroups)
+    );
+  }
+
+  /** {@link isTwinWithin} against a whole registry group, with the group's evidence memoized. */
+  private isTwinInGroup(
+    inst: AutoAnchorInstance,
+    groupKey: string,
+    twinGroups: Map<string, TwinGroup>,
+  ): boolean {
+    let group = twinGroups.get(groupKey);
+    if (!group) {
+      const members = this.idsToInstances(this.groupIds(groupKey));
+      const signatures = new Map<string, number>();
+      for (const member of members) {
+        const sig = contentSignature(member);
+        if (sig) signatures.set(sig, (signatures.get(sig) ?? 0) + 1);
+      }
+      group = {
+        unlabelled: members.length > 1 && members.every((member) => !member.manualId),
+        signatures,
+      };
+      twinGroups.set(groupKey, group);
+    }
+    if (!group.unlabelled) return false;
+    const sig = contentSignature(inst);
+    return !sig || (group.signatures.get(sig) ?? 0) > 1;
+  }
+
   private addIndex(map: Map<string, Set<string>>, key: string, instanceId: string): void {
     let set = map.get(key);
     if (!set) {

package/src/anchors/animationFrame.ts

@@ -1,13 +1,21 @@
 /**
  * Shared requestAnimationFrame hub so multiple surfaces never stack loops.
  * Mirrors web userflowjs `util/animation-frame.tsx`.
+ *
+ * Paused while the app is not active. In bridgeless React Native,
+ * `requestAnimationFrame` is a 0 ms timer, and once the app is backgrounded
+ * iOS fires timers from an NSTimer instead of the display link, so a loop that
+ * kept going would spin as fast as the JS thread allows.
  */
+import { isAppActive, subscribeAppActive } from './appActive';
 
 type Callback = () => void;
 
 const callbacks: Callback[] = [];
 let rafHandle: number | ReturnType<typeof setTimeout> | null = null;
 let active = false;
+let appActive = true;
+let unsubscribeAppActive: (() => void) | null = null;
 
 /**
  * `callback` runs on every animation frame. Starts the shared loop when the
@@ -18,6 +26,7 @@ export function addAnimationFrameCallback(callback: Callback): void {
   callbacks.push(callback);
   if (callbacks.length === 1) {
     active = true;
+    watchAppState();
     requestNext();
   }
 }
@@ -33,6 +42,7 @@ export function removeAnimationFrameCallback(callback: Callback): void {
   if (callbacks.length === 0) {
     active = false;
     cancelPending();
+    unwatchAppState();
   }
 }
 
@@ -41,6 +51,7 @@ export function resetAnimationFrameForTests(): void {
   callbacks.length = 0;
   active = false;
   cancelPending();
+  unwatchAppState();
 }
 
 /** Test helper — number of active subscribers. */
@@ -62,8 +73,27 @@ function onAnimationFrame(): void {
   requestNext();
 }
 
+function watchAppState(): void {
+  if (unsubscribeAppActive) return;
+  appActive = isAppActive();
+  unsubscribeAppActive = subscribeAppActive((next) => {
+    appActive = next;
+    if (!next) {
+      cancelPending();
+    } else if (rafHandle == null) {
+      requestNext();
+    }
+  });
+}
+
+function unwatchAppState(): void {
+  unsubscribeAppActive?.();
+  unsubscribeAppActive = null;
+  appActive = true;
+}
+
 function requestNext(): void {
-  if (!active) return;
+  if (!active || !appActive) return;
   const raf =
     typeof globalThis.requestAnimationFrame === 'function'
       ? globalThis.requestAnimationFrame.bind(globalThis)

package/src/anchors/appActive.ts

@@ -0,0 +1,63 @@
+import { AppState } from 'react-native';
+
+/**
+ * Foreground signal for the anchoring loops (animation-frame tracking and the
+ * tooltip target search).
+ *
+ * Anything other than `background` / `inactive` counts as active, including
+ * `unknown` before the first native report. Hosts or test doubles without
+ * `AppState` always read as active and never notify.
+ */
+
+type AppStateLike = {
+  currentState?: unknown;
+  addEventListener?: (
+    type: 'change',
+    handler: (state: unknown) => void,
+  ) => { remove: () => void } | undefined;
+};
+
+function appState(): AppStateLike | null {
+  const candidate = AppState as AppStateLike | undefined;
+  return candidate && typeof candidate === 'object' ? candidate : null;
+}
+
+function isActiveState(state: unknown): boolean {
+  return state !== 'background' && state !== 'inactive';
+}
+
+/** Whether the app is in the foreground right now. */
+export function isAppActive(): boolean {
+  try {
+    return isActiveState(appState()?.currentState);
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * `listener(active)` runs when the app moves between foreground and anything
+ * else. Repeated reports of the same side are dropped. Returns an unsubscribe.
+ */
+export function subscribeAppActive(listener: (active: boolean) => void): () => void {
+  const state = appState();
+  if (!state || typeof state.addEventListener !== 'function') return () => {};
+  let active = isAppActive();
+  try {
+    const subscription = state.addEventListener('change', (next) => {
+      const nextActive = isActiveState(next);
+      if (nextActive === active) return;
+      active = nextActive;
+      listener(nextActive);
+    });
+    return () => {
+      try {
+        subscription?.remove();
+      } catch {
+        // Teardown is best-effort.
+      }
+    };
+  } catch {
+    return () => {};
+  }
+}

package/src/anchors/elementConditionEvaluator.ts

@@ -7,7 +7,7 @@ import { decodeMobileAutoData, type FlowConditionFragment } from '@userflow-tech
 
 import { anchorChangeTicker } from './anchorChangeTicker';
 import { elementTapMonitor } from './elementTapMonitor';
-import { fiberIsUnder, tapPathDisabled } from './elementTargetMatch';
+import { fiberBearingAnchorId, fiberIsUnder, tapPathDisabled } from './elementTargetMatch';
 import {
   resolveElementTargets,
   tapMayHitSelector,
@@ -188,22 +188,39 @@ function trackClick(
   const subscription = {
     unsubscribe: (): void => {},
   };
+  const latch = (): void => {
+    latched = true;
+    report(valueWhenOccurred, { immediate: true });
+    subscription.unsubscribe();
+    stopWatchingResolution();
+  };
+
   subscription.unsubscribe = elementTapMonitor.subscribe((tap) => {
     if (latched) return;
     if (!tapMayHitSelector(condition.selector, tap)) return;
-    const resolution = resolveElementTargets(condition.selector);
-    if (resolution.status !== 'found') return;
 
-    const matched = resolution.targets.find(
-      (target) => target.fiber != null && fiberIsUnder(tap.targetFiber, target.fiber),
-    );
-    if (!matched?.fiber) return;
-    if (tapPathDisabled(tap.targetFiber, matched.fiber)) return;
+    const resolution = resolveElementTargets(condition.selector);
+    if (resolution.status === 'found') {
+      const matched = resolution.targets.find(
+        (target) => target.fiber != null && fiberIsUnder(tap.targetFiber, target.fiber),
+      );
+      if (!matched?.fiber) return;
+      if (tapPathDisabled(tap.targetFiber, matched.fiber)) return;
+      latch();
+      return;
+    }
 
-    latched = true;
-    report(valueWhenOccurred, { immediate: true });
-    subscription.unsubscribe();
-    stopWatchingResolution();
+    // The press may already have navigated away, so the live scan is absent.
+    // The fiber captured at touch start still carries the manual id. This is
+    // only the fallback: a target that is still on screen keeps the registry
+    // and prop-tier precedence of the live scan.
+    if (resolution.status !== 'absent') return;
+    if ((condition.selector?.type as string | null) === 'AUTO') return;
+    const anchorId = resolveManualAnchorId(condition.selector?.css);
+    const capturedHost = anchorId ? fiberBearingAnchorId(tap.targetFiber, anchorId) : null;
+    if (!capturedHost) return;
+    if (tapPathDisabled(tap.targetFiber, capturedHost)) return;
+    latch();
   });
 
   return () => {

package/src/anchors/elementTapMonitor.ts

@@ -6,10 +6,14 @@
  * tooltip target-press monitor uses. The host fiber is the one captured at
  * touch start, before the press's setState commits a new tree.
  *
+ * A touch that gesture-handler cancels is handed off instead of dropped: the
+ * same fiber is emitted if that handler later ends as a tap.
+ *
  * With no subscribers the monitor stores nothing, so the bridge can skip the
  * fiber lookup entirely.
  */
 import type { AnyFiber } from './fiber/fiberInternals';
+import { gestureHandlerHandoff } from './gestureHandlerHandoff';
 import { type TouchIdentifier, type TouchPoint, withinTapSlop } from './targetPressMonitor';
 
 export interface ElementTap {
@@ -25,6 +29,7 @@ interface TouchStart extends TouchPoint {
 export class ElementTapMonitor {
   private readonly listeners = new Set<ElementTapListener>();
   private readonly touchStarts = new Map<TouchIdentifier, TouchStart>();
+  private readonly handoffStops = new Map<TouchIdentifier, () => void>();
 
   get subscriberCount(): number {
     return this.listeners.size;
@@ -36,10 +41,25 @@ export class ElementTapMonitor {
       this.listeners.delete(listener);
       if (this.listeners.size === 0) {
         this.touchStarts.clear();
+        this.dropHandoffs();
       }
     };
   }
 
+  /** Fingers with a recorded start that have not ended, cancelled, or been handed off. */
+  inProgressIdentifiers(): TouchIdentifier[] {
+    return [...this.touchStarts.keys()];
+  }
+
+  hasTouch(identifier: TouchIdentifier): boolean {
+    return this.touchStarts.has(identifier);
+  }
+
+  /** Fiber captured at touch start, or null when this finger is not in progress. */
+  startFiber(identifier: TouchIdentifier): AnyFiber | null {
+    return this.touchStarts.get(identifier)?.targetFiber ?? null;
+  }
+
   handleTouchStart(
     identifier: TouchIdentifier,
     pageX: number,
@@ -63,31 +83,69 @@ export class ElementTapMonitor {
     if (!start || this.listeners.size === 0 || !start.targetFiber) return;
     if (!withinTapSlop(start, { pageX, pageY })) return;
 
-    const tap: ElementTap = { targetFiber: start.targetFiber };
-    for (const listener of this.listeners) {
-      // One condition's failure must not cost the others this tap, or abort
-      // the bridge's handling of the event's remaining touches.
-      try {
-        listener(tap);
-      } catch {
-        // The condition stays at its current value.
-      }
-    }
+    this.emit(start.targetFiber);
+  }
+
+  /**
+   * Gesture-handler cancelled this finger. Forget the RN touch and emit the
+   * start fiber if that handler later ends as a tap. A start with no fiber
+   * cannot latch, so it is dropped.
+   */
+  handOffTouch(identifier: TouchIdentifier, handlerTags: readonly number[]): void {
+    const start = this.touchStarts.get(identifier);
+    if (!start) return;
+    this.touchStarts.delete(identifier);
+    this.handoffStops.get(identifier)?.();
+    if (!start.targetFiber || handlerTags.length === 0 || this.listeners.size === 0) return;
+    const fiber = start.targetFiber;
+    const stop = gestureHandlerHandoff.track({
+      identifier,
+      pageX: start.pageX,
+      pageY: start.pageY,
+      handlerTags,
+      onResolve: () => this.emit(fiber),
+    });
+    this.handoffStops.set(identifier, () => {
+      stop();
+      this.handoffStops.delete(identifier);
+    });
   }
 
   /** Drop in-progress gesture(s). Omit `identifier` to clear every finger. */
   cancelTouch(identifier?: TouchIdentifier): void {
     if (identifier == null) {
       this.touchStarts.clear();
+      this.dropHandoffs();
       return;
     }
     this.touchStarts.delete(identifier);
+    this.handoffStops.get(identifier)?.();
   }
 
   /** Test helper. */
   resetForTests(): void {
     this.listeners.clear();
     this.touchStarts.clear();
+    this.dropHandoffs();
+  }
+
+  private emit(targetFiber: AnyFiber): void {
+    if (this.listeners.size === 0) return;
+    const tap: ElementTap = { targetFiber };
+    for (const listener of this.listeners) {
+      // One condition's failure must not cost the others this tap, or abort
+      // the bridge's handling of the event's remaining touches.
+      try {
+        listener(tap);
+      } catch {
+        // The condition stays at its current value.
+      }
+    }
+  }
+
+  private dropHandoffs(): void {
+    for (const stop of this.handoffStops.values()) stop();
+    this.handoffStops.clear();
   }
 }