@keyframerdev/vitals 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Catalin Miron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,97 @@
-# Temporary Holding Version
+# @keyframerdev/vitals
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Motion Vitals for React Native: slow frames and janky animations from production, by screen and by
+the line of code that started the animation. Reports go to your project on
+[keyframer.dev](https://keyframer.dev/inspector/docs/vitals).
+
+- Safe for store builds: it never connects to Metro or a relay, never changes an animation, and does
+  no work while nothing moves.
+- JavaScript only: no native module and no config plugin. Works in Expo apps, Expo Go included.
+- Never sends screenshots, text, values, touches, identifiers or absolute times.
+
+Needs Reanimated 4.1 or later with `react-native-worklets` 0.5 or later (React Native 0.78 or later, New
+Architecture).
+
+## Install
+
+```sh
+npm i @keyframerdev/vitals
+```
+
+A regular dependency, not a dev dependency: it ships in your release build.
+
+## Start it
+
+At the app's entry, with the project's field key (`kfp_live_…`, public and write-only, safe to ship):
+
+```ts
+import { startVitals } from '@keyframerdev/vitals'
+import AsyncStorage from '@react-native-async-storage/async-storage'
+import * as Application from 'expo-application'
+
+startVitals({
+  key: 'kfp_live_…',
+  appVersion: Application.nativeApplicationVersion!,
+  build: Application.nativeBuildVersion ?? undefined,
+  navigationRef, // React Navigation's createNavigationContainerRef() or expo-router's useNavigationContainerRef()
+  storage: AsyncStorage, // optional: checkpoints, retries and the daily cap survive restarts
+})
+```
+
+Nothing is measured or sent before `startVitals`. If your app asks for consent, call it after.
+
+| Option | Default | What it does |
+| --- | --- | --- |
+| `key` | required | The project's field key |
+| `appVersion` | required | The version people see (`2.4.1`) |
+| `build` | none | The build number (`812`) |
+| `environment` | `'development'` when `__DEV__`, else `'production'` | Development reports are kept only when the project accepts development builds |
+| `sampleRate` | `0.1` | The share of sessions that report, until the project's settings say otherwise |
+| `navigationRef` | none | Screens are named from its routes |
+| `screenName` | the route's name | `(route) => string`, to name routes yourself (still masked) |
+| `storage` | none | Anything with `getItem`, `setItem` and `removeItem` (AsyncStorage, an MMKV wrapper) |
+| `device` | none | `{ model, memoryBytes, memoryGb, tier, displayHz }`, read by the app (for example from `expo-device`) |
+| `appId` | none | The bundle id or package name |
+| `endpoint` | `https://vitals.keyframer.dev` | The ingest server |
+
+## Call sites with file and line
+
+Add the Babel plugin, beside Reanimated's (react-native-worklets') plugin, in any order:
+
+```js
+// babel.config.js
+module.exports = function (api) {
+  api.cache(true)
+  return {
+    presets: ['babel-preset-expo'],
+    plugins: ['@keyframerdev/vitals/babel'],
+  }
+}
+```
+
+It tags each Reanimated animation, layout animation and animated scroll handler with where it is
+written, so the dashboard shows `app/feed.tsx:42:9 withSpring`, not only the screen. Without it, frames
+are still counted per screen. Restart Metro with a clean cache after changing Babel:
+`npx expo start -c`.
+
+To keep file paths out of the bundle, pass `{ hashSites: true, salt: 'kfp_live_…' }` and upload the
+sites file the build writes with
+[`@keyframerdev/vitals-cli`](https://www.npmjs.com/package/@keyframerdev/vitals-cli).
+
+## More
+
+```ts
+import { setVitalsEnabled, setVitalsScreen, VitalsRoot } from '@keyframerdev/vitals'
+
+setVitalsScreen('Checkout') // where navigation is not automatic
+setVitalsEnabled(false)     // stops now and drops what is pending; true starts again
+<VitalsRoot>{app}</VitalsRoot> // optional: touches open motion windows, so plain lists are measured while they scroll
+```
+
+Docs: [React Native setup](https://keyframer.dev/inspector/docs/vitals/react-native),
+[consent and privacy](https://keyframer.dev/inspector/docs/vitals/consent),
+[store privacy answers](https://keyframer.dev/inspector/docs/vitals/store-privacy).
+
+## License
+
+MIT

package/dist/babel.cjs

@@ -0,0 +1,451 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/babel.ts
+var exports_babel = {};
+__export(exports_babel, {
+  writeManifest: () => writeManifest,
+  manifestPath: () => manifestPath,
+  default: () => keyframerVitals,
+  appIdentity: () => appIdentity,
+  RUNTIME_MODULE: () => RUNTIME_MODULE,
+  PLUGIN_NAME: () => PLUGIN_NAME,
+  ANIMATION_FNS: () => ANIMATION_FNS
+});
+module.exports = __toCommonJS(exports_babel);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var PLUGIN_NAME = "keyframer-vitals";
+var RUNTIME_MODULE = "@keyframerdev/vitals/runtime";
+var INSPECTOR_PLUGIN = "keyframer-inspector";
+var INSPECTOR_RUNTIME = "@keyframerdev/inspector/runtime";
+var REANIMATED = "react-native-reanimated";
+var ANIMATION_FNS = new Set(["withTiming", "withSpring", "withDecay", "withRepeat", "withSequence", "withDelay", "withClamp"]);
+var LAYOUT_PROPS = ["entering", "exiting", "layout"];
+var SCROLL_EVENTS = new Set(["onScroll", "onBeginDrag", "onEndDrag", "onMomentumBegin", "onMomentumEnd"]);
+function keyName(key) {
+  if (key.type === "Identifier")
+    return key.name;
+  if (key.type === "StringLiteral")
+    return key.value;
+  return null;
+}
+function relativeFile(state) {
+  const file = state.filename ?? "unknown";
+  const root = state.opts.root ?? state.cwd ?? "";
+  const rel = root && file.startsWith(root) ? file.slice(root.length).replace(/^[/\\]+/, "") : file;
+  return rel.replace(/\\/g, "/");
+}
+function enclosingName(path2) {
+  let fallback = null;
+  for (let p = path2.parentPath;p; p = p.parentPath) {
+    let name = null;
+    if (p.isFunctionDeclaration() && p.node.id)
+      name = p.node.id.name;
+    else if ((p.isArrowFunctionExpression() || p.isFunctionExpression()) && p.parentPath?.isVariableDeclarator()) {
+      const id = p.parentPath.node.id;
+      if (id.type === "Identifier")
+        name = id.name;
+    }
+    if (!name)
+      continue;
+    if (/^[A-Z]/.test(name) || /^use[A-Z]/.test(name))
+      return name;
+    fallback ??= name;
+  }
+  return fallback;
+}
+var NESTED_STYLE_KEYS = new Set(["shadowOffset", "textShadowOffset"]);
+function nameOfObject(obj) {
+  return obj.type === "Identifier" ? obj.name : obj.type === "MemberExpression" && !obj.computed ? keyName(obj.property) : null;
+}
+function propOf(path2) {
+  let prop = null;
+  let child = path2;
+  for (let p = path2.parentPath;p; child = p, p = p.parentPath) {
+    if (p.isFunction() || p.isStatement())
+      break;
+    if (p.isObjectProperty() && prop === null)
+      prop = keyName(p.node.key);
+    else if (p.isObjectProperty() && NESTED_STYLE_KEYS.has(keyName(p.node.key) ?? ""))
+      prop = keyName(p.node.key);
+    if (p.isCallExpression() && p.node.arguments[0] === child.node) {
+      const callee = p.node.callee;
+      if (callee.type === "MemberExpression" && !callee.computed && keyName(callee.property) === "set")
+        return prop ?? nameOfObject(callee.object);
+    }
+    if (p.isAssignmentExpression()) {
+      const left = p.node.left;
+      if (left.type === "MemberExpression" && keyName(left.property) === "value" && !left.computed)
+        return prop ?? nameOfObject(left.object);
+      break;
+    }
+  }
+  return prop;
+}
+var hex12 = (s) => import_node_crypto.createHash("sha256").update(s).digest("hex").slice(0, 12);
+function readJson(file) {
+  try {
+    return JSON.parse(import_node_fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function appIdentity(root, opts) {
+  const appJson = readJson(import_node_path.default.join(root, "app.json"));
+  const expo = appJson?.expo ?? appJson;
+  const pkg = readJson(import_node_path.default.join(root, "package.json"));
+  const version = opts.appVersion ?? process.env.KEYFRAMER_APP_VERSION ?? expo?.version ?? pkg?.version ?? "0.0.0";
+  const build = opts.build ?? process.env.KEYFRAMER_APP_BUILD ?? expo?.ios?.buildNumber ?? (expo?.android?.versionCode !== undefined ? String(expo.android.versionCode) : undefined);
+  return build ? { version, build } : { version };
+}
+function manifestPath(root, opts) {
+  const app = appIdentity(root, opts);
+  const name = app.build ? `${app.version}+${app.build}` : app.version;
+  return import_node_path.default.join(opts.manifestDir ?? import_node_path.default.join(root, ".keyframer"), `sites-${name.replace(/[^\w.+-]/g, "_")}.json`);
+}
+var sleep = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function writeManifest(file, source, sites, app) {
+  import_node_fs.mkdirSync(import_node_path.default.dirname(file), { recursive: true });
+  const lock = `${file}.lock`;
+  let fd = -1;
+  for (let i = 0;i < 400 && fd < 0; i++) {
+    try {
+      fd = import_node_fs.openSync(lock, "wx");
+    } catch {
+      try {
+        if (Date.now() - import_node_fs.statSync(lock).mtimeMs > 1e4)
+          import_node_fs.unlinkSync(lock);
+      } catch {}
+      sleep(5);
+    }
+  }
+  try {
+    const prev = readJson(file);
+    const merged = {};
+    for (const [hash, s] of Object.entries(prev?.sites ?? {}))
+      if (s.file !== source)
+        merged[hash] = s;
+    Object.assign(merged, sites);
+    const sorted = Object.fromEntries(Object.entries(merged).sort(([a], [b]) => a < b ? -1 : 1));
+    const tmp = `${file}.${process.pid}.tmp`;
+    import_node_fs.writeFileSync(tmp, JSON.stringify({ format: "keyframer-vitals-sites", version: 1, app, sites: sorted }, null, 2) + `
+`);
+    import_node_fs.renameSync(tmp, file);
+  } finally {
+    if (fd >= 0) {
+      import_node_fs.closeSync(fd);
+      try {
+        import_node_fs.unlinkSync(lock);
+      } catch {}
+    }
+  }
+}
+function keyframerVitals({ types: t }) {
+  const literal = (value) => t.valueToNode(value);
+  const markWorklet = (fn) => {
+    if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression")
+      return;
+    if (fn.body.type !== "BlockStatement")
+      fn.body = t.blockStatement([t.returnStatement(fn.body)]);
+    if (!fn.body.directives.some((d) => d.value.value === "worklet"))
+      fn.body.directives.unshift(t.directive(t.directiveLiteral("worklet")));
+  };
+  const helper = (fs, path2, name) => {
+    let id = fs.helpers.get(name);
+    if (!id) {
+      id = path2.scope.getProgramParent().generateUidIdentifier(name.replace(/^__/, ""));
+      fs.helpers.set(name, id);
+    }
+    return t.cloneNode(id);
+  };
+  const isHelper = (fs, e, name) => e?.type === "CallExpression" && e.callee.type === "Identifier" && e.callee.name === fs.helpers.get(name)?.name;
+  const isModuleBinding = (path2, name) => path2.scope.getBinding(name)?.kind === "module";
+  const site = (state, fs, at, fn, component, prop) => {
+    const group = `${fs.file}#${component ?? ""}#${fn}#${prop ?? ""}`;
+    const n = (fs.ordinals.get(group) ?? 0) + 1;
+    fs.ordinals.set(group, n);
+    const key = `${group}#${n}`;
+    if (state.opts.hashSites) {
+      const salt = state.opts.salt ?? "";
+      const hash = hex12(`${salt}
+${fs.file}:${at.line}:${at.column}
+${key}`);
+      fs.sites[hash] = { file: fs.file, line: at.line, column: at.column, fn, component, prop, key };
+      return literal({ ref: { kind: "hashed", hash }, key: `k_${hex12(`${salt}
+${key}`)}`, fn, component: null, prop: null });
+    }
+    return literal({ ref: { kind: "source", file: fs.file, line: at.line, column: at.column }, key, fn, component, prop });
+  };
+  const inspectorPosition = (node) => {
+    if (!node || node.type !== "ObjectExpression")
+      return null;
+    let line = null;
+    let column = null;
+    for (const p of node.properties) {
+      if (p.type !== "ObjectProperty" || p.value.type !== "NumericLiteral")
+        continue;
+      if (keyName(p.key) === "line")
+        line = p.value.value;
+      if (keyName(p.key) === "column")
+        column = p.value.value;
+    }
+    return line !== null ? { line, column: column ?? 0 } : null;
+  };
+  const reportScroll = (fs, path2, fn) => {
+    if (!fn || fs.wrapped.has(fn))
+      return;
+    let body = null;
+    if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression") {
+      markWorklet(fn);
+      body = fn.body;
+    } else if (fn.type === "ObjectMethod")
+      body = fn.body;
+    if (!body)
+      return;
+    fs.wrapped.add(fn);
+    body.body.unshift(t.expressionStatement(t.callExpression(helper(fs, path2, "__kfvScroll"), [])));
+  };
+  const nodes = {
+    CallExpression(path2, state) {
+      const { fs } = state;
+      const { node } = path2;
+      if (fs.wrapped.has(node) || node.callee.type !== "Identifier")
+        return;
+      const name = node.callee.name;
+      if (fs.scrollHookLocals.has(name) && isModuleBinding(path2, name)) {
+        const [first2] = node.arguments;
+        if (first2?.type === "ObjectExpression") {
+          for (const p of first2.properties) {
+            if (p.type === "ObjectProperty" && SCROLL_EVENTS.has(keyName(p.key) ?? ""))
+              reportScroll(fs, path2, p.value);
+            else if (p.type === "ObjectMethod" && SCROLL_EVENTS.has(keyName(p.key) ?? ""))
+              reportScroll(fs, path2, p);
+          }
+        } else
+          reportScroll(fs, path2, first2);
+        return;
+      }
+      const fn = fs.animLocals.get(name);
+      if (fn && isModuleBinding(path2, name) && node.loc) {
+        const at = { line: node.loc.start.line, column: node.loc.start.column };
+        node.arguments.forEach(markWorklet);
+        const call = t.callExpression(helper(fs, path2, "__kfvAnim"), [t.identifier(name), site(state, fs, at, fn, enclosingName(path2), propOf(path2)), ...node.arguments]);
+        fs.wrapped.add(call);
+        path2.replaceWith(call);
+        return;
+      }
+      const viaLocal = fs.inspector.get("__kfAnim");
+      const [first, isite, ...rest] = node.arguments;
+      if (viaLocal && name === viaLocal && first?.type === "Identifier" && fs.animLocals.has(first.name) && isModuleBinding(path2, first.name)) {
+        const at = inspectorPosition(isite) ?? (node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : null);
+        if (!at || !isite)
+          return;
+        const call = t.callExpression(helper(fs, path2, "__kfvAnimVia"), [
+          t.identifier(name),
+          site(state, fs, at, fs.animLocals.get(first.name), enclosingName(path2), propOf(path2)),
+          first,
+          isite,
+          ...rest
+        ]);
+        fs.wrapped.add(call);
+        path2.replaceWith(call);
+      }
+    },
+    JSXOpeningElement(path2, state) {
+      const { fs } = state;
+      const el = path2.node;
+      const attr = (n) => el.attributes.find((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === n);
+      const value = (a) => a?.value?.type === "JSXExpressionContainer" && a.value.expression.type !== "JSXEmptyExpression" ? a.value.expression : null;
+      const setAttr = (n, expr) => {
+        const a = attr(n);
+        if (a) {
+          a.value = t.jsxExpressionContainer(expr);
+          return;
+        }
+        const added = t.jsxAttribute(t.jsxIdentifier(n), t.jsxExpressionContainer(expr));
+        const spread = el.attributes.findIndex((x) => x.type === "JSXSpreadAttribute");
+        if (spread >= 0)
+          el.attributes.splice(spread, 0, added);
+        else
+          el.attributes.push(added);
+      };
+      const loc = el.loc;
+      if (loc) {
+        const at = { line: loc.start.line, column: loc.start.column + 1 };
+        const component = enclosingName(path2);
+        const kinds = {};
+        for (const kind of LAYOUT_PROPS) {
+          const a = attr(kind);
+          const v2 = value(a);
+          if (!a || !v2 || isHelper(fs, v2, "__kfvLayout"))
+            continue;
+          const s = site(state, fs, at, kind, component, null);
+          kinds[kind] = s;
+          a.value = t.jsxExpressionContainer(t.callExpression(helper(fs, path2, "__kfvLayout"), [v2, t.stringLiteral(kind), s]));
+        }
+        if (kinds.entering || kinds.exiting) {
+          const prev = value(attr("ref"));
+          setAttr("ref", t.callExpression(helper(fs, path2, "__kfvMotionRef"), [kinds.entering ? t.cloneNode(kinds.entering) : t.nullLiteral(), kinds.exiting ? t.cloneNode(kinds.exiting) : t.nullLiteral(), ...prev ? [prev] : []]));
+        }
+        if (kinds.layout) {
+          const prev = value(attr("onLayout"));
+          setAttr("onLayout", t.callExpression(helper(fs, path2, "__kfvLayoutMoved"), [t.cloneNode(kinds.layout), ...prev ? [prev] : []]));
+        }
+      }
+      const onScroll = attr("onScroll");
+      const v = value(onScroll);
+      if (!onScroll || !v || isHelper(fs, v, "__kfvScrollJs"))
+        return;
+      if (v.type !== "Identifier" && v.type !== "MemberExpression" && v.type !== "ArrowFunctionExpression" && v.type !== "FunctionExpression" && v.type !== "CallExpression")
+        return;
+      if (v.type === "Identifier" && v.name === "undefined")
+        return;
+      const callOf = (e) => {
+        if (e.type !== "Identifier")
+          return e;
+        const decl = path2.scope.getBinding(e.name)?.path.node;
+        return decl?.type === "VariableDeclarator" ? decl.init : null;
+      };
+      const init = callOf(v);
+      if (init?.type === "CallExpression" && init.callee.type === "Identifier" && fs.scrollHookLocals.has(init.callee.name))
+        return;
+      onScroll.value = t.jsxExpressionContainer(t.callExpression(helper(fs, path2, "__kfvScrollJs"), [v]));
+    }
+  };
+  const run = (program, state) => {
+    if (state.done)
+      return;
+    state.done = true;
+    const fs = {
+      file: relativeFile(state),
+      animLocals: new Map,
+      scrollHookLocals: new Set,
+      inspector: new Map,
+      helpers: new Map,
+      ordinals: new Map,
+      wrapped: new WeakSet,
+      sites: {}
+    };
+    for (const stmt of program.node.body) {
+      if (stmt.type !== "ImportDeclaration" || stmt.importKind === "type")
+        continue;
+      for (const spec of stmt.specifiers) {
+        if (spec.type !== "ImportSpecifier")
+          continue;
+        const imported = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+        if (stmt.source.value === REANIMATED) {
+          if (ANIMATION_FNS.has(imported))
+            fs.animLocals.set(spec.local.name, imported);
+          if (imported === "useAnimatedScrollHandler")
+            fs.scrollHookLocals.add(spec.local.name);
+        } else if (stmt.source.value === INSPECTOR_RUNTIME)
+          fs.inspector.set(imported, spec.local.name);
+      }
+    }
+    if (!fs.animLocals.size && !fs.scrollHookLocals.size && !/\b(entering|exiting|layout|onScroll)\s*=/.test(state.file.code ?? ""))
+      return;
+    program.traverse(nodes, Object.assign(state, { fs }));
+    if (fs.helpers.size) {
+      const specifiers = [...fs.helpers].map(([exported, local]) => t.importSpecifier(local, t.identifier(exported)));
+      program.unshiftContainer("body", t.importDeclaration(specifiers, t.stringLiteral(RUNTIME_MODULE)));
+      program.scope.crawl();
+    }
+    if (state.opts.hashSites) {
+      const root = state.opts.root ?? state.cwd ?? process.cwd();
+      if (Object.keys(fs.sites).length || import_node_fs.existsSync(manifestPath(root, state.opts))) {
+        writeManifest(manifestPath(root, state.opts), fs.file, fs.sites, appIdentity(root, state.opts));
+      }
+    }
+  };
+  return {
+    name: PLUGIN_NAME,
+    visitor: {
+      Program: {
+        enter(program, state) {
+          const file = (state.filename ?? "").replace(/\\/g, "/");
+          state.skip = !state.opts.includeNodeModules && file.includes("/node_modules/") || /\/packages\/vitals\/(src|dist)\//.test(file);
+          state.done = false;
+          state.program = program;
+          if (state.skip) {
+            state.pending = false;
+            return;
+          }
+          const keys = (state.file.opts.plugins ?? []).map((p) => p.key);
+          const me = keys.indexOf(PLUGIN_NAME);
+          const inspector = keys.indexOf(INSPECTOR_PLUGIN);
+          state.pending = me >= 0 && inspector > me;
+          if (!state.pending)
+            run(program, state);
+        }
+      },
+      "Statement|Directive"(_path, state) {
+        if (!state.pending)
+          return;
+        state.pending = false;
+        if (state.program)
+          run(state.program, state);
+      }
+    }
+  };
+}