@deeeed/metamask-harness 0.82.1 → 0.84.0

package/dist/adapters/extension/browser-cdp.js

@@ -1,174 +0,0 @@
-import { WebSocket } from "ws";
-import { withTimeout } from "../../async.js";
-const DEFAULT_TIMEOUT_MS = 1e4;
-async function createBrowserCdpClient(cdpPort) {
-  if (!Number.isInteger(cdpPort) || cdpPort <= 0) {
-    throw new Error("Extension CDP requires a valid port.");
-  }
-  const version = asRecord(
-    await fetchJson(`http://127.0.0.1:${cdpPort}/json/version`)
-  );
-  const webSocketUrl = String(version.webSocketDebuggerUrl ?? "");
-  if (!webSocketUrl) {
-    throw new Error("Extension browser CDP WebSocket is unavailable.");
-  }
-  const socket = new WebSocket(webSocketUrl);
-  await waitForOpen(socket);
-  let nextId = 0;
-  const pending = /* @__PURE__ */ new Map();
-  const handlers = /* @__PURE__ */ new Set();
-  const closeHandlers = /* @__PURE__ */ new Set();
-  socket.on("message", (data) => {
-    let message;
-    try {
-      message = JSON.parse(String(data));
-    } catch {
-      return;
-    }
-    if (message.id && pending.has(message.id)) {
-      const command = pending.get(message.id);
-      pending.delete(message.id);
-      if (!command) return;
-      clearTimeout(command.timer);
-      if (message.error) {
-        command.reject(
-          new Error(
-            String(message.error.message ?? "Extension CDP command failed")
-          )
-        );
-      } else {
-        command.resolve(message.result ?? {});
-      }
-      return;
-    }
-    for (const handler of handlers) handler(message);
-  });
-  socket.on("close", () => {
-    for (const command of pending.values()) {
-      clearTimeout(command.timer);
-      command.reject(new Error("Extension browser CDP connection closed"));
-    }
-    pending.clear();
-    handlers.clear();
-    for (const handler of closeHandlers) handler();
-    closeHandlers.clear();
-  });
-  return {
-    send(method, params = {}, sessionId, timeoutMs = DEFAULT_TIMEOUT_MS) {
-      return new Promise((resolve, reject) => {
-        const id = ++nextId;
-        const timer = setTimeout(() => {
-          pending.delete(id);
-          reject(new Error(`Extension CDP command timed out: ${method}`));
-        }, timeoutMs);
-        pending.set(id, { resolve, reject, timer });
-        socket.send(
-          JSON.stringify({
-            id,
-            method,
-            params,
-            ...sessionId ? { sessionId } : {}
-          })
-        );
-      });
-    },
-    onMessage(handler) {
-      handlers.add(handler);
-      return () => handlers.delete(handler);
-    },
-    onClose(handler) {
-      closeHandlers.add(handler);
-      return () => closeHandlers.delete(handler);
-    },
-    close() {
-      socket.close();
-    }
-  };
-}
-async function fetchCdpJson(cdpPort, path = "/json") {
-  return fetchJson(`http://127.0.0.1:${cdpPort}${path}`);
-}
-function asBrowserCdpTarget(value) {
-  const target = asRecord(value);
-  const targetId = String(target.targetId ?? target.id ?? "");
-  const type = String(target.type ?? "");
-  const url = String(target.url ?? "");
-  return targetId && type && url ? { targetId, type, url } : null;
-}
-function extensionIdFromCdpTargets(value) {
-  const targets = Array.isArray(value) ? value : [];
-  for (const candidate of targets) {
-    const target = asBrowserCdpTarget(candidate);
-    if (!target) continue;
-    try {
-      const url = new URL(target.url);
-      if (url.protocol === "chrome-extension:" && url.hostname) {
-        return url.hostname;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function selectExtensionUiTarget(value, extensionId) {
-  const targets = Array.isArray(value) ? value : [];
-  const candidates = targets.map(asBrowserCdpTarget).filter((candidate) => {
-    if (!candidate || !["page", "other"].includes(candidate.type)) return false;
-    try {
-      const url = new URL(candidate.url);
-      return url.protocol === "chrome-extension:" && url.hostname === extensionId;
-    } catch {
-      return false;
-    }
-  });
-  const matchingPath = (target, pathname) => {
-    try {
-      return new URL(target.url).pathname === pathname;
-    } catch {
-      return false;
-    }
-  };
-  const home = candidates.filter((target) => matchingPath(target, "/home.html"));
-  if (home.length > 0) return home.length === 1 ? home[0] : null;
-  const sidepanel = candidates.filter(
-    (target) => matchingPath(target, "/sidepanel.html")
-  );
-  return sidepanel.length === 1 ? sidepanel[0] : null;
-}
-async function fetchJson(url) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Extension CDP returned HTTP ${response.status}.`);
-  }
-  return response.json();
-}
-function waitForOpen(socket) {
-  const onOpen = (resolve) => () => resolve();
-  let openHandler;
-  let errorHandler;
-  const opened = new Promise((resolve, reject) => {
-    openHandler = onOpen(resolve);
-    errorHandler = reject;
-    socket.once("open", openHandler);
-    socket.once("error", errorHandler);
-  });
-  return withTimeout(opened, {
-    message: "Extension browser CDP connection timed out.",
-    timeoutMs: DEFAULT_TIMEOUT_MS,
-    onTimeout: () => socket.close()
-  }).finally(() => {
-    if (openHandler) socket.off("open", openHandler);
-    if (errorHandler) socket.off("error", errorHandler);
-  });
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  asBrowserCdpTarget,
-  createBrowserCdpClient,
-  extensionIdFromCdpTargets,
-  fetchCdpJson,
-  selectExtensionUiTarget
-};

package/dist/adapters/extension/performance-observer.js

@@ -1,75 +0,0 @@
-import {
-  createCdpTraceCollector
-} from "../performance/cdp-trace.js";
-import {
-  createBrowserCdpClient,
-  fetchCdpJson,
-  selectExtensionUiTarget
-} from "./browser-cdp.js";
-import { resolveExtensionId } from "./extension-id.js";
-async function createExtensionPerformanceBackend(cdpPort, target) {
-  const extensionId = (await resolveExtensionId(target, { cdpPort })).extensionId;
-  if (!extensionId) {
-    throw new Error("Extension performance observation could not resolve the MetaMask extension id.");
-  }
-  const uiTarget = selectExtensionUiTarget(
-    await fetchCdpJson(cdpPort),
-    extensionId
-  );
-  if (!uiTarget) {
-    throw new Error("Extension performance observation requires an open MetaMask UI target.");
-  }
-  const browser = await createBrowserCdpClient(cdpPort);
-  const attached = asRecord(
-    await browser.send(
-      "Target.attachToTarget",
-      { targetId: uiTarget.targetId, flatten: true },
-      void 0,
-      1e4
-    )
-  );
-  const sessionId = String(attached.sessionId ?? "");
-  if (!sessionId) {
-    browser.close();
-    throw new Error("Extension performance observation could not attach to the MetaMask UI target.");
-  }
-  const client = browserTraceClient(browser);
-  return createCdpTraceCollector(client, "extension", async (name) => {
-    const before = Date.now();
-    await browser.send(
-      "Runtime.evaluate",
-      {
-        expression: `performance.mark(${JSON.stringify(name)})`,
-        returnByValue: true
-      },
-      sessionId,
-      1e4
-    );
-    const after = Date.now();
-    return {
-      hostEpochMs: (before + after) / 2,
-      uncertaintyMs: (after - before) / 2
-    };
-  });
-}
-function browserTraceClient(browser) {
-  return {
-    send(method, params = {}, timeoutMs) {
-      return browser.send(method, params, void 0, timeoutMs);
-    },
-    on(method, handler) {
-      return browser.onMessage((message) => {
-        if (message.method === method) handler(message.params ?? {});
-      });
-    },
-    close() {
-      browser.close();
-    }
-  };
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  createExtensionPerformanceBackend
-};

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
-};