react-perf-recorder 0.1.0

package/dist/node/vite.js

@@ -0,0 +1,1072 @@
+import {
+  appendLines,
+  combineProxies,
+  createFilter,
+  findDeclarations,
+  parseModule,
+  proxyModule,
+  scanModule
+} from "./chunk-HS2BJBJX.js";
+
+// src/vite/index.ts
+import fs2 from "fs";
+import { createRequire } from "module";
+import path3 from "path";
+
+// node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  return value;
+}
+function decodeSign(num) {
+  return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn += decodeSign(decodeInteger(reader));
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex += decodeSign(decodeInteger(reader));
+        sourceLine += decodeSign(decodeInteger(reader));
+        sourceColumn += decodeSign(decodeInteger(reader));
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex += decodeSign(decodeInteger(reader));
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+
+// node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+var schemeRegex = /^[\w+.-]+:\/\//;
+var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path4 = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path4) ? path4 : "/" + path4, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path4, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path: path4,
+    query,
+    hash,
+    type: 7
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = 6;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = 5;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+  return url;
+}
+function stripPathFilename(path4) {
+  if (path4.endsWith("/.."))
+    return path4;
+  const index = path4.lastIndexOf("/");
+  return path4.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath(url, type) {
+  const rel = type <= 4;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i = 1; i < pieces.length; i++) {
+    const piece = pieces[i];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path4 = "";
+  for (let i = 1; i < pointer; i++) {
+    path4 += "/" + pieces[i];
+  }
+  if (!path4 || addTrailingSlash && !path4.endsWith("/..")) {
+    path4 += "/";
+  }
+  url.path = path4;
+}
+function resolve(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== 7) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case 1:
+        url.hash = baseUrl.hash;
+      // fall through
+      case 2:
+        url.query = baseUrl.query;
+      // fall through
+      case 3:
+      case 4:
+        mergePaths(url, baseUrl);
+      // fall through
+      case 5:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      // fall through
+      case 6:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    // This is impossible, because of the empty checks at the start of the function.
+    // case UrlType.Empty:
+    case 2:
+    case 3:
+      return queryHash;
+    case 4: {
+      const path4 = url.path.slice(1);
+      if (!path4)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path4)) {
+        return "./" + path4 + queryHash;
+      }
+      return path4 + queryHash;
+    }
+    case 5:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+
+// node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path4) {
+  if (!path4) return "";
+  const index = path4.lastIndexOf("/");
+  return path4.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length) return mappings;
+  if (!owned) mappings = mappings.slice();
+  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start; i < mappings.length; i++) {
+    if (!isSorted(mappings[i])) return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned) line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b) {
+  return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo) return map;
+    const parsed = parse(map);
+    const { version, file, names: names2, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names2 || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+    const resolve2 = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve2);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+};
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index === -1) return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names: names2, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names2[segment[NAMES_INDEX]] : null
+  );
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND) index++;
+  if (index === -1 || index === segments.length) return -1;
+  return index;
+}
+
+// src/shared/schema.ts
+var SESSION_SCHEMA = "react-perf-recorder/session";
+var ENDPOINT = "__react-perf-recorder";
+var CLIENT_HEADER = "x-react-perf-recorder";
+
+// src/vite/component-names.ts
+var DEFAULT_WRAPPERS = ["memo", "forwardRef", "createContext"];
+var DEFAULT_LOCAL = "__rprDefault";
+var nameLine = (local, name) => `if ((typeof ${local} === "function" || (typeof ${local} === "object" && ${local} !== null)) && !${local}.displayName) ${local}.displayName = ${JSON.stringify(name)};`;
+function nameOfFile(file) {
+  const parts = file.replace(/[?#].*$/, "").split(/[\\/]/);
+  const base = parts.pop()?.replace(/\.[^.]+$/, "");
+  const name = base === "index" ? parts.pop() : base;
+  return name && /^[A-Za-z_$][\w$-]*$/.test(name) ? name : null;
+}
+function addComponentNames(code, wrappers = DEFAULT_WRAPPERS, file) {
+  const { names: names2, defaultCall } = scanModule(code, wrappers, { allowReactPrefix: true, file });
+  const lines = names2.map((name) => nameLine(name, name));
+  const defaultName = defaultCall && file ? nameOfFile(file) : null;
+  let out = code;
+  if (defaultCall && defaultName) {
+    const { start, end } = defaultCall;
+    out = `${code.slice(0, start)}(${DEFAULT_LOCAL} = ${code.slice(start, end)})${code.slice(end)}`;
+    lines.push(`var ${DEFAULT_LOCAL};`, nameLine(DEFAULT_LOCAL, defaultName));
+  }
+  return appendLines(out, lines);
+}
+
+// src/vite/entry.ts
+import path from "path";
+var ENTRY_ID = "virtual:react-perf-recorder/entry";
+var RESOLVED_ENTRY_ID = `\0${ENTRY_ID}`;
+function runtimeSpecifier(module, root) {
+  if (!path.isAbsolute(module)) return module;
+  const rel = path.relative(root, module).replace(/\\/g, "/");
+  return rel.startsWith("..") ? `/@fs${module.replace(/\\/g, "/")}` : `/${rel}`;
+}
+function entryCode(clientModule, config, runtimes) {
+  const imports = runtimes.map((r, i) => `import plugin${i} from ${JSON.stringify(r.module)};`);
+  const list = runtimes.map((r, i) => `[plugin${i}, ${JSON.stringify(r.options ?? null)}]`).join(", ");
+  return [
+    `import { boot } from ${JSON.stringify(clientModule)};`,
+    ...imports,
+    `boot(${JSON.stringify(config)}, [${list}], import.meta.hot);`,
+    // Keep the entry alive across HMR: booting twice would install the commit hook twice.
+    `if (import.meta.hot) import.meta.hot.accept(() => {});`
+  ].join("\n");
+}
+
+// src/vite/helpers/hook-deps.ts
+var MEMO_HOOKS = /^(useMemo|useCallback)$/;
+var hookName = (callee) => {
+  if (callee.type === "Identifier") return callee.name;
+  if (callee.type === "MemberExpression" && callee.property.type === "Identifier") return callee.property.name;
+  return null;
+};
+function memoDepsAt(body, code, line) {
+  let found2 = null;
+  const visit = (node) => {
+    if (found2 || !node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child);
+      return;
+    }
+    const n = node;
+    if (n.loc && (n.loc.start.line > line || n.loc.end.line < line)) return;
+    if (n.type === "CallExpression" && n.callee.loc?.start.line === line) {
+      const name = hookName(n.callee);
+      const last = n.arguments[n.arguments.length - 1];
+      if (name && MEMO_HOOKS.test(name) && n.arguments.length > 1 && last?.type === "ArrayExpression") {
+        found2 = last.elements.map(
+          (el) => el ? code.slice(el.start ?? 0, el.end ?? 0).replace(/\s+/g, " ").slice(0, 60) : ""
+        );
+        return;
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+      visit(n[key]);
+    }
+  };
+  visit(body);
+  return found2;
+}
+function declared(body, name) {
+  for (const statement of body) {
+    const node = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+    if (!node) continue;
+    if (node.type === "FunctionDeclaration" && node.id?.name === name) return node;
+    if (node.type === "VariableDeclaration") {
+      for (const d of node.declarations) if (d.id.type === "Identifier" && d.id.name === name && d.init) return d.init;
+    }
+  }
+  return null;
+}
+function memoCalls(fn) {
+  const out = [];
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) return void node.forEach(visit);
+    const n = node;
+    if (n.type === "CallExpression") {
+      const name = hookName(n.callee);
+      if (name && MEMO_HOOKS.test(name)) out.push(n);
+    }
+    for (const key of Object.keys(n)) if (key !== "loc" && !key.endsWith("Comments")) visit(n[key]);
+  };
+  visit(fn);
+  return out;
+}
+function memoDepsInHook(body, code, name) {
+  const fn = declared(body, name);
+  if (fn) {
+    const calls = memoCalls(fn);
+    const last = calls.length === 1 ? calls[0].arguments[calls[0].arguments.length - 1] : void 0;
+    if (calls[0]?.arguments.length !== 2 || last?.type !== "ArrayExpression") return null;
+    return {
+      kind: "deps",
+      deps: last.elements.map(
+        (el) => el ? code.slice(el.start ?? 0, el.end ?? 0).replace(/\s+/g, " ").slice(0, 60) : ""
+      )
+    };
+  }
+  for (const statement of body)
+    if (statement.type === "ImportDeclaration" && statement.specifiers.some((s) => s.local.name === name))
+      return { kind: "import", source: statement.source.value };
+  return null;
+}
+
+// src/vite/middleware.ts
+import { randomBytes } from "crypto";
+import fs from "fs";
+import path2 from "path";
+
+// src/shared/summary.ts
+var names = (list, max = 5) => (list ?? []).slice(0, max).join(", ");
+function reasonText(reason) {
+  const mark = reason.sameContent ? " SAME-CONTENT" : "";
+  const props = [names(reason.changed), reason.sameRef?.length ? `same: ${names(reason.sameRef)}` : ""].filter(Boolean).join(" | ");
+  switch (reason.kind) {
+    case "state":
+      return reason.hook === void 0 ? `class state${mark}` : `state #${reason.hook}${mark}`;
+    case "store":
+      return `external store #${reason.hook}${mark}${reason.store ? ` [${reason.store}]` : ""}${reason.selector ? ` ${reason.selector}` : ""}`;
+    case "context":
+      return `context ${reason.context || "(unnamed)"}${mark}`;
+    case "props":
+      return `props: ${props || "(new object)"}`;
+    case "parent":
+      if (reason.equal) return "parent: props equal";
+      if (!props) return "parent: children";
+      return `parent: props ${props}${reason.children ? " +children" : ""}`;
+    case "bailout":
+      return "bailout: state set to the same value";
+    default:
+      return "unknown";
+  }
+}
+var textOf = (reason) => reason.text ?? reasonText(reason);
+var reasonsById = (reasons = []) => new Map(reasons.map((r) => [r.i, r]));
+
+// src/shared/listing.ts
+function topReason(rec) {
+  const id = rec.roots[0]?.reasons[0]?.[0];
+  const reason = id === void 0 ? void 0 : reasonsById(rec.reasons).get(id);
+  return reason ? textOf(reason) : "";
+}
+function listingOf(rec) {
+  const top = rec.roots?.[0];
+  return {
+    durationMs: rec.durationMs ?? 0,
+    actions: rec.actions?.length ?? 0,
+    commits: rec.totals?.commitsInScope ?? 0,
+    renders: rec.totals?.renders ?? 0,
+    topRoot: top ? `${top.name} \xD7${top.hits} \xB7 ${rec.reasons ? topReason(rec) : ""}` : null
+  };
+}
+
+// src/vite/middleware.ts
+var ID = /^\d{8}-\d{6}-[\w.-]+$/;
+var slug = (s) => (s ?? "").replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "app";
+var stamp = (d) => {
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+};
+function writeAtomic(file, data) {
+  const tmp = path2.join(path2.dirname(file), `.${path2.basename(file)}.${process.pid}.tmp`);
+  fs.writeFileSync(tmp, data);
+  fs.renameSync(tmp, file);
+}
+function dirSize(dir) {
+  let total = 0;
+  for (const name of fs.readdirSync(dir)) {
+    try {
+      total += fs.statSync(path2.join(dir, name)).size;
+    } catch {
+    }
+  }
+  return total;
+}
+var SessionStore = class {
+  constructor(options) {
+    this.options = options;
+    this.tokens = /* @__PURE__ */ new Map();
+  }
+  get dir() {
+    return this.options.dir;
+  }
+  get maxBytes() {
+    return this.options.maxBytes;
+  }
+  ensureDir() {
+    if (fs.existsSync(this.options.dir)) return;
+    fs.mkdirSync(this.options.dir, { recursive: true });
+    if (this.options.gitignore) fs.writeFileSync(path2.join(this.options.dir, ".gitignore"), "*\n");
+  }
+  open(meta) {
+    this.ensureDir();
+    this.prune();
+    const now = /* @__PURE__ */ new Date();
+    const scope = meta.scope?.name ? slug(meta.scope.name) : "app";
+    const source = slug(meta.source ?? "api").replace(/^script-/, "");
+    let id = `${stamp(now)}-${scope}-${source}-${randomBytes(2).toString("hex")}`;
+    while (fs.existsSync(path2.join(this.options.dir, id))) id = `${id.slice(0, -4)}${randomBytes(2).toString("hex")}`;
+    const dir = path2.join(this.options.dir, id);
+    fs.mkdirSync(dir);
+    const session = {
+      schema: SESSION_SCHEMA,
+      version: 1,
+      id,
+      status: "recording",
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      source: String(meta.source ?? "api"),
+      ...meta.label ? { label: String(meta.label).slice(0, 200) } : {},
+      page: meta.page ?? { url: "", title: "", viewport: "", dpr: 1, userAgent: "" },
+      scope: meta.scope ?? null,
+      conditions: meta.conditions ?? {},
+      plugins: meta.plugins ?? [],
+      events: 0,
+      reloads: 0
+    };
+    writeAtomic(path2.join(dir, "session.json"), JSON.stringify(session, null, 2));
+    fs.writeFileSync(path2.join(dir, "events.ndjson"), "");
+    const token = randomBytes(16).toString("hex");
+    this.tokens.set(id, token);
+    return { id, token };
+  }
+  checkToken(id, token) {
+    return Boolean(token) && this.tokens.get(id) === token;
+  }
+  /** `unloaded`: the page went away mid-recording and sent what it had by beacon; a normal stop ends in finish. */
+  append(id, events, unloaded = false) {
+    const dir = this.sessionDir(id);
+    const meta = this.readMeta(dir);
+    if (events.length) fs.appendFileSync(path2.join(dir, "events.ndjson"), `${events.map((e) => JSON.stringify(e)).join("\n")}
+`);
+    meta.events += events.length;
+    meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (meta.status === "recording" && unloaded) meta.status = "interrupted";
+    writeAtomic(path2.join(dir, "session.json"), JSON.stringify(meta, null, 2));
+  }
+  async finish(id, recording) {
+    const dir = this.sessionDir(id);
+    const sites = await this.mapSites(recording);
+    writeAtomic(path2.join(dir, "recording.json"), JSON.stringify({ ...recording, id }, null, 1));
+    const meta = this.readMeta(dir);
+    meta.status = "done";
+    meta.listing = listingOf(recording);
+    meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeAtomic(path2.join(dir, "session.json"), JSON.stringify(meta, null, 2));
+    this.tokens.delete(id);
+    return { id, dir, sites };
+  }
+  /** The panel asking outside a recording: React 19 gives a component's site as a built position, and only the dev server can map it. */
+  async mapPositions(positions) {
+    const mapSite2 = this.options.mapSite;
+    const out = {};
+    if (!mapSite2) return out;
+    for (const p of positions.slice(0, 200)) {
+      if (!p || typeof p.url !== "string" || typeof p.line !== "number" || typeof p.column !== "number") continue;
+      const mapped = await mapSite2(p.url, p.line, p.column).catch(() => null);
+      if (mapped) out[`${p.url}:${p.line}:${p.column}`] = mapped.site;
+    }
+    return out;
+  }
+  /** Turns built positions back into source lines: every hook's call site, and on React 19 the component's own. */
+  async mapSites(recording) {
+    const sites = {};
+    const mapSite2 = this.options.mapSite;
+    if (!mapSite2) return sites;
+    const cache = /* @__PURE__ */ new Map();
+    const map = (g, hooks) => {
+      const key = `${g.url}:${g.line}:${g.column}`;
+      const cacheKey = hooks ? `${key}|memo` : key;
+      if (!cache.has(cacheKey))
+        cache.set(
+          cacheKey,
+          mapSite2(g.url, g.line, g.column, hooks).catch(() => null)
+        );
+      return cache.get(cacheKey).then((mapped) => {
+        if (mapped) sites[key] = { ...sites[key], ...mapped };
+        return mapped;
+      });
+    };
+    for (const action of recording.actions ?? []) {
+      const own = action.target?.generatedSource;
+      if (!own) continue;
+      const mapped = await map(own);
+      if (mapped) action.target.source = mapped.site;
+      delete action.target.generatedSource;
+    }
+    for (const root of [...recording.roots, ...recording.outsideRoots]) {
+      const own = root.generatedSource;
+      if (own) {
+        const mapped = await map(own);
+        if (mapped) root.source = mapped.site;
+        delete root.generatedSource;
+      }
+      for (const hook of Object.values(root.hooks ?? {})) {
+        const g = hook.generated;
+        if (!g) continue;
+        const mapped = await map(g);
+        if (mapped) {
+          hook.site = mapped.site;
+          if (mapped.code) hook.code = mapped.code;
+        }
+        delete hook.generated;
+      }
+    }
+    for (const memo of recording.memos ?? []) {
+      const g = memo.info?.generated;
+      if (!g) continue;
+      const mapped = await map(g, (memo.info.path ?? []).slice(0, -1));
+      if (mapped) {
+        memo.info.site = mapped.site;
+        if (mapped.code) memo.info.code = mapped.code;
+        if (mapped.deps) memo.info.deps = mapped.deps;
+      }
+      delete memo.info.generated;
+    }
+    return sites;
+  }
+  sessionDir(id) {
+    if (!ID.test(id)) throw Object.assign(new Error("bad session id"), { status: 400 });
+    const dir = path2.join(this.options.dir, id);
+    if (!fs.existsSync(dir)) throw Object.assign(new Error("unknown session"), { status: 404 });
+    return dir;
+  }
+  readMeta(dir) {
+    return JSON.parse(fs.readFileSync(path2.join(dir, "session.json"), "utf8"));
+  }
+  /** Oldest sessions go first; a session still being written (updated within a minute) is never removed. */
+  prune() {
+    const { sessions, bytes } = this.options.retain;
+    const entries = fs.readdirSync(this.options.dir).filter((name) => ID.test(name)).sort().map((name) => {
+      const dir = path2.join(this.options.dir, name);
+      return { dir, size: dirSize(dir), mtime: fs.statSync(dir).mtimeMs };
+    });
+    let total = entries.reduce((sum, e) => sum + e.size, 0);
+    let count = entries.length;
+    for (const entry of entries) {
+      if (count < sessions && total <= bytes) break;
+      if (Date.now() - entry.mtime < 6e4) continue;
+      fs.rmSync(entry.dir, { recursive: true, force: true });
+      count--;
+      total -= entry.size;
+    }
+  }
+};
+async function readBody(req, limit) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > limit) throw Object.assign(new Error("payload too large"), { status: 413 });
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+var send = (res, status, body) => {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+};
+function createMiddleware(store, base, version) {
+  const prefix = `${base.replace(/\/$/, "")}/${ENDPOINT}/`;
+  return async (req, res, next) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (!url.pathname.startsWith(prefix)) return next();
+    const route = url.pathname.slice(prefix.length);
+    try {
+      if (req.method === "GET" && route === "health") return send(res, 200, { ok: true, version, dir: store.dir });
+      if (req.method !== "POST") return send(res, 405, { error: "method not allowed" });
+      const match = /^(?:map|sessions(?:\/([^/]+)\/(events|finish))?)$/.exec(route);
+      if (!match) return send(res, 404, { error: "not found" });
+      const [, id, action] = match;
+      const trusted = req.headers[CLIENT_HEADER] === "1" && String(req.headers["content-type"] ?? "").startsWith("application/json");
+      const beacon = action === "events" && id && store.checkToken(id, url.searchParams.get("token"));
+      if (!trusted && !beacon) return send(res, 415, { error: `requests need content-type application/json and ${CLIENT_HEADER}: 1` });
+      const raw = await readBody(req, action === "finish" ? store.maxBytes : Math.min(store.maxBytes, 16 * 1024 * 1024));
+      const body = raw ? JSON.parse(raw) : {};
+      if (route === "map") return send(res, 200, { sites: await store.mapPositions(body.positions ?? []) });
+      if (!action) return send(res, 200, store.open(body));
+      if (action === "events") {
+        if (!Array.isArray(body.events)) return send(res, 400, { error: "events must be an array" });
+        store.append(id, body.events, url.searchParams.get("end") === "1");
+        return send(res, 200, { ok: true });
+      }
+      if (body.recording?.schema !== "react-perf-recorder/recording") return send(res, 400, { error: "not a recording" });
+      return send(res, 200, await store.finish(id, body.recording));
+    } catch (error) {
+      const status = error.status ?? (error instanceof SyntaxError ? 400 : 500);
+      return send(res, status, { error: String(error.message ?? error) });
+    }
+  };
+}
+
+// src/vite/plugin-api.ts
+var definePerfRecorderPlugin = (plugin) => plugin;
+
+// src/vite/index.ts
+var VERSION = true ? "0.1.0" : "dev";
+function resolvable(specifier, root = process.cwd()) {
+  try {
+    createRequire(path3.join(path3.resolve(root), "package.json")).resolve(specifier);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_WRAPPER_PATTERN = "^(Anonymous|ForwardRef|Memo)$";
+function resolveOutDir(root, outDir) {
+  const dir = outDir ?? process.env.REACT_PERF_RECORDER_DIR ?? ".agent-artifacts/perf-recorder";
+  return path3.resolve(root, dir);
+}
+var traceMaps = /* @__PURE__ */ new WeakMap();
+var fileLines = /* @__PURE__ */ new Map();
+function linesOf(file) {
+  const mtimeMs = fs2.statSync(file).mtimeMs;
+  const cached = fileLines.get(file);
+  if (cached?.mtimeMs === mtimeMs) return cached.lines;
+  if (fileLines.size > 200) fileLines.clear();
+  const lines = fs2.readFileSync(file, "utf8").split("\n");
+  fileLines.set(file, { mtimeMs, lines });
+  return lines;
+}
+var parsedFiles = /* @__PURE__ */ new Map();
+function parsedOf(file) {
+  const mtimeMs = fs2.statSync(file).mtimeMs;
+  let parsed = parsedFiles.get(file);
+  if (parsed?.mtimeMs !== mtimeMs) {
+    if (parsedFiles.size > 50) parsedFiles.clear();
+    const code = linesOf(file).join("\n");
+    parsedFiles.set(file, parsed = { mtimeMs, code, body: parseModule(code, file) });
+  }
+  return parsed;
+}
+var EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+function depsOf(file, line, hooks = []) {
+  const here = parsedOf(file);
+  if (!here.body) return null;
+  const direct = memoDepsAt(here.body, here.code, line);
+  if (direct || !hooks.length) return direct;
+  const innermost = hooks[hooks.length - 1];
+  let at = file;
+  for (let hop = 0; hop < 3; hop++) {
+    const parsed = parsedOf(at);
+    if (!parsed.body) return null;
+    const found2 = memoDepsInHook(parsed.body, parsed.code, innermost) ?? (hop === 0 && hooks.length > 1 ? memoDepsInHook(parsed.body, parsed.code, hooks[0]) : null);
+    if (!found2) return null;
+    if (found2.kind === "deps") return found2.deps;
+    if (!found2.source.startsWith(".")) return null;
+    const base = path3.resolve(path3.dirname(at), found2.source);
+    const next = EXTENSIONS.map((ext) => base + ext).find((candidate) => fs2.existsSync(candidate) && fs2.statSync(candidate).isFile());
+    if (!next) return null;
+    at = next;
+  }
+  return null;
+}
+async function mapSite(server, root, url, line, column, hooks) {
+  const parsed = new URL(url, "http://localhost");
+  const mod = await server.moduleGraph.getModuleByUrl(parsed.pathname + parsed.search);
+  const map = mod?.transformResult?.map;
+  if (!mod?.file || !map) return null;
+  let traced = traceMaps.get(map);
+  if (!traced) traceMaps.set(map, traced = new TraceMap(map));
+  const pos = originalPositionFor(traced, { line, column: Math.max(0, column - 1) });
+  if (pos.line == null) return null;
+  const file = pos.source ? path3.isAbsolute(pos.source) ? pos.source : path3.resolve(path3.dirname(mod.file), pos.source) : mod.file;
+  const real = fs2.existsSync(file) ? file : mod.file;
+  const code = linesOf(real)[pos.line - 1]?.trim().slice(0, 140);
+  const deps = hooks ? depsOf(real, pos.line, hooks) : null;
+  return { site: `${path3.relative(root, real).replace(/\\/g, "/")}:${pos.line}`, ...code ? { code } : {}, ...deps ? { deps } : {} };
+}
+function perfRecorder(options = {}) {
+  let root = process.cwd();
+  let base = "/";
+  let serving = true;
+  const plugins = options.plugins ?? [];
+  const ctx = { root: () => root };
+  plugins.forEach((p) => p.init?.(ctx));
+  const apply = (_, env) => options.enabled ?? (env.command === "serve" && !process.env.VITEST && env.mode !== "test");
+  const components = options.components === false ? null : options.components ?? {};
+  const componentFilter = createFilter(() => root, components?.include ?? ["src/**/*.{tsx,jsx}"], components?.exclude);
+  const wrapperPattern = components?.wrapperPattern ?? DEFAULT_WRAPPER_PATTERN;
+  const appFilter = createFilter(() => root, ["src/**/*.{ts,tsx,js,jsx}"]);
+  const rootProxy = proxyModule("core", {
+    source: "react-dom/client",
+    importer: appFilter,
+    code: () => [
+      // Named exports only: react-dom/client is interop'd from CJS, and `export *` would lose them.
+      `import * as original from 'react-dom/client';`,
+      `import { noteRoot } from 'react-perf-recorder/runtime';`,
+      `export const createRoot = (...args) => { const root = original.createRoot(...args); noteRoot(root); return root; };`,
+      `export const hydrateRoot = (...args) => { const root = original.hydrateRoot(...args); noteRoot(root); return root; };`,
+      `export const version = original.version;`,
+      `export default original.default ?? original;`
+    ].join("\n")
+  });
+  const clientConfig = () => ({
+    version: VERSION,
+    projectRoot: root.replace(/\\/g, "/"),
+    wrapperPattern,
+    actions: { values: options.actions?.values ?? false, secretSelector: options.actions?.secretSelector ?? "[data-rpr-secret]" },
+    maxDurationMs: options.engine?.maxDurationMs ?? 10 * 6e4,
+    bigCommit: options.engine?.bigCommit ?? 150,
+    timelineLimit: options.engine?.timelineLimit ?? 5e3,
+    timers: options.engine?.timers ?? true,
+    endpoint: options.save ?? serving ? `${base.replace(/\/$/, "")}/${ENDPOINT}` : null,
+    panel: options.panel === false ? false : {
+      corner: options.panel?.corner ?? "bottom-left",
+      highlight: options.panel?.highlight ?? true,
+      shortcuts: { record: options.panel?.shortcuts?.record ?? "Alt+Shift+KeyR", pick: options.panel?.shortcuts?.pick ?? "Alt+Shift+KeyS" }
+    }
+  });
+  const core = {
+    name: "react-perf-recorder",
+    enforce: "pre",
+    apply,
+    // The app's import of react-dom/client is rewritten to the proxy, so the optimizer's scan never meets it and
+    // would find it on the first page load, then reload the page with two copies of React for a moment.
+    config: (config) => ({
+      optimizeDeps: { exclude: ["react-perf-recorder"], include: resolvable("react-dom/client", config.root) ? ["react-dom/client"] : [] }
+    }),
+    configResolved(config) {
+      root = config.root;
+      base = config.base;
+      serving = config.command === "serve";
+    },
+    resolveId: (id, importer) => id === ENTRY_ID ? RESOLVED_ENTRY_ID : rootProxy.resolveId(id, importer),
+    load(id) {
+      const proxied = rootProxy.load(id);
+      if (proxied) return proxied;
+      if (id !== RESOLVED_ENTRY_ID) return null;
+      const runtimes = plugins.filter((p) => p.runtime).map((p) => ({ module: runtimeSpecifier(p.runtime.module, root), options: p.runtime.options }));
+      return entryCode("react-perf-recorder/client", clientConfig(), runtimes);
+    },
+    transform(code, id) {
+      const rewritten = appFilter(id) ? rootProxy.rewrite(code) : null;
+      if (!components || !componentFilter(id)) return rewritten ? { code: rewritten, map: null } : null;
+      const named = addComponentNames(rewritten ?? code, components.wrappers ?? DEFAULT_WRAPPERS, id);
+      return named ? { code: named, map: null } : rewritten ? { code: rewritten, map: null } : null;
+    },
+    // The dev server serves a virtual module under /@id/ and puts the base in front itself for a tag added before it
+    // reads the page's scripts; a build bundles the module from its id, and only for such a tag.
+    transformIndexHtml: {
+      order: "pre",
+      handler: () => [{ tag: "script", attrs: { type: "module", src: serving ? `/@id/${ENTRY_ID}` : ENTRY_ID }, injectTo: "head-prepend" }]
+    },
+    configureServer(server) {
+      const dir = resolveOutDir(root, options.outDir);
+      const store = new SessionStore({
+        dir,
+        maxBytes: options.maxBytes ?? 64 * 1024 * 1024,
+        retain: { sessions: options.retain?.sessions ?? 100, bytes: options.retain?.bytes ?? 500 * 1024 * 1024 },
+        gitignore: !path3.relative(root, dir).startsWith(".."),
+        mapSite: (url, line, column, hooks) => mapSite(server, root, url, line, column, hooks)
+      });
+      server.middlewares.use(createMiddleware(store, base, VERSION));
+      server.config.logger.info(`  react-perf-recorder: sessions \u2192 ${dir}`);
+    }
+  };
+  const wrapped = plugins.filter((p) => p.vite).map((p) => ({
+    name: `react-perf-recorder:${p.name}`,
+    enforce: "pre",
+    apply,
+    ...p.vite.config ? { config: (config) => p.vite.config(config) ?? void 0 } : {},
+    ...p.vite.resolveId ? { resolveId: (source, importer) => p.vite.resolveId(source, importer) ?? null } : {},
+    ...p.vite.load ? { load: (id) => p.vite.load(id) ?? null } : {},
+    ...p.vite.transform ? { transform: (code, id) => p.vite.transform(code, id) ?? null } : {}
+  }));
+  return [core, ...wrapped];
+}
+export {
+  addComponentNames,
+  appendLines,
+  combineProxies,
+  createFilter,
+  definePerfRecorderPlugin,
+  findDeclarations,
+  perfRecorder,
+  proxyModule,
+  resolveOutDir
+};