@deeeed/metamask-harness 0.82.1 → 0.83.0

package/dist/adapters/performance/cdp-trace.js

@@ -1,406 +0,0 @@
-import {
-  summarizeFrames
-} from "@farmslot/adapter-rn";
-import { withTimeout } from "../../async.js";
-import {
-  summarizeJavaScriptTasks
-} from "./js-task-metrics.js";
-const MAX_TRACE_BYTES = 16 * 1024 * 1024;
-const MAX_TRACE_EVENTS = 25e4;
-const MOBILE_TRACE_CATEGORIES = [
-  "blink.user_timing",
-  "disabled-by-default-devtools.timeline.frame"
-];
-const EXTENSION_TRACE_CATEGORIES = [
-  "blink.user_timing",
-  "devtools.timeline",
-  "disabled-by-default-devtools.timeline",
-  "disabled-by-default-devtools.timeline.frame",
-  "v8.execute"
-];
-const MOBILE_TRACE_KIND = {
-  categories: MOBILE_TRACE_CATEGORIES,
-  rendererScoped: false,
-  nativeSource: "react-native-cdp-frame-timings",
-  javascriptTasks: false
-};
-const TRACE_KINDS = {
-  extension: {
-    categories: EXTENSION_TRACE_CATEGORIES,
-    rendererScoped: true,
-    nativeSource: "chromium-cdp-frame-timings",
-    javascriptTasks: true
-  },
-  ios: MOBILE_TRACE_KIND,
-  android: MOBILE_TRACE_KIND
-};
-function createCdpTraceCollector(client, platform, marker) {
-  let active;
-  const offData = client.on("Tracing.dataCollected", (params) => {
-    if (!active || !Array.isArray(params.value)) return;
-    for (const value of params.value) {
-      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
-      const event = value;
-      const bytes = Buffer.byteLength(JSON.stringify(event));
-      if (active.events.length >= MAX_TRACE_EVENTS || active.bytes + bytes > MAX_TRACE_BYTES) {
-        active.overflow = true;
-        continue;
-      }
-      active.events.push(event);
-      active.bytes += bytes;
-    }
-  });
-  const offComplete = client.on("Tracing.tracingComplete", (params) => {
-    if (!active) return;
-    active.dataLossOccurred = params.dataLossOccurred === true;
-    active.complete?.();
-  });
-  return {
-    async start(id) {
-      if (active) throw new Error("Only one CDP performance trace may be active.");
-      let complete;
-      const completePromise = new Promise((resolve) => {
-        complete = resolve;
-      });
-      active = {
-        id,
-        events: [],
-        bytes: 0,
-        overflow: false,
-        dataLossOccurred: false,
-        complete,
-        completePromise
-      };
-      let tracingStarted = false;
-      try {
-        await client.send(
-          "Tracing.start",
-          {
-            categories: TRACE_KINDS[platform].categories.join(","),
-            transferMode: "ReportEvents"
-          },
-          15e3
-        );
-        tracingStarted = true;
-        const markerName = `mmh-clock-${id}-${Date.now()}`;
-        const sync = await marker(markerName);
-        active.markerName = markerName;
-        active.markerHostEpochMs = sync.hostEpochMs;
-        active.markerUncertaintyMs = sync.uncertaintyMs;
-      } catch (error) {
-        if (tracingStarted) {
-          await client.send("Tracing.end", {}, 5e3).catch(() => void 0);
-          await withTimeout(active.completePromise, {
-            message: "CDP tracing cleanup did not report tracingComplete.",
-            timeoutMs: 1e3
-          }).catch(() => void 0);
-        }
-        active = void 0;
-        throw error;
-      }
-    },
-    async end(id) {
-      const capture = active;
-      if (!capture || capture.id !== id) {
-        throw new Error(`Performance capture is not active: ${id}`);
-      }
-      try {
-        await client.send("Tracing.end", {}, 15e3);
-        await withTimeout(capture.completePromise, {
-          message: "CDP tracing did not report tracingComplete.",
-          timeoutMs: 3e4
-        });
-      } finally {
-        active = void 0;
-      }
-      return parseTraceCapture({
-        platform,
-        events: capture.events,
-        markerName: capture.markerName,
-        markerHostEpochMs: capture.markerHostEpochMs,
-        markerUncertaintyMs: capture.markerUncertaintyMs,
-        dataLossOccurred: capture.dataLossOccurred,
-        overflow: capture.overflow,
-        unavailableReasons: [],
-        coverageGapReasons: []
-      });
-    },
-    async close() {
-      if (active) {
-        await client.send("Tracing.end", {}, 5e3).catch(() => void 0);
-        await withTimeout(active.completePromise, {
-          message: "CDP tracing cleanup did not report tracingComplete.",
-          timeoutMs: 1e3
-        }).catch(() => void 0);
-        active = void 0;
-      }
-      offData();
-      offComplete();
-      client.close();
-    }
-  };
-}
-function parseTraceCapture(capture) {
-  const marker = findClockMarker(capture.events, capture.markerName);
-  const kind = TRACE_KINDS[capture.platform];
-  if (kind.rendererScoped && !finite(marker?.pid)) {
-    const reason = "Extension trace marker did not identify a renderer process.";
-    return {
-      platform: capture.platform,
-      javascript: unavailableJavaScriptSource("cdp-js-runtime-tasks", reason),
-      nativeUi: unavailableNativeUiSource("cdp-native-frame-timings", reason),
-      trace: traceEvidence(capture, "unresolved")
-    };
-  }
-  const scopedEvents = kind.rendererScoped && finite(marker?.pid) ? capture.events.filter((event) => event.pid === marker.pid) : capture.events;
-  const scope = !kind.rendererScoped ? "mobile-host" : finite(marker?.pid) ? "extension-renderer" : "unresolved";
-  const trace = traceEvidence(
-    { ...capture, events: scopedEvents },
-    scope,
-    kind.rendererScoped && finite(marker?.pid) ? marker.pid : void 0
-  );
-  if (!finite(marker?.ts) || capture.markerHostEpochMs === void 0 || capture.markerUncertaintyMs === void 0) {
-    const reason = "CDP trace clock marker was unavailable.";
-    return {
-      platform: capture.platform,
-      javascript: unavailableJavaScriptSource("cdp-js-runtime-tasks", reason),
-      nativeUi: unavailableNativeUiSource(
-        "cdp-native-frame-timings",
-        reason
-      ),
-      trace
-    };
-  }
-  const traceToEpochMs = (timestampUs) => capture.markerHostEpochMs + (timestampUs - marker.ts) / 1e3;
-  const gapReasons = [
-    ...capture.coverageGapReasons,
-    ...capture.overflow ? ["CDP trace retention limit was reached."] : [],
-    ...capture.dataLossOccurred ? ["CDP reported trace data loss."] : []
-  ];
-  const nativeSamples = nativeFrameSamples(
-    scopedEvents,
-    capture.platform,
-    traceToEpochMs
-  );
-  const javascriptSamples = javascriptTaskSamples(
-    scopedEvents,
-    traceToEpochMs
-  );
-  const status = capture.overflow || capture.dataLossOccurred ? "partial" : "complete";
-  return {
-    platform: capture.platform,
-    javascript: javascriptSourceResult(
-      "cdp-js-runtime-tasks",
-      javascriptSamples,
-      status,
-      gapReasons,
-      traceEventNames(scopedEvents),
-      capture.markerUncertaintyMs
-    ),
-    nativeUi: nativeUiSourceResult(
-      kind.nativeSource,
-      nativeSamples,
-      status,
-      gapReasons,
-      traceEventNames(scopedEvents),
-      capture.markerUncertaintyMs
-    ),
-    trace,
-    rawTraceEvents: normalizeTraceTimestamps(scopedEvents, traceToEpochMs)
-  };
-}
-function normalizeTraceTimestamps(events, traceToEpochMs) {
-  return events.map(
-    (event) => finite(event.ts) ? { ...event, ts: traceToEpochMs(event.ts) * 1e3 } : { ...event }
-  );
-}
-function traceEvidence(capture, scope, rendererProcessId) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const event of capture.events) {
-    const name = String(event.name ?? "");
-    counts.set(name, (counts.get(name) ?? 0) + 1);
-  }
-  return {
-    beginFrameCount: counts.get("BeginFrame") ?? 0,
-    dataLossOccurred: capture.dataLossOccurred,
-    drawFrameCount: counts.get("DrawFrame") ?? 0,
-    overflow: capture.overflow,
-    profileChunkCount: counts.get("ProfileChunk") ?? 0,
-    ...rendererProcessId === void 0 ? {} : { rendererProcessId },
-    runTaskCount: counts.get("RunTask") ?? 0,
-    scope,
-    totalEventCount: capture.events.length
-  };
-}
-function nativeFrameSamples(events, platform, traceToEpochMs) {
-  const begins = /* @__PURE__ */ new Map();
-  const frames = [];
-  for (const event of events) {
-    if (event.name !== "BeginFrame" && event.name !== "DrawFrame") continue;
-    const sequence = frameSequence(event);
-    if (!sequence || !finite(event.ts)) continue;
-    if (event.name === "BeginFrame") {
-      begins.set(sequence, event);
-      continue;
-    }
-    const begin = begins.get(sequence);
-    if (!begin || !finite(begin.ts)) continue;
-    frames.push({ beginUs: begin.ts, endUs: event.ts });
-  }
-  frames.sort((first, second) => first.beginUs - second.beginUs);
-  const frameBudgetMs = estimateFrameBudgetMs(frames);
-  if (platform === "ios") {
-    const samples = [];
-    for (let index = 1; index < frames.length; index += 1) {
-      const previous = frames[index - 1];
-      const current = frames[index];
-      if (!previous || !current) continue;
-      const durationMs = (current.beginUs - previous.beginUs) / 1e3;
-      if (durationMs <= 0) continue;
-      samples.push({
-        cadenceInterval: true,
-        completedAtEpochMs: traceToEpochMs(current.beginUs),
-        durationMs,
-        ...frameBudgetMs ? {
-          frameBudgetMs,
-          overBudget: durationMs > frameBudgetMs * 1.01
-        } : {},
-        startedAtEpochMs: traceToEpochMs(previous.beginUs)
-      });
-    }
-    return samples;
-  }
-  return frames.map((frame) => {
-    const durationMs = (frame.endUs - frame.beginUs) / 1e3;
-    return {
-      completedAtEpochMs: traceToEpochMs(frame.endUs),
-      durationMs,
-      ...frameBudgetMs ? {
-        frameBudgetMs,
-        overBudget: durationMs > frameBudgetMs * 1.01
-      } : {},
-      startedAtEpochMs: traceToEpochMs(frame.beginUs)
-    };
-  }).filter((sample) => sample.durationMs > 0);
-}
-function estimateFrameBudgetMs(frames) {
-  const cadenceMs = [];
-  for (let index = 1; index < frames.length; index += 1) {
-    const previous = frames[index - 1];
-    const current = frames[index];
-    if (!previous || !current) continue;
-    const intervalMs = (current.beginUs - previous.beginUs) / 1e3;
-    if (intervalMs >= 3.5 && intervalMs <= 40) cadenceMs.push(intervalMs);
-  }
-  if (cadenceMs.length < 5) return void 0;
-  cadenceMs.sort((first, second) => first - second);
-  const observedBudgetMs = percentile(cadenceMs, 0.1);
-  const refreshRateHz = Math.round(1e3 / observedBudgetMs);
-  return refreshRateHz >= 24 && refreshRateHz <= 240 ? 1e3 / refreshRateHz : void 0;
-}
-function percentile(sorted, quantile) {
-  if (sorted.length === 1) return sorted[0] ?? 0;
-  const position = (sorted.length - 1) * quantile;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  const lowerValue = sorted[lower] ?? 0;
-  const upperValue = sorted[upper] ?? lowerValue;
-  return lowerValue + (upperValue - lowerValue) * (position - lower);
-}
-function javascriptTaskSamples(events, traceToEpochMs) {
-  return events.filter(
-    (event) => event.name === "RunTask" && event.ph === "X" && finite(event.ts) && finite(event.dur) && event.dur > 0
-  ).map((event) => ({
-    completedAtEpochMs: traceToEpochMs(event.ts + event.dur),
-    durationMs: event.dur / 1e3
-  }));
-}
-function findClockMarker(events, markerName) {
-  if (!markerName) return void 0;
-  return events.find(
-    (candidate) => candidate.name === markerName || asRecord(candidate.args).sync_id === markerName || asRecord(asRecord(candidate.args).data).sync_id === markerName
-  );
-}
-function frameSequence(event) {
-  const args = asRecord(event.args);
-  const value = args.frameSeqId ?? asRecord(args.data).frameSeqId;
-  return value === void 0 ? void 0 : String(value);
-}
-function javascriptSourceResult(kind, samples, status, coverageGapReasons, observedEventNames, clockSyncUncertaintyMs) {
-  return {
-    applicability: "applicable",
-    status: samples.length > 0 ? status : "partial",
-    kind,
-    unavailableReasons: [],
-    coverageGapReasons: [
-      ...coverageGapReasons,
-      ...samples.length > 0 ? [] : [
-        `No ${kind} samples were recorded. Observed trace events: ${observedEventNames.join(", ") || "none"}.`
-      ]
-    ],
-    samples,
-    summary: summarizeJavaScriptTasks(samples),
-    clockSyncUncertaintyMs
-  };
-}
-function nativeUiSourceResult(kind, samples, status, coverageGapReasons, observedEventNames, clockSyncUncertaintyMs) {
-  const summary = summarizeFrames(samples);
-  const hasUnclassifiedCadenceGap = (summary.cadenceGapCount ?? 0) > 0;
-  return {
-    status: samples.length === 0 ? "partial" : hasUnclassifiedCadenceGap ? "partial" : status,
-    kind,
-    unavailableReasons: [],
-    coverageGapReasons: [
-      ...coverageGapReasons,
-      ...samples.length > 0 ? [] : [
-        `No ${kind} samples were recorded. Observed trace events: ${observedEventNames.join(", ") || "none"}.`
-      ],
-      ...hasUnclassifiedCadenceGap ? [
-        "Unclassified native cadence gap prevents a complete FPS result."
-      ] : []
-    ],
-    samples,
-    summary,
-    clockSyncUncertaintyMs
-  };
-}
-function traceEventNames(events) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const name = String(event.name ?? "unknown");
-    counts.set(name, (counts.get(name) ?? 0) + 1);
-  }
-  return [...counts.entries()].sort((first, second) => second[1] - first[1]).slice(0, 20).map(([name, count]) => `${name}(${count})`);
-}
-function unavailableJavaScriptSource(kind, reason) {
-  return {
-    applicability: "applicable",
-    status: "unavailable",
-    kind,
-    unavailableReasons: [reason],
-    coverageGapReasons: [],
-    samples: [],
-    summary: { taskCount: 0 }
-  };
-}
-function unavailableNativeUiSource(kind, reason) {
-  return {
-    status: "unavailable",
-    kind,
-    unavailableReasons: [reason],
-    coverageGapReasons: [],
-    samples: [],
-    summary: { frameCount: 0 }
-  };
-}
-function finite(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  TRACE_KINDS,
-  createCdpTraceCollector,
-  parseTraceCapture
-};

