@buoy-gg/js-top 7.0.28 → 7.0.30

package/src/js-top/engine/frameStack.ts

@@ -1,142 +0,0 @@
-/**
- * wrapTask — the single wrapper every patched entry point uses, plus the
- * frame stack that makes nested wrapped calls book EXCLUSIVE time.
- *
- * The no-double-count rule: every wrapper at any depth books
- * `(end − start) − childrenMs` to its own origin and adds its TOTAL to its
- * parent frame's childrenMs. Thread occupancy is then the sum of exclusive
- * time at all depths, which equals the union of wrapped wall intervals —
- * nesting (e.g. rAF callbacks fired inside a wrapped bridge call-in) can
- * never inflate totals.
- *
- * Naming: exported/inner functions carry a `buoyJsTop` prefix on purpose —
- * Hermes dev stacks only show function names + bundle offsets, and the
- * registry's stack parser filters engine frames by that prefix.
- */
-
-import { now } from "./now";
-import { isActive, WRAPPED_TAG } from "./state";
-import type { TaskApi } from "../types";
-import {
-  buoyJsTopBookExclusive,
-  buoyJsTopOriginExists,
-  buoyJsTopScheduleOrigin,
-} from "./originRegistry";
-
-const DEPTH_CAP = 32;
-
-interface Frame {
-  originKey: string;
-  start: number;
-  childrenMs: number;
-}
-
-const stack: Frame[] = [];
-
-/** Depth-0 completed intervals ≥ this feed the longtask correlator. */
-const NOTABLE_INTERVAL_MS = 20;
-const INTERVAL_RING_SIZE = 64;
-
-export interface CompletedInterval {
-  originKey: string;
-  start: number;
-  end: number;
-}
-
-const intervalRing: (CompletedInterval | null)[] = new Array(
-  INTERVAL_RING_SIZE,
-).fill(null);
-let intervalRingIndex = 0;
-
-/** Recent depth-0 wrapped intervals, unordered — consumers scan all slots. */
-export function recentIntervals(): (CompletedInterval | null)[] {
-  return intervalRing;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyFn = (...args: any[]) => any;
-
-/** Push a frame (unless depth-capped), run `invoke`, book on the way out. */
-function buoyJsTopRunFrame<T>(originKey: string, invoke: () => T): T {
-  const start = now();
-  const parent = stack.length > 0 ? stack[stack.length - 1] : null;
-  let frame: Frame | null = null;
-  if (stack.length < DEPTH_CAP) {
-    frame = { originKey, start, childrenMs: 0 };
-    stack.push(frame);
-  }
-  try {
-    // The user code runs OUTSIDE any catch of ours: errors propagate to the
-    // runtime's normal unhandled-error path untouched.
-    return invoke();
-  } finally {
-    try {
-      if (frame) {
-        stack.pop();
-        const end = now();
-        const total = end - start;
-        const exclusive = Math.max(0, total - frame.childrenMs);
-        if (parent) parent.childrenMs += total;
-        buoyJsTopBookExclusive(originKey, exclusive, start, end);
-        if (!parent && total >= NOTABLE_INTERVAL_MS) {
-          intervalRing[intervalRingIndex] = { originKey, start, end };
-          intervalRingIndex = (intervalRingIndex + 1) % INTERVAL_RING_SIZE;
-        }
-      }
-    } catch {
-      // Bookkeeping must never break the app.
-    }
-  }
-}
-
-/**
- * Wrap a callback at schedule time. ALWAYS wraps once patches are installed
- * (installation itself only happens on first engine start): a long-lived
- * callback — the classic forgotten setInterval — must stay attributable
- * even when it was scheduled while the engine was off, or after clear()
- * deleted its origin record. Identity is therefore resolved eagerly at
- * schedule time when possible (best stack context) and re-resolved lazily
- * at fire time otherwise. Inactive-engine cost per fire: one boolean.
- */
-export function buoyJsTopWrapTask<T extends AnyFn>(fn: T, api: TaskApi): T {
-  if (typeof fn !== "function") return fn;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  if ((fn as any)[WRAPPED_TAG]) return fn;
-  let originKey: string | null = isActive()
-    ? buoyJsTopScheduleOrigin(api, fn, now())
-    : null;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const buoyJsTopTaskWrapper = function (this: any, ...args: any[]) {
-    if (!isActive()) return fn.apply(this, args);
-    if (originKey === null || !buoyJsTopOriginExists(originKey)) {
-      // Scheduled while the engine was off, or stats cleared since —
-      // (re)resolve identity now, without stack capture (see scheduleOrigin).
-      originKey = buoyJsTopScheduleOrigin(api, fn, now(), false);
-    }
-    return buoyJsTopRunFrame(originKey, () => fn.apply(this, args));
-  } as unknown as T;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (buoyJsTopTaskWrapper as any)[WRAPPED_TAG] = true;
-  return buoyJsTopTaskWrapper;
-}
-
-/**
- * Run a thunk as a named task frame — for entry points that aren't
- * schedule-a-callback shaped (e.g. bridge call-ins, where the "origin" is
- * the module.method being invoked right now).
- */
-export function buoyJsTopRunAs<T>(
-  api: TaskApi,
-  name: string,
-  thunk: () => T,
-): T {
-  if (!isActive()) return thunk();
-  const originKey = buoyJsTopScheduleOrigin(api, { name }, now());
-  return buoyJsTopRunFrame(originKey, thunk);
-}
-
-/** Test-only: current nesting depth. */
-export function debugDepth(): number {
-  return stack.length;
-}

package/src/js-top/engine/longtasks.ts

@@ -1,137 +0,0 @@
-/**
- * Freeze tracking. RN ships a real `PerformanceObserver('longtask')` (C++
- * TurboModule, present in Expo Go and release): entries fire for any task
- * that blocks the JS event loop ≥ 50ms — what a user feels as a dropped tap
- * or stuttered animation — but carry NO attribution. We supply it: each
- * entry is overlap-matched against the ring of recent depth-0 wrapped
- * intervals; the biggest overlap names the offender.
- *
- * Freeze data doesn't get its own UI section — it decorates the places you
- * already look: per-row ⚠ badges in the task table and a summary chip in
- * the header, both fed by getFreezeStats() (trailing 60s window). The raw
- * entry list is still exported for the desktop panel and MCP payloads.
- *
- * The observer installs once and stays connected (uninstalling/reinstalling
- * observers has its own churn); its handler early-outs when the engine is
- * inactive — longtasks only fire on 50ms+ blocks, so the idle cost is nil.
- */
-
-import { g, isActive } from "./state";
-import { recentIntervals } from "./frameStack";
-import { labelForOrigin } from "./originRegistry";
-import { bookLongtaskRange } from "./aggregator";
-import type { JsTopLongtask, JsTopTiers } from "../types";
-
-const MAX_ENTRIES = 40;
-/** Freeze badges/summary only consider the trailing window. */
-const FREEZE_WINDOW_MS = 60_000;
-
-/** Per-origin key for freezes we couldn't attribute to a wrapped callback. */
-export const SYSTEM_FREEZE_KEY = "unattributed";
-
-interface FreezeEntry {
-  start: number;
-  duration: number;
-  at: number;
-  originKey: string | null;
-}
-
-export interface FreezeStats {
-  /** Freezes in the trailing window. */
-  count: number;
-  worstMs: number;
-  /** Keyed by origin key (SYSTEM_FREEZE_KEY for unattributed). */
-  byOrigin: Record<string, { count: number; maxMs: number }>;
-}
-
-let installed = false;
-let supported = false;
-const entries: FreezeEntry[] = [];
-
-function correlate(start: number, duration: number): string | null {
-  const end = start + duration;
-  let bestKey: string | null = null;
-  let bestOverlap = 0;
-  for (const interval of recentIntervals()) {
-    if (!interval) continue;
-    const overlap =
-      Math.min(end, interval.end) - Math.max(start, interval.start);
-    if (overlap > bestOverlap) {
-      bestOverlap = overlap;
-      bestKey = interval.originKey;
-    }
-  }
-  return bestKey;
-}
-
-export function installLongtaskObserver(): Partial<JsTopTiers> {
-  if (installed) return { longtask: supported };
-  installed = true;
-  const PerformanceObserverCtor = g.PerformanceObserver;
-  if (typeof PerformanceObserverCtor !== "function") {
-    return { longtask: false };
-  }
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const observer = new PerformanceObserverCtor((list: any) => {
-      if (!isActive()) return;
-      try {
-        for (const entry of list.getEntries()) {
-          if (entry.entryType !== "longtask") continue;
-          const start = entry.startTime as number;
-          const duration = entry.duration as number;
-          bookLongtaskRange(start, start + duration);
-          entries.push({
-            start,
-            duration,
-            at: Date.now(),
-            originKey: correlate(start, duration),
-          });
-          if (entries.length > MAX_ENTRIES) entries.shift();
-        }
-      } catch {
-        // Never let observation break the app.
-      }
-    });
-    observer.observe({ entryTypes: ["longtask"] });
-    supported = true;
-  } catch {
-    supported = false;
-  }
-  return { longtask: supported };
-}
-
-/** Raw recent entries (desktop panel + MCP payload shape). */
-export function getLongtasks(): JsTopLongtask[] {
-  return entries.map((e) => ({
-    start: e.start,
-    duration: e.duration,
-    at: e.at,
-    originLabel: e.originKey ? labelForOrigin(e.originKey) : null,
-  }));
-}
-
-/** Windowed per-origin freeze aggregation for badges + header summary. */
-export function getFreezeStats(now: number): FreezeStats {
-  const byOrigin: FreezeStats["byOrigin"] = {};
-  let count = 0;
-  let worstMs = 0;
-  for (const e of entries) {
-    if (e.at > 0 && now - e.at > FREEZE_WINDOW_MS) continue;
-    count++;
-    if (e.duration > worstMs) worstMs = e.duration;
-    const key = e.originKey ?? SYSTEM_FREEZE_KEY;
-    const s = byOrigin[key];
-    if (s) {
-      s.count++;
-      if (e.duration > s.maxMs) s.maxMs = e.duration;
-    } else {
-      byOrigin[key] = { count: 1, maxMs: e.duration };
-    }
-  }
-  return { count, worstMs, byOrigin };
-}
-
-export function clearLongtasks(): void {
-  entries.length = 0;
-}

package/src/js-top/engine/now.ts

@@ -1,33 +0,0 @@
-/**
- * High-res monotonic clock for the engine's hot path. Resolved once at module
- * load: `nativePerformanceNow` (JSI global, cheapest) → `performance.now` →
- * `Date.now`. All engine timestamps share this single time base.
- */
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const g: any =
-  // eslint-disable-next-line no-restricted-globals
-  typeof globalThis !== "undefined" ? globalThis : undefined;
-
-const resolved: () => number = (() => {
-  if (typeof g?.nativePerformanceNow === "function") {
-    const native = g.nativePerformanceNow as () => number;
-    return () => native();
-  }
-  if (typeof g?.performance?.now === "function") {
-    const perf = g.performance as { now: () => number };
-    return () => perf.now();
-  }
-  return () => Date.now();
-})();
-
-let clock = resolved;
-
-export function now(): number {
-  return clock();
-}
-
-/** Test-only: swap the engine clock for a controllable one. */
-export function setNowForTests(fn: (() => number) | null): void {
-  clock = fn ?? resolved;
-}