@keepsnappy/react-native 0.1.0-alpha.12 → 0.1.0-alpha.14

package/js/sdk/core.ts

@@ -1,12 +1,12 @@
-// perf-lab core: settings, windows, the commit walk, observers, faults, logs.
+// keepsnappy core: settings, windows, the commit walk, observers, faults, logs.
 // Loaded by boot.ts, which Metro runs before the app's entry module.
 
 import {
   type ActivationStore,
   type Decision,
   MODE,
-  PERF_LAB_DEEP_LINK_PATH,
-  PERF_LAB_ENABLED,
+  KEEPSNAPPY_DEEP_LINK_PATH,
+  KEEPSNAPPY_ENABLED,
   parseQuery,
   type PolyfillActivation,
 } from './activation';
@@ -32,6 +32,7 @@ import {
   summarizeArtifacts,
   type WrittenFile,
 } from './artifacts';
+import { createPendingArtifacts, type EarlierArtifacts } from './artifact-pending';
 import {
   backgroundSource,
   type Carrier,
@@ -90,7 +91,7 @@ import {
   windowAggregate,
 } from './sampler';
 
-export { PERF_LAB_DEEP_LINK_PATH, PERF_LAB_ENABLED, parseQuery };
+export { KEEPSNAPPY_DEEP_LINK_PATH, KEEPSNAPPY_ENABLED, parseQuery };
 
 type LogSink = 'console' | 'native' | 'both';
 
@@ -126,7 +127,7 @@ interface Settings extends SamplerSettings {
   diag: boolean;
 }
 
-interface PerfLabNative extends Partial<CpuProfileNative> {
+interface KeepSnappyNative extends Partial<CpuProfileNative> {
   beginAsyncSection(name: string, cookie: number): void;
   endAsyncSection(name: string, cookie: number): void;
   setCounter(name: string, value: number): void;
@@ -143,13 +144,16 @@ interface PerfLabNative extends Partial<CpuProfileNative> {
   samplerRecent(sinceT: number): SamplerRecord[];
   samplerNow(): number;
   flushSignal?(status: string, detail: string): void;
-  // GC before the action: Android finishes the pending command broadcast with this result; iOS shows it on `perflab.ack`.
+  // The list of profile files not uploaded yet, with run tokens: internal storage, read by a later process.
+  artifactsPendingRead?(): string | null;
+  artifactsPendingWrite?(content: string): boolean;
+  // Command answer (`gc:<n> ok`, `memread:<n> ok`): Android finishes the pending command broadcast with this result; iOS shows it on `keepsnappy.ack`.
   commandDone?(n: number, data: string): void;
   /** Android: whether the broadcast of command n still waits for its answer (native finishes it at a deadline). */
   commandPending?(n: number): boolean;
   ackSignal?(text: string): void;
   commandListen?(on: boolean): void;
-  addListener?(event: 'perflabCommand', listener: (e: { cmd: string; n: number; tNative: number }) => void): { remove(): void };
+  addListener?(event: 'keepsnappyCommand', listener: (e: { cmd: string; n: number; tNative: number }) => void): { remove(): void };
 }
 
 interface RendererInternals {
@@ -232,7 +236,7 @@ interface PolyfillHook {
   attach: (listener: HookListener | null) => void;
 }
 
-interface PerfLabGlobal {
+interface KeepSnappyGlobal {
   HermesInternal?: HermesInternalApi;
   PerformanceObserver?: PerfObserverCtor & { supportedEntryTypes?: string[] };
   performance?: PerformanceLike;
@@ -240,12 +244,12 @@ interface PerfLabGlobal {
   console: { log: (...args: unknown[]) => void; timeStamp?: unknown };
   expo?: { modules?: Record<string, unknown> };
   __REACT_DEVTOOLS_GLOBAL_HOOK__?: Record<string, unknown>;
-  __PERFLAB_HOOK__?: PolyfillHook;
-  __PERFLAB_ACTIVATION__?: PolyfillActivation;
-  __PERF_LAB__?: unknown;
+  __KEEPSNAPPY_HOOK__?: PolyfillHook;
+  __KEEPSNAPPY_ACTIVATION__?: PolyfillActivation;
+  __KEEPSNAPPY__?: unknown;
 }
 
-const g = globalThis as unknown as PerfLabGlobal;
+const g = globalThis as unknown as KeepSnappyGlobal;
 
 const NO_FAULTS: Faults = {
   cpu: 0,
@@ -296,14 +300,14 @@ export const now = () => (g.performance ? g.performance.now() : Date.now());
 export const fmt = (ms: number) => ms.toFixed(3);
 const noop = () => undefined;
 
-let nativeModule: PerfLabNative | null | undefined;
+let nativeModule: KeepSnappyNative | null | undefined;
 let nativeMissingLogged = false;
 
-const getNative = (): PerfLabNative | null => {
+const getNative = (): KeepSnappyNative | null => {
   if (nativeModule) {
     return nativeModule;
   }
-  const found = g.expo?.modules?.PerfLab as PerfLabNative | undefined;
+  const found = g.expo?.modules?.KeepSnappy as KeepSnappyNative | undefined;
   if (found) {
     nativeModule = found;
     return found;
@@ -311,7 +315,7 @@ const getNative = (): PerfLabNative | null => {
   if (!nativeMissingLogged) {
     nativeMissingLogged = true;
     g.console.log(
-      'PERF_LAB native module PerfLab missing (expo.modules.PerfLab)',
+      'KEEPSNAPPY native module KeepSnappy missing (expo.modules.KeepSnappy)',
     );
   }
   return null;
@@ -344,10 +348,10 @@ const cpu = createCpuProfiler({
 });
 
 export const perfLog = (message: string, sink: LogSink = settings.log) => {
-  if (!PERF_LAB_ENABLED) {
+  if (!KEEPSNAPPY_ENABLED) {
     return;
   }
-  const line = `PERF_LAB ${message}`;
+  const line = `KEEPSNAPPY ${message}`;
   if (sink === 'console' || sink === 'both') {
     g.console.log(line);
   }
@@ -412,7 +416,7 @@ const nativeSamplerNow = () => {
 
 // On-demand sample: logged natively like the automatic ones and returned. Null when the sampler is off.
 export const sample = (reason = 'manual'): SamplerRecord | null => {
-  if (!PERF_LAB_ENABLED || samplerState.mode === 'off') {
+  if (!KEEPSNAPPY_ENABLED || samplerState.mode === 'off') {
     return null;
   }
   try {
@@ -816,7 +820,7 @@ const clearIdleGc = () => {
 
 const scheduleIdleGc = () => {
   clearIdleGc();
-  if (!PERF_LAB_ENABLED || !settings.gcwin || openWindows.size > 0) {
+  if (!KEEPSNAPPY_ENABLED || !settings.gcwin || openWindows.size > 0) {
     return;
   }
   idleGcTimer = setTimeout(() => {
@@ -835,7 +839,7 @@ export const lastCommitAt = (key: string) =>
 export const isWindowOpen = (key?: string) =>
   key ? openWindows.has(key) : openWindows.size > 0;
 
-const traceName = (name: string) => `perf-lab:${name}`;
+const traceName = (name: string) => `keepsnappy:${name}`;
 
 interface StartOptions {
   key?: string;
@@ -962,7 +966,7 @@ const endBackground = (reason: string) => {
 };
 
 const start = (name: string, options: StartOptions = {}) => {
-  if (!PERF_LAB_ENABLED || !settings.marks) {
+  if (!KEEPSNAPPY_ENABLED || !settings.marks) {
     return null;
   }
   const key = options.key ?? name;
@@ -1091,7 +1095,7 @@ const rename = (key: string, name: string) => {
 };
 
 const point = (name: string) => {
-  if (!PERF_LAB_ENABLED || !settings.marks) {
+  if (!KEEPSNAPPY_ENABLED || !settings.marks) {
     return;
   }
   const t = now();
@@ -1277,15 +1281,15 @@ const onCommitFiberUnmount = (_rendererId: number, fiber: Fiber) => {
 };
 
 export const lastRoot = (rendererId = 1): FiberRoot | null =>
-  g.__PERFLAB_HOOK__?.state.lastRootByRenderer[rendererId] ?? null;
+  g.__KEEPSNAPPY_HOOK__?.state.lastRootByRenderer[rendererId] ?? null;
 
 // The polyfill (withKeepSnappy) installed the hook before React loaded; attach to
 // it. Without the polyfill, fall back to installing it now, as the prototype did.
 export const attachHook = () => {
-  if (!PERF_LAB_ENABLED || hookState.installed) {
+  if (!KEEPSNAPPY_ENABLED || hookState.installed) {
     return;
   }
-  const polyfill = g.__PERFLAB_HOOK__;
+  const polyfill = g.__KEEPSNAPPY_HOOK__;
   if (polyfill) {
     polyfill.ensure();
     polyfill.attach({
@@ -1310,7 +1314,7 @@ export const attachHook = () => {
   }
   if (g.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
     hookState.preexisting = true;
-    g.console.log('PERF_LAB hook already present, not replacing it');
+    g.console.log('KEEPSNAPPY hook already present, not replacing it');
     return;
   }
   let nextRendererId = 1;
@@ -1327,7 +1331,7 @@ export const attachHook = () => {
         bundleType: internals.bundleType,
       });
       g.console.log(
-        `PERF_LAB hook inject id=${id} renderer=${internals.rendererPackageName} version=${internals.version} bundleType=${internals.bundleType}`,
+        `KEEPSNAPPY hook inject id=${id} renderer=${internals.rendererPackageName} version=${internals.version} bundleType=${internals.bundleType}`,
       );
       return id;
     },
@@ -1617,6 +1621,17 @@ export const setArtifactHandler = (handler: ArtifactHandler | null) => {
 // Entries a window interrupted wait for the next flush of this process.
 let artifactBacklog: ArtifactEntry[] = [];
 
+const pendingArtifacts = createPendingArtifacts(() => {
+  const native = getNative();
+  if (typeof native?.artifactsPendingRead !== 'function' || typeof native.artifactsPendingWrite !== 'function') {
+    return null;
+  }
+  return {
+    read: () => native.artifactsPendingRead!(),
+    write: content => native.artifactsPendingWrite!(content),
+  };
+}, perfLog);
+
 const writeManifest = (entries: ArtifactEntry[], upload: ArtifactUploadSummary | null) => {
   try {
     const manifest = buildManifest({
@@ -1662,11 +1677,39 @@ const sendArtifacts = async (fresh: ArtifactEntry[], deadline: number) => {
     summary = summarizeArtifacts(entries, 0, 'push not configured');
   }
   artifactBacklog = entries.filter(entry => entry.state === 'pending' || entry.state === 'failed');
+  pendingArtifacts.note(PROCESS_ID, entries, runToken);
   writeManifest(entries, summary);
   perfLog(`artifacts ${JSON.stringify(summary)}`);
   return summary;
 };
 
+// After this process's own files: what earlier processes left (a flush that never finished, a kill during the upload), each
+// under its own run token and process id, within the same deadline.
+const sendEarlierArtifacts = async (deadline: number) => {
+  if (!artifactHandler) {
+    return;
+  }
+  const groups: EarlierArtifacts[] = pendingArtifacts.earlier(PROCESS_ID);
+  if (groups.length === 0) {
+    return;
+  }
+  const tried: EarlierArtifacts[] = [];
+  for (const group of groups) {
+    // What does not fit in this flush waits for the next one, with no try counted.
+    if (Date.now() >= deadline) {
+      break;
+    }
+    tried.push(group);
+    try {
+      const summary = await artifactHandler(group.entries, null, group.processId, deadline);
+      perfLog(`artifacts earlier ${JSON.stringify({ processId: group.processId, ...summary })}`);
+    } catch (error) {
+      perfLog(`artifacts earlier failed ${String(error)}`);
+    }
+  }
+  pendingArtifacts.settleEarlier(tried);
+};
+
 // Declared on every window line so the backend can tell windows of this model from older ones (REQ-VER-34).
 // 2: a tap or scroll window runs from its touch to the next touch, the background or the flush; no quiet rule, no `+3s` twin.
 // 3: model 2, and a screen window also ends at the next action, the next screen, the background or the flush; no 3 s cap.
@@ -1753,7 +1796,7 @@ const finalizeWindow = (window: MarkerWindow) => {
 const writeWindowRecord = (window: MarkerWindow, summary: Record<string, unknown>) => {
   const json = JSON.stringify(summary);
   perfLog(`window ${json}`);
-  windowListener?.(`${Date.now()} PERF_LAB window ${json}`);
+  windowListener?.(`${Date.now()} KEEPSNAPPY window ${json}`);
   if (settings.file) {
     const path = getNative()?.writeText(
       `window-${window.id}-${window.name.replace(/[^\w.:+-]/g, '_')}.json`,
@@ -1948,7 +1991,7 @@ const forwardSamples = () => {
       if (record.t <= samplesSentT) {
         continue;
       }
-      windowListener(`${record.wallMs} PERF_LAB sample ${JSON.stringify(record)}`);
+      windowListener(`${record.wallMs} KEEPSNAPPY sample ${JSON.stringify(record)}`);
       samplesSentT = record.t;
     }
   } catch (error) {
@@ -1973,7 +2016,7 @@ export const writeRunEvent = (kind: 'gc' | 'appstate', record: Record<string, un
   const json = JSON.stringify({ ...record, t: now(), wallMs: Date.now() });
   perfLog(`${kind} ${json}`);
   if (inRun() && (kind === 'gc' || gcRanSinceFlush)) {
-    windowListener?.(`${Date.now()} PERF_LAB ${kind} ${json}`);
+    windowListener?.(`${Date.now()} KEEPSNAPPY ${kind} ${json}`);
   }
 };
 
@@ -1995,9 +2038,13 @@ export const setFlushHandler = (handler: FlushHandler | null) => {
 };
 
 // `flush=1`: end the open windows, send every unsent line, then show the result
-// to the test driver as an accessibility element (iOS: id `perflab.flushed`,
+// to the test driver as an accessibility element (iOS: id `keepsnappy.flushed`,
 // label `ok` / `error` / `off`), so a flow can wait for it without network access.
-const flushOnce = async () => {
+// The driver's name for one flush link (`ack=<n>`), echoed at the end of the answer's detail: the answer element stays up
+// until the next one replaces it, so without it a later flush in the same process could read an earlier flush's answer.
+const ACK_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
+
+const flushOnce = async (ack: string | undefined) => {
   // One deadline for the whole flush (lines, clock, artifacts); the end report of the upload comes after it.
   const deadline = Date.now() + ARTIFACT_UPLOAD_DEADLINE_MS;
   endAll('flush');
@@ -2008,6 +2055,8 @@ const flushOnce = async () => {
   } catch (error) {
     perfLog(`flush files failed ${String(error)}`);
   }
+  // Before anything that waits on the network: a flush that never ends, or a process killed now, leaves the list to a later one.
+  pendingArtifacts.note(PROCESS_ID, [...artifactBacklog, ...artifacts], runToken);
   let status = 'off';
   let detail = 'push not configured';
   if (flushHandler) {
@@ -2026,10 +2075,25 @@ const flushOnce = async () => {
     const sent = await sendArtifacts(artifacts, deadline);
     if (sent) {
       detail += ` artifacts=${sent.uploaded}/${sent.total}`;
+      // A profile file of a run that did not reach the API is missing data, whatever kept it back: failed after its tries, left
+      // unsent by the deadline, kept on the device (token refused, no endpoint, no native upload) or refused by the API.
+      const missing = sent.failed + sent.pending + (runToken !== null ? sent.local + sent.rejected : 0);
+      if (status === 'ok' && missing > 0) {
+        status = 'error';
+        detail += ` failed=${sent.failed} pending=${sent.pending} local=${sent.local} rejected=${sent.rejected}`;
+      }
     }
   } catch (error) {
     perfLog(`artifacts failed ${String(error)}`);
   }
+  try {
+    await sendEarlierArtifacts(deadline);
+  } catch (error) {
+    perfLog(`artifacts earlier failed ${String(error)}`);
+  }
+  if (ack !== undefined && ACK_PATTERN.test(ack)) {
+    detail += ` ack=${ack}`;
+  }
   perfLog(`flush ${status} ${detail}`);
   try {
     getNative()?.flushSignal?.(status, detail);
@@ -2041,11 +2105,11 @@ const flushOnce = async () => {
 // A second flush link while one runs (the driver's final flush) waits for it: the flush signal means the
 // uploads of the first are done, so it must not be raised by a flush that has nothing left to send.
 let flushing: Promise<void> | null = null;
-export const flushNow = (): Promise<void> => {
+export const flushNow = (ack?: string): Promise<void> => {
   commandAnswers.clear();
   gcRanSinceFlush = false;
   // The first flush starts at once (it ends the open windows in the same tick as the link).
-  const run = flushing === null ? flushOnce() : flushing.then(flushOnce);
+  const run = flushing === null ? flushOnce(ack) : flushing.then(() => flushOnce(ack));
   const tail: Promise<void> = run
     .catch(() => undefined)
     .then(() => {
@@ -2059,7 +2123,7 @@ export const flushNow = (): Promise<void> => {
 
 // The activation's profile/cpuprof turn those on for the whole process; off
 // leaves the build's env defaults.
-// A PerfLab run (one with a run token) forces an idle GC between windows so heap-after-GC
+// A KeepSnappy run (one with a run token) forces an idle GC between windows so heap-after-GC
 // readings exist for the leak slope (plan 41 Q7); `gcwin=0` in a link still turns it off.
 const applyDecision = (decision: Decision) => {
   settings.diag = decision.diag;
@@ -2093,13 +2157,13 @@ const activationReport = () => {
     mode: 'active',
     buildMode: decision.mode,
     read: decision.read,
-    installMs: g.__PERFLAB_ACTIVATION__?.installMs,
+    installMs: g.__KEEPSNAPPY_ACTIVATION__?.installMs,
     runToken: runToken !== null,
     expiresAt: decision.expiresAt,
     diag: decision.diag,
     profile: decision.profile,
     cpuprof: decision.cpuprof,
-    renderer: g.__PERFLAB_ACTIVATION__?.renderer ?? null,
+    renderer: g.__KEEPSNAPPY_ACTIVATION__?.renderer ?? null,
     next: next
       ? {
           active: next.active,
@@ -2242,10 +2306,32 @@ export const actionGc = (n: number, tNative?: number): string => {
   }
   // The gc-pre / gc-post records go out now: the backend pairs them with this command by their seq.
   forwardSamples();
+  rememberAnswer(key, answer);
+  answerCommand(n, answer);
+  return answer;
+};
+
+const rememberAnswer = (key: string, answer: string) => {
   commandAnswers.set(key, answer);
   if (commandAnswers.size > COMMAND_ANSWERS_KEPT) {
     commandAnswers.delete(commandAnswers.keys().next().value as string);
   }
+};
+
+// The end GC's manual memory read: the driver's `memread` command, sent with the GC's own n after the GC's answer. One sample, at
+// once (no timer), reason `endgc-read:<n>`, sent with the run's lines before the answer; the answer is the driver's signal that the
+// app may go to the background. Derive reads kept from this record (derivation 23).
+export const endGcRead = (n: number): string => {
+  const key = `${runToken ?? '-'}#read${n}`;
+  const known = commandAnswers.get(key);
+  if (known !== undefined) {
+    answerCommand(n, known);
+    return known;
+  }
+  const record = sample(`endgc-read:${n}`);
+  const answer = `memread:${n} ${record ? 'ok' : 'unavailable'}`;
+  forwardSamples();
+  rememberAnswer(key, answer);
   answerCommand(n, answer);
   return answer;
 };
@@ -2258,44 +2344,48 @@ const syncCommandListener = () => {
   if (!native?.commandListen) {
     return;
   }
-  const on = PERF_LAB_ENABLED && runToken !== null;
+  const on = KEEPSNAPPY_ENABLED && runToken !== null;
   if (on && commandSubscription === null) {
     commandSubscription =
-      native.addListener?.('perflabCommand', e => {
+      native.addListener?.('keepsnappyCommand', e => {
         // A command native already timed out on is not run: its GC would land in the next step's action.
         if (native.commandPending?.(e.n) === false) {
-          perfLog(`command gc:${e.n} late, skipped`);
+          perfLog(`command ${e.cmd}:${e.n} late, skipped`);
           return;
         }
-        handlePerfLabCommand(e.cmd, e.n, e.tNative);
+        handleKeepSnappyCommand(e.cmd, e.n, e.tNative);
       }) ?? null;
   }
   native.commandListen(on);
 };
 
 /** A command (`cmd=<name>&n=<n>`), from a link (iOS) or the native receiver (Android); unknown commands are ignored. */
-export const handlePerfLabCommand = (cmd: string | undefined, n: number, tNative?: number): boolean => {
-  if (!PERF_LAB_ENABLED || cmd !== 'gc' || !Number.isInteger(n) || n < 1) {
+export const handleKeepSnappyCommand = (cmd: string | undefined, n: number, tNative?: number): boolean => {
+  if (!KEEPSNAPPY_ENABLED || (cmd !== 'gc' && cmd !== 'memread') || !Number.isInteger(n) || n < 1) {
     return false;
   }
   // Every received command is answered, so the Android receiver is never left pending.
   try {
-    actionGc(n, tNative);
+    if (cmd === 'gc') {
+      actionGc(n, tNative);
+    } else {
+      endGcRead(n);
+    }
   } catch (error) {
-    perfLog(`command gc:${n} failed ${String(error)}`);
-    answerCommand(n, `gc:${n} error`);
+    perfLog(`command ${cmd}:${n} failed ${String(error)}`);
+    answerCommand(n, `${cmd}:${n} error`);
   }
   return true;
 };
 
-export const handlePerfLabDeepLink = (url: string) => {
-  if (!PERF_LAB_ENABLED) {
+export const handleKeepSnappyDeepLink = (url: string) => {
+  if (!KEEPSNAPPY_ENABLED) {
     return;
   }
   const params = parseQuery(url.split('?')[1]);
   // A command changes no settings and writes no activation record.
   if (params.cmd !== undefined) {
-    handlePerfLabCommand(params.cmd, Number(params.n));
+    handleKeepSnappyCommand(params.cmd, Number(params.n));
     return;
   }
   const written = activation?.store.apply(params) ?? null;
@@ -2306,7 +2396,7 @@ export const handlePerfLabDeepLink = (url: string) => {
   }
   applySettings(params);
   if (params.flush === '1') {
-    void flushNow();
+    void flushNow(params.ack);
   }
 };
 
@@ -2326,7 +2416,7 @@ export const addStartupSection = (name: string, read: () => unknown) => {
 
 export const logStartup = (phase: string) => {
   const native = getNative();
-  const polyfill = g.__PERFLAB_HOOK__?.state;
+  const polyfill = g.__KEEPSNAPPY_HOOK__?.state;
   const extra: Record<string, unknown> = {};
   for (const [name, read] of extraStartupSections) {
     extra[name] = safe(read);
@@ -2391,7 +2481,7 @@ export const logStartup = (phase: string) => {
 };
 
 export const exposeGlobal = () => {
-  g.__PERF_LAB__ = {
+  g.__KEEPSNAPPY__ = {
     settings,
     set: applySettings,
     markers,

package/js/sdk/cpuprof.ts

@@ -3,7 +3,7 @@
 // overlapping windows (a press and the screen it opens) share one span and one
 // file. Inside a run it samples on until `flush=1` and writes one file there.
 // The file is a DevTools .cpuprofile (nodes/samples/timeDeltas) written by the
-// native module into Documents/perf-lab.
+// native module into Documents/keepsnappy.
 
 export interface CpuProfileNative {
   cpuProfileStart(hz: number): boolean;

package/js/sdk/dormant.ts

@@ -16,14 +16,14 @@ interface DormantNative {
 
 interface DormantGlobal {
   __REACT_DEVTOOLS_GLOBAL_HOOK__?: unknown;
-  __PERFLAB_HOOK__?: { state?: { mode?: string; listener?: unknown } };
-  __PERF_LAB__?: unknown;
+  __KEEPSNAPPY_HOOK__?: { state?: { mode?: string; listener?: unknown } };
+  __KEEPSNAPPY__?: unknown;
   expo?: { modules?: Record<string, unknown> };
 }
 
 const g = globalThis as unknown as DormantGlobal;
 
-const NET_MARK = '__perflabNet';
+const NET_MARK = '__keepsnappyNet';
 
 const marked = (value: unknown) =>
   (typeof value === 'function' || (typeof value === 'object' && value !== null)) &&
@@ -54,8 +54,8 @@ export const dormantReport = (decision: Decision) => ({
   buildMode: decision.mode,
   read: decision.read,
   reactHook: typeof g.__REACT_DEVTOOLS_GLOBAL_HOOK__,
-  perflabHook: g.__PERFLAB_HOOK__ ? (g.__PERFLAB_HOOK__.state?.mode ?? 'present') : 'absent',
-  sdkGlobal: g.__PERF_LAB__ !== undefined,
+  keepsnappyHook: g.__KEEPSNAPPY_HOOK__ ? (g.__KEEPSNAPPY_HOOK__.state?.mode ?? 'present') : 'absent',
+  sdkGlobal: g.__KEEPSNAPPY__ !== undefined,
   fetchWrapped: globalWrapped('fetch'),
   xhrGetterWrapped: globalWrapped('XMLHttpRequest'),
   xhrPatched: xhrPatched(),
@@ -69,9 +69,9 @@ export const startDormant = (decision: Decision) => {
     store.apply(params);
     if (params.dump === '1') {
       // Asked for: one os_log line (iOS) / logcat line (Android), no log file.
-      const native = g.expo?.modules?.PerfLab as DormantNative | undefined;
+      const native = g.expo?.modules?.KeepSnappy as DormantNative | undefined;
       const report = { ...dormantReport(decision), activation: store.stats() };
-      native?.osLog?.(`PERF_LAB dormant ${JSON.stringify(report)}`);
+      native?.osLog?.(`KEEPSNAPPY dormant ${JSON.stringify(report)}`);
     }
   });
 };

package/js/sdk/links.ts

@@ -1,31 +1,31 @@
-// Settings links (`<scheme>://devtools/perf-lab?...`) without app code: the SDK
+// Settings links (`<scheme>://devtools/keepsnappy?...`) without app code: the SDK
 // runs before the router subscribes to Linking, so it wraps the link sources.
-// A perf-lab link goes to the handler here and never reaches the app's
+// A keepsnappy link goes to the handler here and never reaches the app's
 // listeners, so the router does not navigate to an unmatched route. Only a URL
-// whose host and path are exactly `devtools/perf-lab` on a custom (non-web)
+// whose host and path are exactly `devtools/keepsnappy` on a custom (non-web)
 // scheme is one; every other URL passes through unchanged after one substring
 // check: in a dormant build this is the only work the SDK does after startup.
 
 import { Linking } from 'react-native';
 
-import { PERF_LAB_DEEP_LINK_PATH } from './activation';
+import { KEEPSNAPPY_DEEP_LINK_PATH } from './activation';
 
 export type LinkHandler = (url: string, via: string) => void;
-// Told when an app URL (not a perf-lab one) is handed to the app, before the
+// Told when an app URL (not a keepsnappy one) is handed to the app, before the
 // app sees it: the start of a link-driven navigation.
 export type AppLinkHandler = (url: string, via: string) => void;
 
 type UrlListener = (event: { url: string }) => void;
 
-// `<scheme>://devtools/perf-lab[/][?query][#fragment]`, also with an empty host
-// (`<scheme>:///devtools/perf-lab`). Universal links (http/https) never match,
+// `<scheme>://devtools/keepsnappy[/][?query][#fragment]`, also with an empty host
+// (`<scheme>:///devtools/keepsnappy`). Universal links (http/https) never match,
 // so a web page cannot route a link here.
-// Spells out PERF_LAB_DEEP_LINK_PATH.
-const SETTINGS_LINK = /^([a-z][a-z0-9+.-]*):\/\/\/?devtools\/perf-lab\/?(?:[?#]|$)/i;
+// Spells out KEEPSNAPPY_DEEP_LINK_PATH.
+const SETTINGS_LINK = /^([a-z][a-z0-9+.-]*):\/\/\/?devtools\/keepsnappy\/?(?:[?#]|$)/i;
 const WEB_SCHEMES = new Set(['http', 'https']);
 
-export const isPerfLabUrl = (url: unknown): url is string => {
-  if (typeof url !== 'string' || !url.includes(PERF_LAB_DEEP_LINK_PATH)) {
+export const isKeepSnappyUrl = (url: unknown): url is string => {
+  if (typeof url !== 'string' || !url.includes(KEEPSNAPPY_DEEP_LINK_PATH)) {
     return false;
   }
   const match = SETTINGS_LINK.exec(url);
@@ -126,7 +126,7 @@ const patch = (
 };
 
 const filterInitial = (url: unknown, via: string) => {
-  if (isPerfLabUrl(url)) {
+  if (isKeepSnappyUrl(url)) {
     apply(url, via);
     return null;
   }
@@ -157,7 +157,7 @@ export const installLinks = (
         return original(type, listener);
       }
       const filtered: UrlListener = event => {
-        if (isPerfLabUrl(event?.url)) {
+        if (isKeepSnappyUrl(event?.url)) {
           apply(event.url, 'event');
           return;
         }

package/js/sdk/net.ts

@@ -403,8 +403,8 @@ export type NetCounter = ReturnType<typeof createNetCounter>;
 // images loaded natively (Image, expo-image), WebSockets, and native SDKs
 // (Stream, LiveKit, Firebase).
 
-const WRAPPED = '__perflabNet';
-const XHR_STATE = '__perflabNetXhr';
+const WRAPPED = '__keepsnappyNet';
+const XHR_STATE = '__keepsnappyNetXhr';
 const EXPO_BUILTIN = Symbol.for('expo.builtin');
 
 type AnyFn = (...args: unknown[]) => unknown;

package/js/sdk/profile-export.ts

@@ -178,7 +178,7 @@ const changeDescription = (cause: UpdateCause) => ({
 
 export interface ReactExport {
   version: 5;
-  source: 'perflab';
+  source: 'keepsnappy';
   captureStart: { clock: 'perf-now-ms'; t0: number };
   dataForRoots: {
     rootID: number;
@@ -225,11 +225,11 @@ export const buildReactExport = (t0: number, commits: ExportCommit[]): ReactExpo
       passiveEffectDuration: null,
       priorityLevel: null,
       timestamp: Math.max(0, commit.t - t0),
-      perflabCauses: commit.causes,
-      perflabCarrier: commit.carrier,
-      perflabStore: commit.store,
-      perflabTask: commit.task,
-      ...(commit.facts ? { perflabFacts: commit.facts } : {}),
+      keepsnappyCauses: commit.causes,
+      keepsnappyCarrier: commit.carrier,
+      keepsnappyStore: commit.store,
+      keepsnappyTask: commit.task,
+      ...(commit.facts ? { keepsnappyFacts: commit.facts } : {}),
       updaters: (commit.updaters ?? []).map(displayName => ({
         displayName,
         hocDisplayNames: null,
@@ -241,7 +241,7 @@ export const buildReactExport = (t0: number, commits: ExportCommit[]): ReactExpo
   });
   return {
     version: 5,
-    source: 'perflab',
+    source: 'keepsnappy',
     captureStart: { clock: 'perf-now-ms', t0 },
     dataForRoots: [
       {