package/dist/adapters/performance/js-task-metrics.js

@@ -1,35 +0,0 @@
-const LONG_TASK_MS = 50;
-function summarizeJavaScriptTasks(samples) {
-  const durations = samples.map((sample) => sample.durationMs).filter((duration) => Number.isFinite(duration) && duration > 0).sort((first, second) => first - second);
-  if (durations.length === 0) return { taskCount: 0 };
-  const longTaskCount = durations.filter(
-    (duration) => duration >= LONG_TASK_MS
-  ).length;
-  return {
-    longestTaskMs: round(durations.at(-1) ?? 0),
-    longTaskCount,
-    longTaskPercent: round(longTaskCount / durations.length * 100),
-    p50TaskMs: round(percentile(durations, 0.5)),
-    p95TaskMs: round(percentile(durations, 0.95)),
-    p99TaskMs: round(percentile(durations, 0.99)),
-    taskCount: durations.length,
-    totalTaskTimeMs: round(
-      durations.reduce((total, duration) => total + duration, 0)
-    )
-  };
-}
-function percentile(sorted, quantile) {
-  if (sorted.length === 1) return sorted[0] ?? 0;
-  const position = (sorted.length - 1) * quantile;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  const lowerValue = sorted[lower] ?? 0;
-  const upperValue = sorted[upper] ?? lowerValue;
-  return lowerValue + (upperValue - lowerValue) * (position - lower);
-}
-function round(value) {
-  return Math.round(value * 1e3) / 1e3;
-}
-export {
-  summarizeJavaScriptTasks
-};

package/dist/async.js

@@ -1,19 +0,0 @@
-async function withTimeout(promise, options) {
-  let timer;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_resolve, reject) => {
-        timer = setTimeout(() => {
-          options.onTimeout?.();
-          reject(new Error(options.message));
-        }, options.timeoutMs);
-      })
-    ]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-export {
-  withTimeout
-};