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

package/README.md

@@ -25,14 +25,14 @@ module.exports = withKeepSnappy(config);
 plugins: [/* ... */, '@keepsnappy/react-native'],
 ```
 
-Native code needs no further setup: Expo autolinking links the module from `expo-module.config.json` (iOS pod `PerfLab`, Android `expo.modules.perflab.PerfLabModule`) when the flag is on. Set `EXPO_PUBLIC_KEEPSNAPPY` the same way for `expo prebuild` (or the EAS build) and for the JS bundle, then `pod install` / rebuild.
+Native code needs no further setup: Expo autolinking links the module from `expo-module.config.json` (iOS pod `KeepSnappy`, Android `expo.modules.keepsnappy.KeepSnappyModule`) when the flag is on. Set `EXPO_PUBLIC_KEEPSNAPPY` the same way for `expo prebuild` (or the EAS build) and for the JS bundle, then `pod install` / rebuild.
 
 ### What the config plugin does
 
 It decides whether the native module is linked, from `EXPO_PUBLIC_KEEPSNAPPY` at prebuild time:
 
-- **Flag off:** the package is excluded from Expo autolinking. iOS: the Podfile's `use_expo_modules!` becomes `use_expo_modules!({ exclude: ['<package>'] })` (this also reaches the `expo-configure-project.sh` build phase that regenerates `ExpoModulesProvider.swift`). Android: `expoAutolinking.exclude` is set in `settings.gradle` before `expoAutolinking.useExpoModules()`. `expo-modules-autolinking` 57 reads exclusions only from the app's `package.json` and from these call sites. Result: no `PerfLab` pod, no Android project, no provider entry.
-- **Flag on:** the exclusion is removed again (prebuild without `--clean` edits existing files) and `extra.perflab = { native: true, profilingRenderer }` is added to the app config, so flag-on and flag-off builds have different native fingerprints. `profilingRenderer` is `always` (`KEEPSNAPPY_REACT_PROFILING=1`), `switch` (`=switch`) or `off`, read at prebuild time, so the three builds fingerprint differently too. Set `KEEPSNAPPY_REACT_PROFILING` the same way for prebuild and for the bundle.
+- **Flag off:** the package is excluded from Expo autolinking. iOS: the Podfile's `use_expo_modules!` becomes `use_expo_modules!({ exclude: ['<package>'] })` (this also reaches the `expo-configure-project.sh` build phase that regenerates `ExpoModulesProvider.swift`). Android: `expoAutolinking.exclude` is set in `settings.gradle` before `expoAutolinking.useExpoModules()`. `expo-modules-autolinking` 57 reads exclusions only from the app's `package.json` and from these call sites. Result: no `KeepSnappy` pod, no Android project, no provider entry.
+- **Flag on:** the exclusion is removed again (prebuild without `--clean` edits existing files) and `extra.keepsnappy = { native: true, profilingRenderer }` is added to the app config, so flag-on and flag-off builds have different native fingerprints. `profilingRenderer` is `always` (`KEEPSNAPPY_REACT_PROFILING=1`), `switch` (`=switch`) or `off`, read at prebuild time, so the three builds fingerprint differently too. Set `KEEPSNAPPY_REACT_PROFILING` the same way for prebuild and for the bundle.
 
 A Podfile whose `use_expo_modules!` already takes arguments (or a settings.gradle without `expoAutolinking.useExpoModules()`) cannot be edited safely; with the flag off, prebuild then fails with a message saying what to add. No Info.plist, entitlement or manifest change is needed: the module only uses `os_signpost`/`OSLog`, `android.os.Trace`, logcat and the app's own files directory.
 
@@ -52,23 +52,23 @@ All values are read at **bundle time** (Expo CLI loads `.env*` into the Metro pr
 
 | Variable (current name) | Proposed public name | Values | Effect |
 |---|---|---|---|
-| `EXPO_PUBLIC_KEEPSNAPPY` | `PERFLAB` | `1` = on, anything else = off | Build flag. Off: Metro config untouched, SDK not in the bundle. On: hook polyfill + SDK boot in the bundle. |
+| `EXPO_PUBLIC_KEEPSNAPPY` | `KEEPSNAPPY` | `1` = on, anything else = off | Build flag. Off: Metro config untouched, SDK not in the bundle. On: hook polyfill + SDK boot in the bundle. |
 | `EXPO_PUBLIC_KEEPSNAPPY_MODE` | `KEEPSNAPPY_MODE` | `dormant` / `auto` | `auto`: measure from the first frame (same as `KEEPSNAPPY_AUTO=1`). `dormant`: nothing runs until activated (below); once activated the process measures like `auto`. Unset: `auto` if `KEEPSNAPPY_AUTO=1`, else manual (markers until a settings link turns collection on). |
 | `EXPO_PUBLIC_KEEPSNAPPY_AUTO` | `KEEPSNAPPY_AUTO` | `1` = on | Measure-only builds: collection (React hook walk, PerformanceObserver, log to console and native file) is on from the first frame, with no deep link needed. Off: only markers until a settings link turns collection on. Equivalent to `KEEPSNAPPY_MODE=auto`; `KEEPSNAPPY_MODE` wins when both are set. |
 | `EXPO_PUBLIC_KEEPSNAPPY_INGEST_URL` | `KEEPSNAPPY_INGEST_URL` | URL of the farm ingest (`POST /v1/ingest`) | Push client. Push is on only if both the URL and the key are set. |
-| `EXPO_PUBLIC_KEEPSNAPPY_KEY` | `KEEPSNAPPY_KEY` | ingest key | Sent as `x-perflab-key`. |
+| `EXPO_PUBLIC_KEEPSNAPPY_KEY` | `KEEPSNAPPY_KEY` | ingest key | Sent as `x-keepsnappy-key`. |
 | `EXPO_PUBLIC_KEEPSNAPPY_SAMPLER` | `KEEPSNAPPY_SAMPLER` | `auto` / `manual` / `off` | Native resource sampler default. Unset: `auto` when `KEEPSNAPPY_AUTO=1`, else `off`. |
 | `EXPO_PUBLIC_KEEPSNAPPY_SAMPLER_MS` | `KEEPSNAPPY_SAMPLER_MS` | ms, 250–60000 | Auto sampling interval (default 4000; windows also get a sample at open and at close). |
 | `EXPO_PUBLIC_KEEPSNAPPY_PROFILE` | `KEEPSNAPPY_PROFILE` | `1` = on | Default of `profile`: per-component update causes per window (any renderer), plus self/total ms and updaters with the profiling renderer (`react.profile`). |
-| `EXPO_PUBLIC_KEEPSNAPPY_REACT_EXPORT` | `KEEPSNAPPY_REACT_EXPORT` | `1` = on | Default of `rexport`: a React DevTools v5 export per window (`Documents/perf-lab/react-<process>-<window id>-<name>.json`, TraceSift's input). Inside a run (a run token is set) the files are held and written at `flush=1`; otherwise at window end. |
-| `EXPO_PUBLIC_KEEPSNAPPY_CPUPROF`, `..._CPUPROF_HZ` | `KEEPSNAPPY_CPUPROF` | `1` = on; Hz (default 250) | Default of `cpuprof`/`cpuhz`: Hermes sampling profiler (iOS), `Documents/perf-lab/cpu-<process>-<span>.cpuprofile`. Inside a run it samples from the first window to `flush=1` and stops and dumps there, so the synchronous dump never lands in a measured window; otherwise one file per span of overlapping windows, dumped when the last one ends. `<process>` is the launch's `processId` (startup line), so launches never overwrite each other. |
+| `EXPO_PUBLIC_KEEPSNAPPY_REACT_EXPORT` | `KEEPSNAPPY_REACT_EXPORT` | `1` = on | Default of `rexport`: a React DevTools v5 export per window (`Documents/keepsnappy/react-<process>-<window id>-<name>.json`, TraceSift's input). Inside a run (a run token is set) the files are held and written at `flush=1`; otherwise at window end. |
+| `EXPO_PUBLIC_KEEPSNAPPY_CPUPROF`, `..._CPUPROF_HZ` | `KEEPSNAPPY_CPUPROF` | `1` = on; Hz (default 250) | Default of `cpuprof`/`cpuhz`: Hermes sampling profiler (iOS), `Documents/keepsnappy/cpu-<process>-<span>.cpuprofile`. Inside a run it samples from the first window to `flush=1` and stops and dumps there, so the synchronous dump never lands in a measured window; otherwise one file per span of overlapping windows, dumped when the last one ends. `<process>` is the launch's `processId` (startup line), so launches never overwrite each other. |
 | `KEEPSNAPPY_REACT_PROFILING` (Metro process; also read by the config plugin) | | `1` / `switch` / unset | `1`: `withKeepSnappy` resolves RN's production renderer to `ReactFabric-profiling` (fiber durations, updaters), flag or not; for dedicated perf builds (docs/plans/37). `switch` (flag on only, ignored with the flag off): both Fabric renderers go into the bundle and each process loads one at launch (below). Unset: production renderer only. |
 
-Only the names above are read today. The proposed names drop the `EXPO_PUBLIC_` prefix because the values never need to be readable by app code: the transformer inlines them into the SDK only, so a non-prefixed `PERFLAB=1` would also keep the flag out of the app's own `process.env` surface and match the CLI / CI wording (`PERFLAB=1` in doc 23). Migration plan: accept both names (new name wins), then drop the old ones.
+Only the names above are read today. The proposed names drop the `EXPO_PUBLIC_` prefix because the values never need to be readable by app code: the transformer inlines them into the SDK only, so a non-prefixed `KEEPSNAPPY=1` would also keep the flag out of the app's own `process.env` surface and match the CLI / CI wording (`KEEPSNAPPY=1` in doc 23). Migration plan: accept both names (new name wins), then drop the old ones.
 
 ### Renderer switch (`KEEPSNAPPY_REACT_PROFILING=switch`)
 
-For a shared build (plan 40 §2.1): `withKeepSnappy` resolves `ReactFabric-prod` and `ReactFabric-profiling` to `js/renderer-switch.js`, which `require`s the profiling renderer when `__PERFLAB_ACTIVATION__.profile` is true and the production one otherwise. Both are in the bundle; only the chosen one is evaluated. The choice is made once, before React loads:
+For a shared build (plan 40 §2.1): `withKeepSnappy` resolves `ReactFabric-prod` and `ReactFabric-profiling` to `js/renderer-switch.js`, which `require`s the profiling renderer when `__KEEPSNAPPY_ACTIVATION__.profile` is true and the production one otherwise. Both are in the bundle; only the chosen one is evaluated. The choice is made once, before React loads:
 
 - **dormant build:** the activation's `profile` (link `activate=1&profile=1`), read by the hook polyfill. A process that is not activated, or whose activation expired, runs the production renderer, as without the switch. If the polyfill cannot reach the native module (Android may install `expo.modules` lazily), the boot module reads the activation and sets `profile` before the renderer loads;
 - **auto / manual build:** `EXPO_PUBLIC_KEEPSNAPPY_PROFILE=1`. The runtime `profile=1` link turns causes and render times on, but cannot change the renderer of a running process.
@@ -84,21 +84,21 @@ A dormant process installs nothing: `__REACT_DEVTOOLS_GLOBAL_HOOK__` is left as
 
 Activation is by settings link and **applies from the next launch**, never in the running process, so a process is wholly measured or wholly dormant and carries exactly one run token:
 
-| Link | Writes `perf-lab/activation.json` |
+| Link | Writes `keepsnappy/activation.json` |
 |---|---|
-| `devtools/perf-lab?activate=1&runToken=<pl_rt_…>&ttl=<s>&diag=1&profile=1&cpuprof=1&cpuhz=<Hz>` | `{ active: true, runToken, expiresAt, diag, profile, cpuprof }`; `ttl` default 7200 s, max 21600 s (the run token's own life); `diag` (default off) marks the launch as a diagnostic iteration; `profile` (default off) loads the profiling renderer in a switch build and turns causes and render times on; `cpuprof` (default off) stores a Hermes sampling rate in Hz: `1`/`true` means `cpuhz` (default 250), a number above 1 is the rate itself, clamped to 10–10000 |
-| `devtools/perf-lab?activate=0` | `{ active: false }`, every field off |
-| `devtools/perf-lab?runToken=<t>` | keeps the current activation, replaces the token (empty clears it); keeps `diag`, `profile` and `cpuprof` unless the link sets them |
+| `devtools/keepsnappy?activate=1&runToken=<pl_rt_…>&ttl=<s>&diag=1&profile=1&cpuprof=1&cpuhz=<Hz>` | `{ active: true, runToken, expiresAt, diag, profile, cpuprof }`; `ttl` default 7200 s, max 21600 s (the run token's own life); `diag` (default off) marks the launch as a diagnostic iteration; `profile` (default off) loads the profiling renderer in a switch build and turns causes and render times on; `cpuprof` (default off) stores a Hermes sampling rate in Hz: `1`/`true` means `cpuhz` (default 250), a number above 1 is the rate itself, clamped to 10–10000 |
+| `devtools/keepsnappy?activate=0` | `{ active: false }`, every field off |
+| `devtools/keepsnappy?runToken=<t>` | keeps the current activation, replaces the token (empty clears it); keeps `diag`, `profile` and `cpuprof` unless the link sets them |
 
 The launch that reads the record applies `profile` and `cpuprof` for its whole life (they switch the settings of the same name on; off leaves the build's env defaults). Records written before these fields existed read as both off.
 
-An expired activation is dormant. Uninstall and `clearState` remove the file. In a dormant (not activated) process the link wrapper only handles these parameters and `dump=1`, which answers with one `PERF_LAB dormant {json}` line on os_log / logcat (no file): hook, `fetch`/XHR wrapping, SDK global and link patch status. In auto and manual builds a `runToken` link applies at once, as before, and is also persisted, so a relaunched process keeps it until it expires.
+An expired activation is dormant. Uninstall and `clearState` remove the file. In a dormant (not activated) process the link wrapper only handles these parameters and `dump=1`, which answers with one `KEEPSNAPPY dormant {json}` line on os_log / logcat (no file): hook, `fetch`/XHR wrapping, SDK global and link patch status. In auto and manual builds a `runToken` link applies at once, as before, and is also persisted, so a relaunched process keeps it until it expires.
 
 Launch arguments as a second activation path are not implemented.
 
 ### Settings link (runtime)
 
-`<app scheme>://devtools/perf-lab?<params>` is intercepted before the router sees it (`Linking.getInitialURL`, `Linking.addEventListener('url')`, `expo-linking`'s `getLinkingURL` and `getInitialURL` are wrapped), so it never navigates the app.
+`<app scheme>://devtools/keepsnappy?<params>` is intercepted before the router sees it (`Linking.getInitialURL`, `Linking.addEventListener('url')`, `expo-linking`'s `getLinkingURL` and `getInitialURL` are wrapped), so it never navigates the app.
 
 | Param | Values | Meaning |
 |---|---|---|
@@ -110,8 +110,8 @@ Launch arguments as a second activation path are not implemented.
 | `runToken` | string, empty clears | Correlates pushed batches with a farm run (redacted in logs). Persisted; in a dormant build it applies from the next launch only |
 | `activate`, `ttl` | `1`/`0`, seconds | Activation of a dormant build, from the next launch (see above) |
 | `gc` | `1` | Force a Hermes GC now and log heap before/after |
-| `flush` | `1` | End the open windows and send every unsent line now; result as the `perflab.flushed` element (see Push). Ignored by a dormant process |
-| `dump` | `1` | Write a `startup` report now (its `activation` section has `mode: active`, the build mode and the next launch's activation); in a dormant process: the `PERF_LAB dormant` line |
+| `flush` | `1` | End the open windows and send every unsent line now; result as the `keepsnappy.flushed` element (see Push). Ignored by a dormant process |
+| `dump` | `1` | Write a `startup` report now (its `activation` section has `mode: active`, the build mode and the next launch's activation); in a dormant process: the `KEEPSNAPPY dormant` line |
 | `sampler` | `auto` / `manual` / `off` | Native resource sampler mode |
 | `samplerMs` | 250–60000 | Auto sampling interval |
 | `sample` | `1` | Take one sample now (ignored when the sampler is off) |
@@ -126,23 +126,23 @@ With `activate=1` (or a bare `runToken`), `profile`, `cpuprof` and `cpuhz` are a
 
 With `EXPO_PUBLIC_KEEPSNAPPY_INGEST_URL` and `EXPO_PUBLIC_KEEPSNAPPY_KEY` set, every window line is queued for `POST /v1/windows`.
 
-- **Measured runs** (a dormant build that was activated, or any process started with a run token): nothing is sent while the run is active. Lines go to the log file and the push journal only. At the end of the iteration the flow opens `devtools/perf-lab?flush=1`: the SDK ends the open windows, sends every unsent line (retrying a failed batch up to 3 times) and then shows the result as an accessibility element for the driver, id `perflab.flushed`, label `ok` / `error` / `off` (no ingest configured), value with batch and line counts or the error. It is a transparent 1x1 pt view on the key window (iOS), created only on request in a measuring process; Android only logs `PERF_LAB flushed <status>` for now. A dormant process ignores `flush`.
+- **Measured runs** (a dormant build that was activated, or any process started with a run token): nothing is sent while the run is active. Lines go to the log file and the push journal only. At the end of the iteration the flow opens `devtools/keepsnappy?flush=1`: the SDK ends the open windows, sends every unsent line (retrying a failed batch up to 3 times) and then shows the result as an accessibility element for the driver, id `keepsnappy.flushed`, label `ok` / `error` / `off` (no ingest configured), value with batch and line counts or the error. It is a transparent 1x1 pt view on the key window (iOS), created only on request in a measuring process; Android only logs `KEEPSNAPPY flushed <status>` for now. A dormant process ignores `flush`.
 - **Other builds:** idle flush after 10 s, never while a window is open, and when the app goes to the background, as before.
 
 Maestro, end of an iteration:
 
 ```yaml
-- openLink: <scheme>://devtools/perf-lab?flush=1&activate=0
+- openLink: <scheme>://devtools/keepsnappy?flush=1&activate=0
 - extendedWaitUntil:
     visible:
-      id: perflab.flushed
+      id: keepsnappy.flushed
     timeout: 60000
 - assertVisible:
-    id: perflab.flushed
+    id: keepsnappy.flushed
     text: ok
 ```
 
-The run token is stamped on each line when it is queued, and a batch never mixes tokens, so a window belongs to the run that was current when it was recorded. Every queued line is also journalled in `perf-lab/push-spool.jsonl` (with its token); delivered lines are marked done and the journal is emptied whenever the queue drains. A process that starts pushing first queues what earlier processes recorded and never sent, ahead of its own lines and with their own tokens. A batch id names exactly its lines (process, first and last sequence, count), and the batch is journalled before it is first sent, so a later process resends the same lines under the same id: the server drops a replay it already stored and never drops lines it does not have. The journal is read at the first idle send or at the `flush=1` link, never at startup or inside a measured window, and is rewritten to the live queue whenever it passes twice the queue caps; lines dropped by the cap are counted (`dropped`, `resumeDropped`) across processes. On Android, `activation.json` and the journal live in internal storage (`filesDir`); only logs and dumps go to external storage. An install from before that move has both files moved in at the first state access, and the external copies deleted.
+The run token is stamped on each line when it is queued, and a batch never mixes tokens, so a window belongs to the run that was current when it was recorded. Every queued line is also journalled in `keepsnappy/push-spool.jsonl` (with its token); delivered lines are marked done and the journal is emptied whenever the queue drains. A process that starts pushing first queues what earlier processes recorded and never sent, ahead of its own lines and with their own tokens. A batch id names exactly its lines (process, first and last sequence, count), and the batch is journalled before it is first sent, so a later process resends the same lines under the same id: the server drops a replay it already stored and never drops lines it does not have. The journal is read at the first idle send or at the `flush=1` link, never at startup or inside a measured window, and is rewritten to the live queue whenever it passes twice the queue caps; lines dropped by the cap are counted (`dropped`, `resumeDropped`) across processes. On Android, `activation.json` and the journal live in internal storage (`filesDir`); only logs and dumps go to external storage. An install from before that move has both files moved in at the first state access, and the external copies deleted.
 
 ### Profile files of a run
 
@@ -159,7 +159,7 @@ Inside a run, at `flush=1` the SDK keeps the raw files plan 40 §3.3 asks for:
 - in a diagnostic iteration (`diag`), every `.cpuprofile` and React export;
 - otherwise only the files that cover a window with a commit over the device frame budget or a long task > 50 ms.
 
-It lists them in `perf-lab/artifacts-<processId>.json` and, after the lines, uploads them: a signed URL from `POST /v1/artifacts`, then a gzip PUT by the native module, then `complete` (contract in plan 40 §3.6). It never uploads while a window is open. A missing endpoint (404), a missing native function (older binary) or no ingest config leaves the files on the device with the reason in the manifest. The flush still ends normally, and its detail gets `artifacts=<uploaded>/<total>`. Each file goes up under the run token that was current when it was recorded, also when a later link changed the token (the token is kept in memory, never in the manifest). The native upload streams the gzip through a temp file on Android, maps the file on iOS, and skips a file over the API's 64 MiB cap without reading it.
+It lists them in `keepsnappy/artifacts-<processId>.json` and, after the lines, uploads them: a signed URL from `POST /v1/artifacts`, then a gzip PUT by the native module, then `complete` (contract in plan 40 §3.6). It never uploads while a window is open. A missing endpoint (404), a missing native function (older binary) or no ingest config leaves the files on the device with the reason in the manifest. The flush still ends normally, and its detail gets `artifacts=<uploaded>/<total>`. Each file goes up under the run token that was current when it was recorded, also when a later link changed the token (the token is kept in memory, never in the manifest). The native upload streams the gzip through a temp file on Android, maps the file on iOS, and skips a file over the API's 64 MiB cap without reading it.
 
 ### What caused the work (REQ-MEAS-32)
 
@@ -168,16 +168,16 @@ A window ends at the next action, so it also catches work the test only waits th
 - A cause follows the code it started through timers, animation frames, microtasks, `Promise.prototype.then` (so `await` on Hermes), `XMLHttpRequest` responses, WebSocket open/close, React's scheduler tasks and the first `onLayout`/`onLoad` of the views it mounted. Scrolling, momentum, gesture-handler, refresh and slider events belong to the latest touch while it is the newest action (after a deep link they have no cause until the next touch: a push can scroll the list of the screen the link opened); other host events, including the pager-view page events, have no cause.
 - A commit is foreign to a window when every cause is a push or an action older than the window's anchor (the newest action when the window started). It then counts in `react.external.<source>` (`commits`, `renderMs`) instead of every other `react.*` field. Anything else, including work with no cause and other native events, stays in the window.
 - Foreign work that no open window takes, including a back-dated window that opens later, goes to a window `background:<source>` (kind `background`: `websocket`, `launch`, `link`, `touch`), open from its first commit until the app leaves the foreground or the flush. A commit is routed there only when every window ends (app background or flush), so a back-dated window that opens later still takes it however many commits came after; the recent-commit ring bounds only `react.backfill` of judged work. The foreign commits that left the ring wait in memory until that end, each with its profile and, with the React export on, its exported fibers: on the S23 TapIn "join live" iteration that is about 71 push commits (the chat burst, 6 A/A exports), and the flush at the end of every iteration empties the list. It has `react` only.
-- The React export marks each commit with `perflabCauses`; every window carries `react.causes.awaitThroughThen`.
-- A timer callback that runs after a newer action than the one its registration carries is a carried tick: its work keeps the old cause (so it stays foreign to later windows) and is counted again in `react.external.<source>.timerCarried`, the upper bound of work a queue-serving timer did for the open window. Every run of the callback is its own tick, for repeating and re-registering timers alike; a run that starts a request (itself or in a continuation) is `timer-net` while the request counter runs (`react.causes.requestsMarked`). The export marks each commit with `perflabCarrier`.
-- A zustand store write made under a carried tick, to a store whose last write came from a newer action, runs under that action (`withKeepSnappy` resolves `zustand/vanilla` to `js/zustand-vanilla.js`, which routes every store's `setState` through the tracker): a timer that serves a queue does the work of the action that queued it. A store remembers the newest action that wrote it. The export marks such commits with `perflabStore` (`touch#3>touch#9`) and `perflabTask` (their causes and carrier without the move); the app must have one zustand copy; `react.causes.storesWrapped` says how many stores the wrapper saw (0: none can move).
+- The React export marks each commit with `keepsnappyCauses`; every window carries `react.causes.awaitThroughThen`.
+- A timer callback that runs after a newer action than the one its registration carries is a carried tick: its work keeps the old cause (so it stays foreign to later windows) and is counted again in `react.external.<source>.timerCarried`, the upper bound of work a queue-serving timer did for the open window. Every run of the callback is its own tick, for repeating and re-registering timers alike; a run that starts a request (itself or in a continuation) is `timer-net` while the request counter runs (`react.causes.requestsMarked`). The export marks each commit with `keepsnappyCarrier`.
+- A zustand store write made under a carried tick, to a store whose last write came from a newer action, runs under that action (`withKeepSnappy` resolves `zustand/vanilla` to `js/zustand-vanilla.js`, which routes every store's `setState` through the tracker): a timer that serves a queue does the work of the action that queued it. A store remembers the newest action that wrote it. The export marks such commits with `keepsnappyStore` (`touch#3>touch#9`) and `keepsnappyTask` (their causes and carrier without the move); the app must have one zustand copy; `react.causes.storesWrapped` says how many stores the wrapper saw (0: none can move).
 - The commit stream (`js/sdk/stream.ts`) records every commit of the process once, with its cause facts (root ids, timer runs, store writes, render time or `null`) and the tables of roots, runs and writes, in segment files `stream-<process>-<seq>.json` kept in every run (artifact kind `commit-stream`). The backend replays the split from it; until it does, the window values above are the SDK's own.
 
 Known limits: a server reply to a tap that arrives over the WebSocket is foreign, and so is a screen the app opens from a socket handler; direct JSI calls into JS (Reanimated `runOnJS`) carry no cause and stay in the window.
 
 ### Native resource sampler
 
-Off unless enabled. `auto` samples every `samplerMs` on a native utility thread (no JS work); `manual` keeps only the frame counter running and samples on request (`sample=1` link or `__PERF_LAB__.sample()`), plus one sample when each window opens and one when it closes in `auto` and `manual`. Every sample is one `PERF_LAB sample {json}` line in the native log (os_log + `Documents/perf-lab/log.txt` on iOS, logcat on Android), whatever the `log` sink. Windows get a `sampler` object (footprint start/end/delta, CPU cores, frames missed, longest frame gap) when samples bracket them. Record format and limits: `docs/research/31-native-sampler.md`.
+Off unless enabled. `auto` samples every `samplerMs` on a native utility thread (no JS work); `manual` keeps only the frame counter running and samples on request (`sample=1` link or `__KEEPSNAPPY__.sample()`), plus one sample when each window opens and one when it closes in `auto` and `manual`. Every sample is one `KEEPSNAPPY sample {json}` line in the native log (os_log + `Documents/keepsnappy/log.txt` on iOS, logcat on Android), whatever the `log` sink. Windows get a `sampler` object (footprint start/end/delta, CPU cores, frames missed, longest frame gap) when samples bracket them. Record format and limits: `docs/research/31-native-sampler.md`.
 
 ### Network requests
 
@@ -203,7 +203,7 @@ The first screen window of the process is the launch screen (REQ-MEAS-22): it st
 
 ### App log lines
 
-`globalThis.__PERF_LAB__?.log(message)` writes `PERF_LAB app <message>` to the native log (and the console), the same file and stream as the SDK's own lines, whatever the `log` sink. `__PERF_LAB__` exists only when the SDK is in the bundle.
+`globalThis.__KEEPSNAPPY__?.log(message)` writes `KEEPSNAPPY app <message>` to the native log (and the console), the same file and stream as the SDK's own lines, whatever the `log` sink. `__KEEPSNAPPY__` exists only when the SDK is in the bundle.
 
 ## Layout
 
@@ -212,9 +212,9 @@ The first screen window of the process is the launch screen (REQ-MEAS-22): it st
 | `metro.js` | `@keepsnappy/react-native/metro`: `withKeepSnappy(config)` |
 | `app.plugin.js` | Expo config plugin: excludes the native module from autolinking when the flag is off |
 | `expo-module.config.json` | Expo autolinking for the native module |
-| `ios/PerfLab.podspec`, `ios/PerfLabModule.swift` | iOS: signposts, OSLog, log file in Documents/perf-lab |
-| `ios/PerfLabSampler.swift` | iOS: resource sampler (task_vm_info, thread CPU, CADisplayLink frames) |
-| `android/build.gradle`, `android/src/...` | Android: `Trace` sections, logcat, log file, resource sampler (`PerfLabSampler.kt`, untested on device) |
+| `ios/KeepSnappy.podspec`, `ios/KeepSnappyModule.swift` | iOS: signposts, OSLog, log file in Documents/keepsnappy |
+| `ios/KeepSnappySampler.swift` | iOS: resource sampler (task_vm_info, thread CPU, CADisplayLink frames) |
+| `android/build.gradle`, `android/src/...` | Android: `Trace` sections, logcat, log file, resource sampler (`KeepSnappySampler.kt`, untested on device) |
 | `js/sdk/sampler.ts` | Sampler settings parsing and per-window aggregation (pure) |
 | `js/sdk/net.ts`, `net-install.ts` | Request counter and fetch/XHR hooks (pure), and their wiring |
 | `js/hook.polyfill.js` | React DevTools hook (Metro polyfill, ES5, no `require`) |
@@ -234,7 +234,7 @@ The package has no JS entry point (`main`) on purpose: app code never imports it
 ## Local development
 
 ```sh
-bun install            # at the perflab repo root (workspace)
+bun install            # at the keepsnappy repo root (workspace)
 bun run typecheck      # in packages/react-native: SDK (tsconfig.json) + tests (tsconfig.test.json)
 bun test
 ```
@@ -247,7 +247,7 @@ The app consumes a packed tarball, the same artifact npm would serve:
 # in packages/react-native
 bun run pack:local                 # -> dist/keepsnappy-react-native-0.1.0.tgz (dist/ is gitignored)
 # in the app
-bun add @keepsnappy/react-native@file:../perflab/packages/react-native/dist/keepsnappy-react-native-0.1.0.tgz
+bun add @keepsnappy/react-native@file:../keepsnappy/packages/react-native/dist/keepsnappy-react-native-0.1.0.tgz
 ```
 
 After editing the package, run both commands again (re-adding refreshes the integrity hash in `bun.lock`), then rebuild the JS bundle with `--reset-cache`; `pod install` only when native files changed. Bun 1.4 caches a `file:` tarball by path under `~/.bun/install/cache/@T@<hash>@@@1` and reuses it while the version is unchanged, so a repack with the same version can install the old contents: delete those entries (their `package.json` names the package), install with a fresh cache (`BUN_INSTALL_CACHE_DIR=$(mktemp -d) bun add …`, which also refreshes the `bun.lock` integrity) or bump the version, and check with `diff -r node_modules/@keepsnappy/react-native/js <repo>/packages/react-native/js`.
@@ -256,6 +256,6 @@ Why not a folder `file:` dependency or `bun link`: for a folder outside the app,
 
 ## Store builds
 
-With the flag off the JS bundle carries no SDK code (check: `grep -c __PERFLAB_HOOK__ main.jsbundle` is 0) and, after a prebuild with the flag off, the binary carries no SDK native code (no `PerfLab` in `Podfile.lock`, in `ExpoModulesProvider.swift` or in the app binary's symbols).
+With the flag off the JS bundle carries no SDK code (check: `grep -c __KEEPSNAPPY_HOOK__ main.jsbundle` is 0) and, after a prebuild with the flag off, the binary carries no SDK native code (no `KeepSnappy` in `Podfile.lock`, in `ExpoModulesProvider.swift` or in the app binary's symbols).
 
-Use `EXPO_PUBLIC_KEEPSNAPPY*`, `KEEPSNAPPY_*`, and `withKeepSnappy`. Previous build environment names and `withPerfLab` are no longer supported. Native module identities, stored records and wire formats are unchanged.
+Use `EXPO_PUBLIC_KEEPSNAPPY*`, `KEEPSNAPPY_*`, and `withKeepSnappy`. Previous build environment names and `withKeepSnappy` are no longer supported. Native module identities, stored records and wire formats are unchanged.

package/android/build.gradle

@@ -2,11 +2,11 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'expo-module-gradle-plugin'
 
-group = 'expo.modules.perflab'
+group = 'expo.modules.keepsnappy'
 version = '1.0.0'
 
 android {
-  namespace "expo.modules.perflab"
+  namespace "expo.modules.keepsnappy"
   compileSdk safeExtGet("compileSdkVersion", 34)
 
   defaultConfig {

package/android/src/main/java/expo/modules/{perflab/PerfLabModule.kt → keepsnappy/KeepSnappyModule.kt}

@@ -1,4 +1,4 @@
-package expo.modules.perflab
+package expo.modules.keepsnappy
 
 import android.app.Activity
 import android.content.BroadcastReceiver
@@ -31,11 +31,11 @@ import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.zip.GZIPOutputStream
 
-private const val TAG = "PERF_LAB"
+private const val TAG = "KEEPSNAPPY"
 
 // The element the test driver waits for after the flush link; same id as on iOS.
-private const val FLUSH_ELEMENT_ID = "perflab.flushed"
-private const val FLUSH_ELEMENT_TAG = "perflab.flushed.view"
+private const val FLUSH_ELEMENT_ID = "keepsnappy.flushed"
+private const val FLUSH_ELEMENT_TAG = "keepsnappy.flushed.view"
 private const val FLUSH_ELEMENT_DP = 8
 // Alpha 1 of 255: drawn, so it counts as visible, but no pixel changes on screen.
 private const val FLUSH_ELEMENT_BACKGROUND = 0x01000000
@@ -58,7 +58,7 @@ private val LEGACY_STATE_FILES = listOf("activation.json", "push-spool.jsonl")
 // do work before a function is called (a dormant build calls activationRead only).
 // UNTESTED ON DEVICE (activation, spool): compiled only, like the sampler.
 // NOT YET COMPILED: moveLegacyState and the streamed uploadArtifact (night of 2026-10-14).
-class PerfLabModule : Module() {
+class KeepSnappyModule : Module() {
   private val mainHandler = Handler(Looper.getMainLooper())
 
   // GC before the action: the driver's command arrives as a broadcast, which pauses no activity (a link does, and the app
@@ -84,7 +84,7 @@ class PerfLabModule : Module() {
               resultData = "bad command"
               return
             }
-            val tNative = perfLabMonotonicMs()
+            val tNative = keepSnappyMonotonicMs()
             pendingCommands.remove(n)?.finish()
             val pending = goAsync()
             pendingCommands[n] = pending
@@ -94,22 +94,22 @@ class PerfLabModule : Module() {
                 pending.finish()
               }
             }, commandDeadlineMs)
-            sendEvent("perflabCommand", mapOf("cmd" to cmd, "n" to n, "tNative" to tNative))
+            sendEvent("keepsnappyCommand", mapOf("cmd" to cmd, "n" to n, "tNative" to tNative))
           }
         }
-        val filter = IntentFilter("${context.packageName}.perflab.COMMAND")
+        val filter = IntentFilter("${context.packageName}.keepsnappy.COMMAND")
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
           context.registerReceiver(receiver, filter, Context.RECEIVER_EXPORTED)
         } else {
           context.registerReceiver(receiver, filter)
         }
         commandReceiver = receiver
-        writeLog("PERF_LAB command receiver on")
+        writeLog("KEEPSNAPPY command receiver on")
       } else if (!on && commandReceiver != null) {
         try { context.unregisterReceiver(commandReceiver) } catch (e: Exception) {}
         commandReceiver = null
         for (n in pendingCommands.keys.toList()) pendingCommands.remove(n)?.finish()
-        writeLog("PERF_LAB command receiver off")
+        writeLog("KEEPSNAPPY command receiver off")
       }
     }
   }
@@ -117,7 +117,7 @@ class PerfLabModule : Module() {
   private fun showFlushElement(status: String) {
     val activity = appContext.currentActivity
     if (activity == null) {
-      writeLog("PERF_LAB flush element not shown: no foreground activity ($status)")
+      writeLog("KEEPSNAPPY flush element not shown: no foreground activity ($status)")
       return
     }
     mainHandler.post {
@@ -143,17 +143,17 @@ class PerfLabModule : Module() {
   private var samplerCreated = false
   private val sampler by lazy {
     samplerCreated = true
-    PerfLabSampler({ appContext.reactContext }, { appContext.currentActivity }, ::writeLog)
+    KeepSnappySampler({ appContext.reactContext }, { appContext.currentActivity }, ::writeLog)
   }
   private val io: ExecutorService by lazy {
-    Executors.newSingleThreadExecutor { r -> Thread(r, "perflab-io") }
+    Executors.newSingleThreadExecutor { r -> Thread(r, "keepsnappy-io") }
   }
 
   // activation.json and the push journal (run tokens) live in internal storage: on Android 9
   // and older another app with storage permission could read or plant files in external storage.
   private fun stateDir(create: Boolean): File? {
     val context = appContext.reactContext ?: return null
-    val dir = File(context.filesDir ?: return null, "perf-lab")
+    val dir = File(context.filesDir ?: return null, "keepsnappy")
     moveLegacyState(context, dir)
     if (create) dir.mkdirs()
     return dir
@@ -170,7 +170,7 @@ class PerfLabModule : Module() {
       if (legacyChecked) return
       legacyChecked = true
       val external = try { context.getExternalFilesDir(null) } catch (e: Exception) { null }
-      val old = external?.let { File(it, "perf-lab") } ?: return
+      val old = external?.let { File(it, "keepsnappy") } ?: return
       for (name in LEGACY_STATE_FILES) {
         val from = File(old, name)
         if (!from.exists()) continue
@@ -217,7 +217,7 @@ class PerfLabModule : Module() {
   private fun uploadArtifact(fileName: String, url: String, headers: Map<String, String>, timeoutMs: Double): Map<String, Any?> {
     val context = appContext.reactContext
     val base = context?.getExternalFilesDir(null)
-    val file = base?.let { File(File(it, "perf-lab"), fileName.replace('/', '_')) }
+    val file = base?.let { File(File(it, "keepsnappy"), fileName.replace('/', '_')) }
     if (context == null || file == null || !file.exists()) {
       return mapOf("status" to 0, "error" to "file missing")
     }
@@ -226,7 +226,7 @@ class PerfLabModule : Module() {
       return mapOf("status" to 413, "error" to "file is $length bytes, over $ARTIFACT_MAX_BYTES")
     }
     val gzFile = try {
-      File.createTempFile("perflab-upload-", ".gz", context.cacheDir)
+      File.createTempFile("keepsnappy-upload-", ".gz", context.cacheDir)
     } catch (e: Exception) {
       return mapOf("status" to 0, "bytes" to length.toInt(), "error" to "temp file: $e")
     }
@@ -282,9 +282,9 @@ class PerfLabModule : Module() {
   }
 
   override fun definition() = ModuleDefinition {
-    Name("PerfLab")
+    Name("KeepSnappy")
 
-    Events("perflabCommand")
+    Events("keepsnappyCommand")
 
     // Sync functions: called on the JS thread through JSI, no bridge hop, so a
     // marker lands at the moment JS asks for it.
@@ -335,7 +335,7 @@ class PerfLabModule : Module() {
     }
 
     Function("samplerNow") {
-      perfLabMonotonicMs()
+      keepSnappyMonotonicMs()
     }
 
     OnDestroy {
@@ -376,10 +376,10 @@ class PerfLabModule : Module() {
     }
 
     // iOS shows the flush result as an accessibility element; Android adds a 1x1 transparent view
-    // (contentDescription `perflab.flushed`, text = status) to the foreground activity's decor view;
+    // (contentDescription `keepsnappy.flushed`, text = status) to the foreground activity's decor view;
     // like iOS it stays until the next flush replaces it or the process ends. Always logged too.
     Function("flushSignal") { status: String, detail: String ->
-      writeLog("PERF_LAB flushed $status $detail")
+      writeLog("KEEPSNAPPY flushed $status $detail")
       showFlushElement(status)
     }
 
@@ -435,7 +435,7 @@ class PerfLabModule : Module() {
     Function("writeText") { fileName: String, content: String ->
       val context = appContext.reactContext ?: return@Function null
       val base = context.getExternalFilesDir(null) ?: return@Function null
-      val dir = File(base, "perf-lab")
+      val dir = File(base, "keepsnappy")
       dir.mkdirs()
       val file = File(dir, fileName.replace('/', '_'))
       file.writeText(content)

package/android/src/main/java/expo/modules/{perflab/PerfLabSampler.kt → keepsnappy/KeepSnappySampler.kt}

@@ -1,4 +1,4 @@
-package expo.modules.perflab
+package expo.modules.keepsnappy
 
 import android.app.Activity
 import android.app.Application
@@ -25,7 +25,7 @@ import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.TimeUnit
 
 // System.nanoTime() is CLOCK_MONOTONIC, the clock of performance.now() in React Native.
-internal fun perfLabMonotonicMs(): Double = System.nanoTime() / 1_000_000.0
+internal fun keepSnappyMonotonicMs(): Double = System.nanoTime() / 1_000_000.0
 
 // PowerManager.THERMAL_STATUS_* (0 none .. 6 shutdown) mapped to the iOS ProcessInfo.thermalState
 // scale (0 nominal .. 3 critical) that derive and the heat rule read (`thermal >= 2` = serious):
@@ -34,7 +34,7 @@ private const val THERMAL_ANDROID_MODERATE = 2
 private const val THERMAL_ANDROID_SEVERE = 3
 private const val THERMAL_ANDROID_CRITICAL = 4
 
-internal fun perfLabThermalLevel(raw: Int): Int = when {
+internal fun keepSnappyThermalLevel(raw: Int): Int = when {
   raw >= THERMAL_ANDROID_CRITICAL -> 3
   raw >= THERMAL_ANDROID_SEVERE -> 2
   raw >= THERMAL_ANDROID_MODERATE -> 1
@@ -53,7 +53,7 @@ private val JS_THREAD_NAMES = listOf("mqt_v_js", "mqt_js")
 // Counts presented and missed frames on the main thread's Choreographer. The budget follows the
 // display's current refresh rate (read off the frame path), so 90/120 Hz screens are judged right.
 // The callback allocates nothing: it reuses itself and touches only primitive fields.
-internal class PerfLabFrameCounter : Choreographer.FrameCallback {
+internal class KeepSnappyFrameCounter : Choreographer.FrameCallback {
   private val lock = Any()
   private val main = Handler(Looper.getMainLooper())
   @Volatile private var running = false
@@ -127,7 +127,7 @@ internal const val JANK_BASIS_DISPLAY_RATE = "display-rate"
 // interval. Not seen: other windows (RN Modal dialogs, popups) and SurfaceView/TextureView content (video, Skia canvases);
 // `windowCovered` says another window held focus during the interval, so the counts of that interval are unknown.
 // Follows the foreground activity through lifecycle callbacks; the listener runs on its own thread, never the UI thread.
-internal class PerfLabFrameMetrics(private val context: () -> Context?) :
+internal class KeepSnappyFrameMetrics(private val context: () -> Context?) :
   Window.OnFrameMetricsAvailableListener, Application.ActivityLifecycleCallbacks, ViewTreeObserver.OnWindowFocusChangeListener {
   private class Frame(val endNs: Long, val jank: Boolean, val firstDraw: Boolean, val durationNs: Long, val dropped: Int)
 
@@ -151,7 +151,7 @@ internal class PerfLabFrameMetrics(private val context: () -> Context?) :
   fun start(current: Activity?) {
     if (thread != null) return
     val app = context()?.applicationContext as? Application ?: return
-    val t = HandlerThread("perflab-framemetrics").also { it.start() }
+    val t = HandlerThread("keepsnappy-framemetrics").also { it.start() }
     thread = t
     handler = Handler(t.looper)
     application = app
@@ -259,16 +259,16 @@ internal class PerfLabFrameMetrics(private val context: () -> Context?) :
 
 // Off unless configured. `auto` samples on its own thread every intervalMs and needs no JS;
 // `manual` only keeps the frame counter running and samples when asked. Every sample is logged
-// as `PERF_LAB sample {json}` and kept in a short ring for windows.
+// as `KEEPSNAPPY sample {json}` and kept in a short ring for windows.
 // UNTESTED ON DEVICE: written against the iOS implementation, compiled only.
-internal class PerfLabSampler(
+internal class KeepSnappySampler(
   private val context: () -> Context?,
   private val activity: () -> Activity?,
   private val log: (String) -> Unit,
 ) {
   private val lock = Any()
-  private val frames = PerfLabFrameCounter()
-  private val frameMetrics = PerfLabFrameMetrics(context)
+  private val frames = KeepSnappyFrameCounter()
+  private val frameMetrics = KeepSnappyFrameMetrics(context)
   private var executor: ScheduledExecutorService? = null
   private var mode = "off"
   private var intervalMs = SAMPLER_MS_DEFAULT
@@ -303,14 +303,14 @@ internal class PerfLabSampler(
       maxHz = maxRefreshHz()
       frames.start()
       frameMetrics.start(activity())
-      val ex = Executors.newSingleThreadScheduledExecutor { r -> Thread(r, "perflab-sampler") }
+      val ex = Executors.newSingleThreadScheduledExecutor { r -> Thread(r, "keepsnappy-sampler") }
       if (mode == "auto") {
         val period = intervalMs.toLong()
         ex.scheduleAtFixedRate({ synchronized(lock) { collect("auto") } }, period, period, TimeUnit.MILLISECONDS)
       }
       executor = ex
     }
-    mapOf("mode" to mode, "intervalMs" to intervalMs, "nowMs" to perfLabMonotonicMs())
+    mapOf("mode" to mode, "intervalMs" to intervalMs, "nowMs" to keepSnappyMonotonicMs())
   }
 
   fun sample(reason: String): Map<String, Any?>? = synchronized(lock) {
@@ -372,7 +372,7 @@ internal class PerfLabSampler(
   // figure: modes report 120.00001 for a 120 Hz panel.
   private fun maxRefreshHz(): Int {
     val modes = display()?.supportedModes ?: return 0
-    log("PERF_LAB display modes " + modes.joinToString(" ") { "${it.modeId}:${it.physicalWidth}x${it.physicalHeight}@${it.refreshRate}" })
+    log("KEEPSNAPPY display modes " + modes.joinToString(" ") { "${it.modeId}:${it.physicalWidth}x${it.physicalHeight}@${it.refreshRate}" })
     return modes.maxOfOrNull { Math.round(it.refreshRate) } ?: 0
   }
 
@@ -443,7 +443,7 @@ internal class PerfLabSampler(
   }
 
   private fun collect(reason: String): Map<String, Any?> {
-    val started = perfLabMonotonicMs()
+    val started = keepSnappyMonotonicMs()
     val t = started
     val processMs = Process.getElapsedCpuTime().toDouble()
     val mainMs = statCpuMs("/proc/self/task/${Process.myPid()}/stat")
@@ -484,7 +484,7 @@ internal class PerfLabSampler(
       "mem" to memory,
     )
     thermalRaw()?.let {
-      record["thermal"] = perfLabThermalLevel(it)
+      record["thermal"] = keepSnappyThermalLevel(it)
       record["thermalRaw"] = it
     }
     val prev = previous
@@ -505,11 +505,11 @@ internal class PerfLabSampler(
     )
     record["cpu"] = cpu
     record["frames"] = framesOut
-    record["collectMs"] = perfLabMonotonicMs() - started
+    record["collectMs"] = keepSnappyMonotonicMs() - started
 
     ring.addLast(record)
     while (ring.size > ringSize) ring.removeFirst()
-    log("PERF_LAB sample ${JSONObject(record as Map<*, *>)}")
+    log("KEEPSNAPPY sample ${JSONObject(record as Map<*, *>)}")
     return record
   }
 }

package/app.plugin.js

@@ -1,6 +1,6 @@
-// Expo config plugin for the PerfLab SDK.
+// Expo config plugin for the KeepSnappy SDK.
 //
-// The native module (iOS pod PerfLab, Android expo.modules.perflab) is linked
+// The native module (iOS pod KeepSnappy, Android expo.modules.keepsnappy) is linked
 // by Expo autolinking from expo-module.config.json. With the build flag off
 // (EXPO_PUBLIC_KEEPSNAPPY is not "1" when `expo prebuild` runs) this plugin
 // excludes the package from Expo autolinking, so a store build carries no SDK
@@ -20,8 +20,7 @@ const { withPodfile, withSettingsGradle } = require('expo/config-plugins');
 const PACKAGE_NAME = require('./package.json').name;
 const PACKAGE_NAMES = [...new Set([PACKAGE_NAME, '@keepsnappy/react-native'])];
 const namesFor = name => name === PACKAGE_NAME ? PACKAGE_NAMES : [name];
-// Keep this generated-line marker stable so old exclusions can be removed.
-const TAG = 'perflab: native module excluded, EXPO_PUBLIC_PERF_LAB is not 1';
+const TAG = 'keepsnappy: native module excluded, EXPO_PUBLIC_KEEPSNAPPY is not 1';
 
 const isEnabled = () => (process.env.EXPO_PUBLIC_KEEPSNAPPY) === '1';
 
@@ -61,7 +60,9 @@ const gradleLine = (language, name) =>
     : `expoAutolinking.exclude = (expoAutolinking.exclude ?: []) + [${namesFor(name).map(quoted).join(', ')}] // ${TAG}`;
 
 const editSettingsGradle = (contents, enabled, language = 'groovy', name = PACKAGE_NAME) => {
-  const lines = contents.split('\n').filter(line => !line.includes(TAG));
+  // Match the generated statement independently of its branding comment.
+  const generated = ['groovy', 'kt'].map(dsl => gradleLine(dsl, name).split(' // ')[0]);
+  const lines = contents.split('\n').filter(line => !generated.includes(line.split(' // ')[0].trim()));
   if (enabled) {
     return lines.join('\n');
   }
@@ -81,7 +82,7 @@ const withKeepSnappy = config => {
   if (enabled) {
     config.extra = {
       ...config.extra,
-      perflab: { native: true, profilingRenderer: profilingRenderer() },
+      keepsnappy: { native: true, profilingRenderer: profilingRenderer() },
     };
   }
   config = withPodfile(config, mod => {

package/expo-module.config.json

@@ -1,9 +1,9 @@
 {
   "platforms": ["ios", "android"],
   "ios": {
-    "modules": ["PerfLabModule"]
+    "modules": ["KeepSnappyModule"]
   },
   "android": {
-    "modules": ["expo.modules.perflab.PerfLabModule"]
+    "modules": ["expo.modules.keepsnappy.KeepSnappyModule"]
   }
 }

package/ios/{PerfLab.podspec → KeepSnappy.podspec}

@@ -3,7 +3,7 @@ require 'json'
 package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
 
 Pod::Spec.new do |s|
-  s.name           = 'PerfLab'
+  s.name           = 'KeepSnappy'
   s.version        = package['version']
   s.summary        = package['description']
   s.description    = package['description']
@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   s.dependency 'hermes-engine'
 
   s.source_files = "*.{swift,h,mm}"
-  s.public_header_files = "PerfLabHermes.h"
+  s.public_header_files = "KeepSnappyHermes.h"
 
   s.pod_target_xcconfig = {
     'DEFINES_MODULE' => 'YES',

package/ios/{PerfLabHermes.h → KeepSnappyHermes.h}

@@ -4,7 +4,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 // Hermes sampling profiler (C++ API) for Swift. The runtime pointer is the
 // jsi::Runtime behind Expo's JavaScriptRuntime.withUnsafePointee.
-@interface PerfLabHermes : NSObject
+@interface KeepSnappyHermes : NSObject
 
 + (BOOL)startWithHz:(double)hz;
 + (BOOL)stop;

package/ios/{PerfLabHermes.mm → KeepSnappyHermes.mm}

@@ -1,4 +1,4 @@
-#import "PerfLabHermes.h"
+#import "KeepSnappyHermes.h"
 
 #include <fstream>
 #include <sstream>
@@ -13,7 +13,7 @@ static fh::IHermesRootAPI *rootAPI() {
   return jsi::castInterface<fh::IHermesRootAPI>(fh::makeHermesRootAPI());
 }
 
-@implementation PerfLabHermes
+@implementation KeepSnappyHermes
 
 + (BOOL)startWithHz:(double)hz {
   auto *api = rootAPI();