@keepsnappy/react-native 0.1.0-alpha.16 → 0.1.0-alpha.17

package/js/babel-transformer.js

@@ -68,20 +68,27 @@ module.exports = {
         : args.src;
       args = { ...args, src: inlineEnv(src) };
     }
+    const root = args.options?.projectRoot ?? projectRoot ?? process.cwd();
+    // A client file built without its stamps keys its components to an ancestor's: never silently.
+    const skipped = error => console.warn(`KeepSnappy: component stamps skipped for ${path.relative(root, file)}: ${String(error)}`);
     let stamps;
     try {
       stamps = require('./component-stamps.js').instrumentation(
-        original.src, file, args.options?.projectRoot ?? projectRoot ?? process.cwd(), clientPackages, file === entryFile ? 1 : 0,
+        original.src, file, root, clientPackages, file === entryFile ? 1 : 0,
       );
-    } catch { return upstream.transform(args); }
+    } catch (error) { skipped(error); return upstream.transform(args); }
     if (!stamps) return upstream.transform(args);
     const complete = result => { stamps.complete(); return result; };
-    const passthrough = () => { stamps.complete(true); return upstream.transform(args); };
+    const passthrough = error => {
+      skipped(error);
+      stamps.complete(true);
+      return upstream.transform(args);
+    };
     try {
       const result = upstream.transform({ ...args, plugins: [stamps.plugin, ...(args.plugins ?? [])] });
       return result && typeof result.then === 'function'
         ? result.then(complete, passthrough) : complete(result);
-    } catch { return passthrough(); }
+    } catch (error) { return passthrough(error); }
   },
   getCacheKey(...args) {
     const base =

package/js/component-stamps.js

@@ -119,6 +119,15 @@ const anonymousRender = (node, t) => {
     && !node.id && !node.async && !node.generator && returnsJSX(node.body, t);
 };
 
+// A plugin that ran first (React Compiler listed in the app's babel.config.js) may put back regenerated nodes without
+// `loc`; the line then comes from the declaration in the source.
+const declarationLine = (src, id, statement, lineOffset) => {
+  const line = id.loc?.start?.line ?? statement.loc?.start?.line;
+  if (typeof line === 'number') return Math.max(1, line - lineOffset);
+  const match = new RegExp(`^[ \\t]*(?:export[ \\t]+(?:default[ \\t]+)?)?(?:async[ \\t]+)?(?:function\\*?|class|const)[ \\t]+${id.name}\\b`, 'm').exec(src);
+  return match ? src.slice(0, match.index).split('\n').length : 1;
+};
+
 function instrumentation(src, filename, projectRoot, clientPackages, lineOffset = 0) {
   const client = clientFile(filename, projectRoot, clientPackages);
   if (!client) return null;
@@ -166,13 +175,19 @@ function instrumentation(src, filename, projectRoot, clientPackages, lineOffset
           const stamps = [];
           for (const id of found) {
             const componentName = id === defaultId ? 'default' : id.name;
-            const key = componentKey(componentName, client.file);
-            components.push({ key, name: componentName, file: client.file, line: Math.max(1, id.loc.start.line - lineOffset) });
-            const name = () => t.identifier(id.name);
-            const typeIs = value => t.binaryExpression('===', t.unaryExpression('typeof', name()), t.stringLiteral(value));
-            stamps.push(t.ifStatement(t.logicalExpression('||', typeIs('function'), t.logicalExpression('&&',
-              t.binaryExpression('!==', name(), t.nullLiteral()), typeIs('object'))),
-            t.expressionStatement(t.assignmentExpression('=', t.memberExpression(name(), t.identifier('__ks')), t.stringLiteral(key)))));
+            // One declaration that cannot be stamped must not cost the file its other stamps.
+            try {
+              const key = componentKey(componentName, client.file);
+              const line = declarationLine(src, id, statement.node, lineOffset);
+              const name = () => t.identifier(id.name);
+              const typeIs = value => t.binaryExpression('===', t.unaryExpression('typeof', name()), t.stringLiteral(value));
+              stamps.push(t.ifStatement(t.logicalExpression('||', typeIs('function'), t.logicalExpression('&&',
+                t.binaryExpression('!==', name(), t.nullLiteral()), typeIs('object'))),
+              t.expressionStatement(t.assignmentExpression('=', t.memberExpression(name(), t.identifier('__ks')), t.stringLiteral(key)))));
+              components.push({ key, name: componentName, file: client.file, line });
+            } catch (error) {
+              console.warn(`KeepSnappy: could not stamp ${componentName} in ${client.file}: ${String(error)}`);
+            }
           }
           if (stamps.length) statement.insertAfter(stamps);
         }

package/js/sdk/core.ts

@@ -473,8 +473,10 @@ interface OpenSampleState {
 // - so does a window that starts within OPEN_SAMPLE_TOLERANCE_MS of the close sample (restarted key);
 // - a window detected long after its t0 (a screen window opened by a press, seen after the new screen rendered) gets
 //   none: its bound is the press's open sample;
-// - else the sampler is asked to sample on its own thread.
-const openSampleFor = (id: number, t0: number): OpenSampleState => {
+// - else the sampler is asked to sample on its own thread. A press always is, however late its touch reached JS: with
+//   no window before it (after a GC command, the background or the flush) the sample before the touch can be seconds
+//   old, so its own sample, a negative lead past t0, is the closer bound.
+const openSampleFor = (id: number, t0: number, press: boolean): OpenSampleState => {
   const none = { openRecord: null, openPending: null };
   if (samplerState.mode === 'off') {
     return none;
@@ -487,7 +489,7 @@ const openSampleFor = (id: number, t0: number): OpenSampleState => {
   ) {
     return { openRecord: lastClose.record, openPending: null };
   }
-  if (now() - samplerState.offsetMs - t0Native > OPEN_SAMPLE_TOLERANCE_MS) {
+  if (!press && now() - samplerState.offsetMs - t0Native > OPEN_SAMPLE_TOLERANCE_MS) {
     return none;
   }
   const reason = `window-start:${id}`;
@@ -938,7 +940,14 @@ const routeToBackground = (record: CommitRecord) => {
 
 // Segments written and not yet listed for upload (listed at the next flush).
 const pendingStreamFiles: WrittenFile[] = [];
-// A segment is cut at this many commits even between flushes, so a long stretch outside a run stays bounded.
+// What the run lost since the last flush, which reports it. Commit-stream segments that failed to write are missing data
+// (the backend splits work by cause from them). Kept React exports dropped at the run cap or not written, and stream fibers
+// past a segment's cap, leave every measured value complete: counted notes only.
+const runLosses = { stream: 0, exportsCapped: 0, exportsUnwritten: 0, streamFibersDropped: 0 };
+export const setStreamFiberCapForTest = (fibers: number) => commitStream.setMaxFibers(fibers);
+// A segment is cut at this many commits even between flushes, so a long stretch outside a run stays bounded. In a run
+// the cut waits while a window is open (no file I/O inside a measured window, REQ-MEAS-23): every window ends at the
+// flush, which cuts it, and a segment past its fiber cap keeps only the commits' facts.
 const MAX_SEGMENT_COMMITS = 5000;
 
 const cutStream = () => {
@@ -954,7 +963,10 @@ const cutStream = () => {
   }
   if (path) {
     pendingStreamFiles.push({ name: segment.name, windows: [], bytes: segment.json.length });
+  } else if (inRun()) {
+    runLosses.stream++;
   }
+  if (inRun()) runLosses.streamFibersDropped += segment.fibersDropped;
   perfLog(`stream ${JSON.stringify({ name: segment.name, commits: segment.commits, bytes: segment.json.length, fibersDropped: segment.fibersDropped, written: path !== null })}`);
 };
 
@@ -998,7 +1010,7 @@ const start = (name: string, options: StartOptions = {}) => {
   const statsStart = readHermesStats();
   const id = nextWindowId++;
   const startT = options.at ?? now();
-  const openSample = openSampleFor(id, startT);
+  const openSample = openSampleFor(id, startT, options.kind === 'press');
   const window: MarkerWindow = {
     id,
     key,
@@ -1301,7 +1313,7 @@ const onCommitFiberRoot = (rendererId: number, root: FiberRoot) => {
   // Work no open window judges is the background of its source: pushes, and loops of earlier actions or of the launch.
   record.background = record.judged ? null : backgroundSource(causes);
   commitStream.noteCommit({ seq, t: t0, renderMs, causes, fibers: exported?.fibers ?? null, updaters: profile?.updaters ?? null });
-  if (commitStream.size() >= MAX_SEGMENT_COMMITS) {
+  if (commitStream.size() >= MAX_SEGMENT_COMMITS && !(inRun() && openWindows.size > 0)) {
     cutStream();
   }
   recordCommit(record);
@@ -1525,7 +1537,12 @@ interface PendingExport {
 }
 
 // React exports held until flush (inside a run), capped like a window's.
-const MAX_PENDING_EXPORT_FIBERS = 400000;
+let maxPendingExportFibers = 400000;
+export const setPendingExportCapForTest = (fibers: number) => {
+  const previous = maxPendingExportFibers;
+  maxPendingExportFibers = fibers;
+  return previous;
+};
 const pendingExports: PendingExport[] = [];
 let pendingExportFibers = 0;
 
@@ -1546,7 +1563,8 @@ const writeReactExport = (window: MarkerWindow) => {
     truncated: window.exportTruncated,
   };
   if (inRun()) {
-    if (pendingExportFibers + window.exportFibers > MAX_PENDING_EXPORT_FIBERS) {
+    if (pendingExportFibers + window.exportFibers > maxPendingExportFibers) {
+      if (settings.diag || budgetBreaks.has(window.id)) runLosses.exportsCapped++;
       return { ...base, deferred: true, dropped: true };
     }
     pendingExports.push({
@@ -1623,6 +1641,7 @@ const writeDeferredFiles = (): ArtifactEntry[] => {
     } catch (error) {
       result = { error: String(error) };
     }
+    if (!result.path && (settings.diag || budgetBreaks.has(pending.window))) runLosses.exportsUnwritten++;
     perfLog(
       `rexport ${JSON.stringify({ name: pending.name, commits: pending.commits.length, fibers: pending.fibers, ...result })}`,
     );
@@ -2127,6 +2146,16 @@ const flushOnce = async (ack: string | undefined) => {
   } catch (error) {
     perfLog(`artifacts failed ${String(error)}`);
   }
+  if (runToken !== null) {
+    if (runLosses.stream > 0) {
+      if (status === 'ok') status = 'error';
+      detail += ` lost stream=${runLosses.stream}`;
+    }
+    if (runLosses.exportsCapped > 0) detail += ` exports capped=${runLosses.exportsCapped}`;
+    if (runLosses.exportsUnwritten > 0) detail += ` exports unwritten=${runLosses.exportsUnwritten}`;
+    if (runLosses.streamFibersDropped > 0) detail += ` stream fibersDropped=${runLosses.streamFibersDropped}`;
+  }
+  Object.assign(runLosses, { stream: 0, exportsCapped: 0, exportsUnwritten: 0, streamFibersDropped: 0 });
   try {
     await sendEarlierArtifacts(deadline);
   } catch (error) {

package/js/sdk/fiber.ts

@@ -230,9 +230,11 @@ export const noteMounted = (fiber: Fiber) => {
   const props = propsOf(fiber);
   if (props && props.route !== undefined) {
     noteRoute(fiber, props);
+    // React Navigation core's SceneView: the route's `screen` config and `clearOptions`. Expo Router 58's fork no
+    // longer passes `getState`, so that prop does not mark it. Headers and layouts get `route` without these.
     const route = props.route as { key?: unknown } | null;
     if (typeof route?.key === 'string' &&
-      typeof props.getState === 'function' &&
+      props.screen !== null && typeof props.screen === 'object' &&
       typeof props.clearOptions === 'function') {
       scenes.set(route.key, fiber);
     }
@@ -582,9 +584,11 @@ export interface TargetPlace {
   manySiblings?: number;
 }
 
+// A scroll view's own responder handlers (RN sets them on RCTScrollView) serve the scroll gesture, so a scroll view is
+// never the tap's region: the pressables inside it are.
 const actionableFiber = (f: Fiber) => {
   const props = propsOf(f);
-  return props !== null && isActionable(props);
+  return props !== null && isActionable(props) && !isScrollHost(f);
 };
 const isListCell = (f: Fiber) => {
   if (!isComponentTag(f.tag) || clientKeyOf(f) !== null) return false;
@@ -594,6 +598,69 @@ const isListCell = (f: Fiber) => {
     (typeof p.getRenderedItem === 'function' && 'itemKey' in p));
 };
 
+// React elements a component received in its props (children or any other prop), arrays included, by their props
+// object: the fiber React creates from an element keeps that object as its props.
+// Props objects do not change after their render, so the result is kept per object.
+const MAX_PASSED_ELEMENTS = 64;
+const NO_ELEMENTS: ReadonlySet<unknown> = new Set();
+const passedByProps = new WeakMap<object, ReadonlySet<unknown>>();
+const passedElementProps = (props: Props): ReadonlySet<unknown> => {
+  const known = passedByProps.get(props);
+  if (known) return known;
+  const found = new Set<unknown>();
+  try {
+    const stack: unknown[] = Object.values(props);
+    let seen = 0;
+    while (stack.length > 0 && seen++ < MAX_PASSED_ELEMENTS) {
+      const value = stack.pop();
+      if (Array.isArray(value)) {
+        stack.push(...value.slice(0, MAX_PASSED_ELEMENTS));
+      } else if (value !== null && typeof value === 'object' && '$$typeof' in value && 'props' in value) {
+        found.add((value as { props: unknown }).props);
+      }
+    }
+  } catch {
+    // A prop that throws on read (a revoked Proxy) carries no element we can match.
+  }
+  const result = found.size === 0 ? NO_ELEMENTS : found;
+  passedByProps.set(props, result);
+  return result;
+};
+
+// A client component between the target and the component that placed it passes the press through: it received a
+// press handler from its owner (a button wrapper forwarding `onPress`), or it renders an element it received in its
+// props around the target (a layout or animation wrapper given `children`). Neither tells two buttons apart.
+const passesThrough = (f: Fiber, path: readonly Fiber[]) => {
+  const props = propsOf(f);
+  if (!props) return false;
+  if (isActionable(props)) return true;
+  const passed = passedElementProps(props);
+  if (passed.size === 0) return false;
+  return path.some(p => passed.has(p.memoizedProps) || (p.alternate !== null && passed.has(p.alternate.memoizedProps)));
+};
+
+// The parent of a place: the first client component above the target that does not pass the press through, else the
+// nearest client component above it.
+const placeParentOf = (target: Fiber): Fiber | null => {
+  let nearest: Fiber | null = null;
+  const path: Fiber[] = [target];
+  for (let f = target.return, n = 0; f && n < MAX_UP * 2; f = f.return, n++) {
+    if (clientFiber(f)) {
+      nearest ??= f;
+      if (!passesThrough(f, path)) return f;
+    }
+    path.push(f);
+  }
+  return nearest;
+};
+
+// A client component that can pass a press through for something below it; any other client component is the
+// parent of every target under it.
+const mayPassThrough = (f: Fiber) => {
+  const props = propsOf(f);
+  return props !== null && (isActionable(props) || passedElementProps(props).size > 0);
+};
+
 const occurrenceOf = (
   parent: Fiber,
   target: Fiber,
@@ -611,13 +678,19 @@ const occurrenceOf = (
   const stack: { f: Fiber; inside: boolean }[] = root.child ? [{ f: root.child, inside: false }] : [];
   let count = 0;
   let index = 0;
+  const isParent = (f: Fiber | null) => f !== null && (f === root || f === root.alternate);
   while (stack.length && visited < 1000) {
     const { f, inside } = stack.pop()!;
     visited++;
     if (f.sibling) stack.push({ f: f.sibling, inside });
     if (isListCell(f)) continue;
     const client = clientFiber(f);
-    if (client && (inside || clientKeyOf(f) !== key)) continue;
+    if (client && inside) continue;
+    if (client && clientKeyOf(f) !== key) {
+      if (mayPassThrough(f) && f.child) stack.push({ f: f.child, inside: false });
+      continue;
+    }
+    if (client && !isParent(placeParentOf(f))) continue;
     const inTarget = inside || client;
     if (inTarget && ((scroll && client) || (!scroll && actionableFiber(f)))) {
       count++;
@@ -649,10 +722,7 @@ const placeOf = (host: Fiber | null, scroll: boolean, screen: ScreenKeyResolutio
     if (!scroll && actionableFiber(f)) region = f;
     if (clientFiber(f)) { target = f; break; }
   }
-  let parent: Fiber | null = null;
-  for (let f = target?.return ?? null, n = 0; f && n < MAX_UP * 2; f = f.return, n++) {
-    if (clientFiber(f)) { parent = f; break; }
-  }
+  const parent = target ? placeParentOf(target) : null;
   return {
     screen: screen.screen,
     parent: parent ? clientKeyOf(parent) : null,

package/js/sdk/interactions.ts

@@ -270,6 +270,19 @@ const finishPress = (press: ActivePress, reason: string, at?: number) => {
   }
 };
 
+// A drag is named after its scroll view (REQ-MEAS-10). Returns whether the gesture is a drag.
+const classify = (press: ActivePress) => {
+  const drag = press.maxMovePt >= DRAG_SLOP_PT || press.scrolled || press.takenByScroll;
+  press.kind = drag ? 'drag' : 'press';
+  if (drag) {
+    const axis = dragAxis(press);
+    const candidate = selectScrollHost(press.scrollHosts, axis);
+    press.container = candidate ? nameScrollContainer(candidate, press.screen) : null;
+    markers.rename(press.key, dragName(press), `drag:${press.container?.legacyName ?? press.target.legacyName}`);
+  }
+  return drag;
+};
+
 const onTouchStart = (ne: Record<string, unknown>) => {
   const touches = ne.touches;
   if (Array.isArray(touches) && touches.length > 1) {
@@ -326,6 +339,11 @@ const onTouchStart = (ne: Record<string, unknown>) => {
     legacyName: `press:${target.legacyName}`,
     at: touchStartT,
     details: details(press),
+    // A touch whose touchEnd never reached JS (its view unmounted, the app left the foreground) is classified by how
+    // far it moved, so a swipe stays a drag on its list.
+    beforeEnd: () => {
+      if (press.kind === null) classify(press);
+    },
   });
 };
 
@@ -420,14 +438,7 @@ const onTouchEnd = (ne: Record<string, unknown>, cancelled: boolean) => {
   // A scroll view cancels the touch when it takes the gesture. On a list still moving from a fling it does so at once,
   // before the finger passes the slop, so the move alone would call a fling a press on the row under the finger.
   press.takenByScroll = cancelled && press.scrollHosts.length > 0;
-  const drag = press.maxMovePt >= DRAG_SLOP_PT || press.scrolled || press.takenByScroll;
-  press.kind = drag ? 'drag' : 'press';
-  if (drag) {
-    const axis = dragAxis(press);
-    const candidate = selectScrollHost(press.scrollHosts, axis);
-    press.container = candidate ? nameScrollContainer(candidate, press.screen) : null;
-    const name = dragName(press);
-    markers.rename(press.key, name, `drag:${press.container?.legacyName ?? press.target.legacyName}`);
+  if (classify(press)) {
     return;
   }
   if (cancelled) {

package/js/sdk/push.ts

@@ -115,6 +115,8 @@ const serverClock = async (res: { json?: () => Promise<unknown> }, bound: Promis
 interface Item {
   line: string;
   bytes: number;
+  // The line's size inside the request body: a JSON string (escaped) plus its comma.
+  wire: number;
   token: string | null;
   // The process that recorded the line (its bootId) and its sequence there.
   origin: string;
@@ -127,7 +129,7 @@ interface Batch {
   id: string;
   items: Item[];
   token: string | null;
-  bytes: number;
+  wire: number;
 }
 
 interface SpoolAdd {
@@ -211,6 +213,8 @@ export const pendingFromSpool = (content: string | null): PendingLine[] =>
   readSpool(content).pending;
 
 // Retrying cannot fix these; the batch is dropped instead of blocking the queue.
+const wireBytes = (line: string) => utf8Length(JSON.stringify(line)) + 1;
+
 const isPermanent = (status: number) =>
   status >= 400 && status < 500 && status !== 408 && status !== 429;
 
@@ -261,6 +265,11 @@ export const createPushClient = (deps: PushDeps) => {
   let journalRecords = 0;
   // Lines dropped before delivery, by this process and (from the note) earlier ones.
   let undelivered = 0;
+  // Lines of a run dropped before delivery (queue cap, line over the batch limit), by run token, until its next flush.
+  const droppedOfRun = new Map<string, number>();
+  const noteDropped = (token: string | null) => {
+    if (token !== null) droppedOfRun.set(token, (droppedOfRun.get(token) ?? 0) + 1);
+  };
   // Round trips not reported yet, each with the run token it was measured under.
   let clockPending: { token: string; sample: ClockSample }[] = [];
   const clockOf = (token: string | null) =>
@@ -424,6 +433,7 @@ export const createPushClient = (deps: PushDeps) => {
       }
     }
     undelivered += dropped.length;
+    for (const item of dropped) noteDropped(item.token);
     return dropped;
   };
 
@@ -432,12 +442,14 @@ export const createPushClient = (deps: PushDeps) => {
     if (bytes > maxBatchBytes) {
       stats.dropped++;
       undelivered++;
+      noteDropped(deps.getRunToken());
       stats.lastError = `line of ${bytes} bytes exceeds batch limit`;
       return;
     }
     const item: Item = {
       line,
       bytes,
+      wire: wireBytes(line),
       token: deps.getRunToken(),
       origin: bootId,
       seq: nextSeq++,
@@ -486,11 +498,13 @@ export const createPushClient = (deps: PushDeps) => {
       if (bytes > maxBatchBytes) {
         stats.resumeDropped++;
         undelivered++;
+        noteDropped(record.t);
         continue;
       }
       earlier.push({
         line: record.l,
         bytes,
+        wire: wireBytes(record.l),
         token: record.t,
         origin: record.o,
         seq: record.s,
@@ -528,16 +542,16 @@ export const createPushClient = (deps: PushDeps) => {
     }
     const first = queue[0] as Item;
     const items: Item[] = [];
-    let bytes = 0;
+    let wire = 0;
     if (first.batch !== undefined) {
       // Already sent once (by a killed process): resend exactly that batch.
       while (queue.length > 0 && queue[0]?.batch === first.batch) {
         const next = queue.shift() as Item;
         queuedBytes -= next.bytes;
         items.push(next);
-        bytes += next.bytes;
+        wire += next.wire;
       }
-      return { id: first.batch, items, token: first.token, bytes };
+      return { id: first.batch, items, token: first.token, wire };
     }
     while (queue.length > 0 && items.length < maxBatchItems) {
       const next = queue[0];
@@ -546,16 +560,16 @@ export const createPushClient = (deps: PushDeps) => {
         next.batch !== undefined ||
         next.token !== first.token ||
         next.origin !== first.origin ||
-        (items.length > 0 && bytes + next.bytes > maxBatchBytes)
+        (items.length > 0 && wire + next.wire > maxBatchBytes)
       ) {
         break;
       }
       queue.shift();
       queuedBytes -= next.bytes;
       items.push(next);
-      bytes += next.bytes;
+      wire += next.wire;
     }
-    return { id: '', items, token: first.token, bytes };
+    return { id: '', items, token: first.token, wire };
   };
 
   let inflight: Promise<void> | null = null;
@@ -601,29 +615,48 @@ export const createPushClient = (deps: PushDeps) => {
           bound.clear();
         }
       }
+      const runToken = batch.token;
+      const reported = clockOf(runToken);
+      const sentDevice = device;
+      const bodyOf = (id: string) => JSON.stringify({
+        batch_id: id,
+        device: sentDevice,
+        items: batch.items.map(item => item.line),
+        ...(runToken ? { run_token: runToken } : {}),
+        ...(reported.length ? { clock: reported } : {}),
+      });
+      // Names exactly these lines (process, first and last sequence, count),
+      // so a different set of lines is always a different batch.
+      const idOf = () => {
+        const first = batch.items[0] as Item;
+        const last = batch.items[batch.items.length - 1] as Item;
+        return `${sentDevice.install_id}-${first.origin}-${first.seq}-${last.seq}-${batch.items.length}`;
+      };
+      let body = bodyOf(batch.id || idOf());
       if (!batch.id) {
-        // Names exactly these lines (process, first and last sequence, count),
-        // so a different set of lines is always a different batch. It is
-        // journalled before the first send: a later process that resends after
+        // The cap is on the body as sent (escaped lines, device, clock samples): lines over it go back to the queue
+        // front for the next batch. A lone line still goes; a line alone over the cap was dropped at enqueue.
+        for (let over = utf8Length(body) - maxBatchBytes; over > 0 && batch.items.length > 1; over = utf8Length(body) - maxBatchBytes) {
+          const back: Item[] = [];
+          for (let freed = 0; freed < over && batch.items.length > 1;) {
+            const item = batch.items.pop() as Item;
+            freed += item.wire;
+            back.unshift(item);
+          }
+          queue.unshift(...back);
+          for (const item of back) queuedBytes += item.bytes;
+          body = bodyOf(idOf());
+        }
+        // Journalled before the first send: a later process that resends after
         // a kill sends the same lines under the same id, and the server's
         // replay check can only ever drop lines it already has.
+        batch.id = idOf();
         const first = batch.items[0] as Item;
-        const last = batch.items[batch.items.length - 1] as Item;
-        batch.id = `${device.install_id}-${first.origin}-${first.seq}-${last.seq}-${batch.items.length}`;
         for (const item of batch.items) {
           item.batch = batch.id;
         }
         journal({ b: batch.id, o: first.origin, s: batch.items.map(item => item.seq) });
       }
-      const runToken = batch.token;
-      const reported = clockOf(runToken);
-      const body = JSON.stringify({
-        batch_id: batch.id,
-        device,
-        items: batch.items.map(item => item.line),
-        ...(runToken ? { run_token: runToken } : {}),
-        ...(reported.length ? { clock: reported } : {}),
-      });
       const headers: Record<string, string> = {
         'content-type': 'application/json',
         'x-keepsnappy-key': deps.key,
@@ -804,16 +837,23 @@ export const createPushClient = (deps: PushDeps) => {
         await sendClock(deadline);
       }
       const refused = refusedRunBatches - refusedBefore;
-      const ok = sentAll && refused === 0;
+      // A run that lost lines before they were sent is missing windows, whatever went up after.
+      const token = deps.getRunToken();
+      const lost = token === null ? 0 : (droppedOfRun.get(token) ?? 0);
+      if (token !== null) droppedOfRun.delete(token);
+      const ok = sentAll && refused === 0 && lost === 0;
+      const error = ok
+        ? null
+        : !sentAll
+          ? (stats.lastError ?? 'flush deadline')
+          : refused > 0
+            ? `rejected ${lastRefusedStatus}: ${refused} ${refused === 1 ? 'batch' : 'batches'} of the run dropped`
+            : 'lines of the run dropped before sending';
       return {
         ok,
         batches: stats.batchesSent - sentBefore,
         lines: stats.linesSent - linesBefore,
-        error: ok
-          ? null
-          : !sentAll
-            ? (stats.lastError ?? 'flush deadline')
-            : `rejected ${lastRefusedStatus}: ${refused} ${refused === 1 ? 'batch' : 'batches'} of the run dropped`,
+        error: error !== null && lost > 0 ? `${error} dropped=${lost}` : error,
       };
     } finally {
       flushLimit = null;

package/js/sdk/sampler.ts

@@ -132,7 +132,7 @@ export const estimateOffset = (before: number, native: number, after: number) =>
 // late after its t0 a window can start and still take one. It gates only screen windows (a screen window opened by a
 // press is detected after the new screen rendered and takes the press's open sample, taken the touch delivery delay
 // past the press's t0) and the reuse of a close sample for a restarted key. Press windows do not depend on it: they
-// take the previous window's close sample by contiguity. Evidence for 50: idle lab event timing of 4.9-19.1 ms
+// take the previous window's close sample by contiguity, else a sample of their own however late it is. Evidence for 50: idle lab event timing of 4.9-19.1 ms
 // (packages/derive/test/fixtures/p37-*.log); no loaded-device data. Measure the touchstart delivery delay p99 per
 // device from farm data (docs/log/followups.md).
 export const OPEN_SAMPLE_TOLERANCE_MS = 50;

package/js/sdk/screens.ts

@@ -66,7 +66,8 @@ interface Visit {
   visit: number;
   screenKey: string | null;
   legacyName: string;
-  pendingCommits: number;
+  // The screen component is not known yet: its scene has not mounted, or it is suspended.
+  pending: boolean;
   resolution: ScreenRouteResolution;
   lazyBoundary: Fiber | null;
   t0: number;
@@ -254,7 +255,7 @@ const endVisit = (reason: string, at?: number) => {
   if (!visit || visit.endedAt !== null) {
     return;
   }
-  if (visit.pendingCommits > 0) resolveVisit(visit, true);
+  if (visit.pending) resolveVisit(visit, true);
   const t = Math.max(visit.t0, at ?? now());
   visit.endedAt = t;
   stats.ends[reason] = (stats.ends[reason] ?? 0) + 1;
@@ -269,7 +270,9 @@ const endVisit = (reason: string, at?: number) => {
 // state event.
 const chooseStart = (snapshot: NavSnapshot, floor: number) => {
   const inSpan = (t: number) => t >= floor && t <= snapshot.stateT;
-  const presses = pressesSinceVisit.filter(p => inSpan(p.t0));
+  // Touches delivered since the previous visit opened, whatever their finger time: a finger that landed while the
+  // previous screen was mounting reaches JS after its state was read.
+  const presses = pressesSinceVisit.filter(p => p.t0 >= windowsEndedAt && p.t0 <= snapshot.stateT);
   const link = pendingLink && inSpan(pendingLink.t) ? pendingLink : null;
   const action = snapshot.action && inSpan(snapshot.action.t) ? snapshot.action : null;
   const touchStart = (p: Press) => ({
@@ -357,7 +360,7 @@ const resolveVisit = (visit: Visit, final = false) => {
   if (resolved.screenPending && !final) return;
   moveScreenCounter(visit, resolved.screen);
   visit.name = buildPlaceId({ kind: 'screen', screen: resolved.screen, visit: visit.visit });
-  visit.pendingCommits = 0;
+  visit.pending = false;
   markers.rename(visit.key, visit.name, visit.legacyName);
 };
 
@@ -380,7 +383,7 @@ const extend = (visit: Visit, chain: RoutePart[], chainKey: string) => {
       visit.screenKey = null;
     }
     visit.name = visit.legacyName;
-    visit.pendingCommits = 3;
+    visit.pending = true;
     markers.rename(visit.key, visit.name, visit.legacyName);
   } else resolveVisit(visit);
   stats.extended++;
@@ -447,7 +450,7 @@ const onSnapshot = (snapshot: NavSnapshot, nameSource: NameSource) => {
     visit: n,
     legacyName: nameOf(chainKey, n),
     screenKey: null,
-    pendingCommits: 3,
+    pending: true,
     resolution: resolved,
     lazyBoundary: resolved.suspended ?? null,
     t0: start.t0,
@@ -465,7 +468,7 @@ const onSnapshot = (snapshot: NavSnapshot, nameSource: NameSource) => {
   if (!resolved.screenPending) {
     moveScreenCounter(visit, resolved.screen);
     visit.name = buildPlaceId({ kind: 'screen', screen: resolved.screen, visit: visit.visit });
-    visit.pendingCommits = 0;
+    visit.pending = false;
   }
   current = visit;
   pressesSinceVisit = [];
@@ -481,7 +484,7 @@ const onSnapshot = (snapshot: NavSnapshot, nameSource: NameSource) => {
     kind: 'screen',
     legacyName: visit.legacyName,
     beforeEnd: () => {
-      if (visit.pendingCommits > 0) resolveVisit(visit, true);
+      if (visit.pending) resolveVisit(visit, true);
       visit.lazyBoundary = null;
       visit.resolution = { screen: visit.screenKey ?? visit.resolution.screen };
     },
@@ -526,12 +529,14 @@ export const noteAppLink = (url: string, via: string) => {
   }
 };
 
+// Every touch delivered while a visit is open is an action after the one that opened it, even when its finger landed
+// before the SDK read the navigation state (the JS thread was busy with the mount): order decides, not the clocks.
 const onPress = (t0: number) => {
   const press = lastPressStart();
   if (press) {
     pressesSinceVisit.push(press);
   }
-  if (current && current.endedAt === null && t0 > current.openedAt) {
+  if (current && current.endedAt === null) {
     endVisit('next-action', t0);
   }
 };
@@ -628,7 +633,7 @@ export const installScreens = () => {
   installed = true;
   setScreenKeyProvider(() => current ? {
     screen: current.screenKey ?? current.resolution.screen,
-    ...(current.pendingCommits > 0 || current.lazyBoundary ? { screenPending: true } : {}),
+    ...(current.pending || current.lazyBoundary ? { screenPending: true } : {}),
   } : { screen: '(no screen)' });
   setRetainFloor(screenRetainFloor);
   onWindowsEnd(onWindowsEnded);
@@ -641,11 +646,12 @@ export const installScreens = () => {
   onAfterCommit(() => {
     const visit = current;
     if (visit && isWindowOpen(visit.key)) {
-      if (visit.pendingCommits > 0) {
+      // A pending visit is resolved when its scene mounts, however many commits come first; it falls back to the route
+      // name only when it ends.
+      if (visit.pending && !visit.lazyBoundary) {
         visit.resolution = screenResolution(visit.chain);
         visit.lazyBoundary = visit.resolution.suspended ?? null;
-        visit.pendingCommits--;
-        resolveVisit(visit, visit.pendingCommits === 0);
+        resolveVisit(visit);
       } else if (visit.lazyBoundary) {
         const boundary = currentFiber(visit.lazyBoundary);
         if (!boundary || boundary.memoizedState == null) {

package/js/sdk/stream.ts

@@ -39,6 +39,12 @@ export const createStream = (processId: string, maxFibers = MAX_SEGMENT_FIBERS)
     /** The segment the next commit goes into: windows name it so the backend can tell a stream is complete. */
     seq: () => seq,
     size: () => commits.length,
+    /** Sets the fiber cap of the segments from now on; returns the previous cap. */
+    setMaxFibers(n: number) {
+      const previous = maxFibers;
+      maxFibers = n;
+      return previous;
+    },
     noteRoot(root: CauseRoot) {
       roots.push(root);
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keepsnappy/react-native",
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.17",
   "description": "KeepSnappy in-app SDK for React Native / Expo: zero-code measurement windows, React commit hook, native signposts and log file",
   "license": "UNLICENSED",
   "repository": {