@buoy-gg/js-top 7.0.3

package/lib/typescript/js-top/engine/JsTopController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsTopController.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/JsTopController.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAIL,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,UAAU,CAAC;AAyBlB,KAAK,kBAAkB,GAAG,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;AAC5D,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AACpD,KAAK,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D,CAAC;AAEF,cAAM,mBAAmB;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,KAAK,CAKX;IACF,OAAO,CAAC,YAAY,CAA+C;IACnE,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,kBAAkB,CAAgC;IAC1D;mEAC+D;IAC/D,OAAO,CAAC,cAAc,CAAwC;IAC9D,OAAO,CAAC,gBAAgB,CAAmD;IAC3E,OAAO,CAAC,mBAAmB,CAA8B;IACzD,OAAO,CAAC,UAAU,CAAyB;;IAW3C,SAAS,CAAC,EAAE,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAU7C,gBAAgB,CAAC,EAAE,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAQnD;6EACyE;IACzE,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI;IAiB7B,SAAS,IAAI,OAAO;IAIpB;qEACiE;IACjE,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI;IAMpC,gBAAgB,IAAI,OAAO;IAI3B,SAAS,IAAI,WAAW;IAOxB,KAAK,IAAI,IAAI;IAQb,MAAM,IAAI,IAAI;IAUd,KAAK,IAAI,IAAI;IAab,iBAAiB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI;IAIvC,WAAW,IAAI,aAAa;IAI5B;;;;OAIG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAuCtD,4DAA4D;IAC5D,qBAAqB,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI;IAO/D,wBAAwB,CAAC,EAAE,EAAE,MAAM,aAAa,CAAC,WAAW,CAAC,GAAG,IAAI;IAIpE,2BAA2B,CAAC,EAAE,EAAE,aAAa,GAAG,IAAI;IAMpD,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,WAAW;IA+BnB,OAAO,CAAC,UAAU;IAkBlB,OAAO,CAAC,aAAa;IA6DrB,OAAO,CAAC,YAAY;IAcpB,kDAAkD;IAClD,cAAc,IAAI,OAAO;CAG1B;AAED,eAAO,MAAM,eAAe,qBAA4B,CAAC;AACzD,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/lib/typescript/js-top/engine/__tests__/engine.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Unit tests for the js-top engine's pure accounting core.
+ *
+ * Same self-contained harness pattern as perf-monitor's __tests__: the repo
+ * has no Jest, so run with `npx tsx <path>`; `__tests__` is excluded from
+ * the publish build.
+ */
+export {};
+//# sourceMappingURL=engine.test.d.ts.map

package/lib/typescript/js-top/engine/__tests__/engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.test.d.ts","sourceRoot":"","sources":["../../../../../src/js-top/engine/__tests__/engine.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/lib/typescript/js-top/engine/aggregator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Global per-bucket accounting: the engine's clock is divided into 250ms
+ * buckets (epochs). Each bucket tracks measured busy ms (from the probe) and
+ * attributed ms (from wrapped tasks); `unattributed = busy − attributed` per
+ * bucket is what keeps the table honest when work enters the thread through
+ * a path we can't wrap (bridgeless events, React commits, async/await).
+ *
+ * Rings are epoch-stamped parallel arrays: a slot is only valid when its
+ * stamp matches the epoch being read, so stale slots cost nothing to skip
+ * and nothing to zero eagerly.
+ */
+export declare function epochOf(t: number): number;
+/** Book probe-measured busy time over [start, end], capped per bucket. */
+export declare function bookBusyRange(start: number, end: number): void;
+/**
+ * Book a task's exclusive ms, spread proportionally over its wall span.
+ * (Exclusive time isn't contiguous when children interleave; proportional
+ * spread is exact at 250ms-bucket granularity for all practical tasks.)
+ */
+export declare function bookAttributedRange(start: number, end: number, exclusiveMs: number): void;
+/** Book a reported longtask span (for history display only). */
+export declare function bookLongtaskRange(start: number, end: number): void;
+export declare function windowBusyMs(nowT: number): number;
+export declare function windowAttributedMs(nowT: number): number;
+/**
+ * Per-bucket UNATTRIBUTED ms (busy − attributed), oldest→newest over the
+ * rolling window — the "system" row's activity trend for the detail view.
+ */
+export declare function windowResidualBuckets(nowT: number): number[];
+/** Per-bucket busy%, oldest→newest, over the full 30s history ring. */
+export declare function busyHistory(nowT: number): number[];
+export declare function resetAggregator(): void;
+//# sourceMappingURL=aggregator.d.ts.map

package/lib/typescript/js-top/engine/aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregator.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/aggregator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AASH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzC;AAsCD,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAI9D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GAClB,IAAI,CAON;AAED,gEAAgE;AAChE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAIlE;AAYD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAY5D;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAelD;AAED,wBAAgB,eAAe,IAAI,IAAI,CAEtC"}

package/lib/typescript/js-top/engine/busyProbe.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Busy probe — measures true JS-thread occupancy from timer-gap inflation.
+ *
+ * A 16ms heartbeat (created with the PRE-PATCH setInterval so the probe never
+ * appears in its own table) can only fire when the thread yields; any gap
+ * beyond the calibrated idle baseline is time the thread was busy. This is
+ * the same physical signal as perf-monitor's stall-aware sampler, at higher
+ * frequency: multi-second stalls simply arrive as one huge gap and are booked
+ * as fully-busy buckets by bookBusyRange (the backfill falls out of the
+ * range-distribution math; no separate synthetic-sample pass needed).
+ *
+ * Calibration: the nominal 16ms is never what a real device delivers at
+ * idle. We track a rolling min gap (3 one-second slots) and subtract THAT,
+ * otherwise idle devices read 10–20% phantom busy.
+ *
+ * AppState transitions also pause JS timers, so the controller flags them
+ * via suppressNextGap() — same trick as PerfMonitorController; AppState
+ * events arrive on the JS thread, so a genuine stall can never set the flag.
+ */
+export declare function startBusyProbe(): void;
+export declare function stopBusyProbe(): void;
+export declare function suppressNextGap(): void;
+/** Test-only. */
+export declare function debugBaseline(): number;
+//# sourceMappingURL=busyProbe.d.ts.map

package/lib/typescript/js-top/engine/busyProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"busyProbe.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/busyProbe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAsDH,wBAAgB,cAAc,IAAI,IAAI,CAUrC;AAED,wBAAgB,aAAa,IAAI,IAAI,CAMpC;AAED,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED,iBAAiB;AACjB,wBAAgB,aAAa,IAAI,MAAM,CAEtC"}

package/lib/typescript/js-top/engine/frameStack.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 type { TaskApi } from "../types";
+export interface CompletedInterval {
+    originKey: string;
+    start: number;
+    end: number;
+}
+/** Recent depth-0 wrapped intervals, unordered — consumers scan all slots. */
+export declare function recentIntervals(): (CompletedInterval | null)[];
+type AnyFn = (...args: any[]) => any;
+/**
+ * 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 declare function buoyJsTopWrapTask<T extends AnyFn>(fn: T, api: TaskApi): T;
+/**
+ * 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 declare function buoyJsTopRunAs<T>(api: TaskApi, name: string, thunk: () => T): T;
+/** Test-only: current nesting depth. */
+export declare function debugDepth(): number;
+export {};
+//# sourceMappingURL=frameStack.d.ts.map

package/lib/typescript/js-top/engine/frameStack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameStack.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/frameStack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAqBxC,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAOD,8EAA8E;AAC9E,wBAAgB,eAAe,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,CAE9D;AAGD,KAAK,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAmCrC;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,GAAG,CAAC,CAqBzE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,GACb,CAAC,CAIH;AAED,wCAAwC;AACxC,wBAAgB,UAAU,IAAI,MAAM,CAEnC"}

package/lib/typescript/js-top/engine/longtasks.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 type { JsTopLongtask, JsTopTiers } from "../types";
+/** Per-origin key for freezes we couldn't attribute to a wrapped callback. */
+export declare const SYSTEM_FREEZE_KEY = "unattributed";
+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;
+    }>;
+}
+export declare function installLongtaskObserver(): Partial<JsTopTiers>;
+/** Raw recent entries (desktop panel + MCP payload shape). */
+export declare function getLongtasks(): JsTopLongtask[];
+/** Windowed per-origin freeze aggregation for badges + header summary. */
+export declare function getFreezeStats(now: number): FreezeStats;
+export declare function clearLongtasks(): void;
+//# sourceMappingURL=longtasks.d.ts.map

package/lib/typescript/js-top/engine/longtasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"longtasks.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/longtasks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAM1D,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AAShD,MAAM,WAAW,WAAW;IAC1B,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D;AAsBD,wBAAgB,uBAAuB,IAAI,OAAO,CAAC,UAAU,CAAC,CAmC7D;AAED,8DAA8D;AAC9D,wBAAgB,YAAY,IAAI,aAAa,EAAE,CAO9C;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAkBvD;AAED,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/lib/typescript/js-top/engine/now.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export declare function now(): number;
+/** Test-only: swap the engine clock for a controllable one. */
+export declare function setNowForTests(fn: (() => number) | null): void;
+//# sourceMappingURL=now.d.ts.map

package/lib/typescript/js-top/engine/now.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"now.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/now.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqBH,wBAAgB,GAAG,IAAI,MAAM,CAE5B;AAED,+DAA+D;AAC/D,wBAAgB,cAAc,CAAC,EAAE,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAE9D"}

package/lib/typescript/js-top/engine/originRegistry.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Origin registry — the "process table". An origin is the identity of a task
+ * scheduling site.
+ *
+ * Two-stage identity keeps the hot path free of stack captures:
+ *  - Cheap key `${api}|${fnName}` — computed on every schedule, just string
+ *    concat + Map lookup.
+ *  - Once an origin gets hot (PROMOTE_MIN_CALLS schedules or
+ *    PROMOTE_MIN_TOTAL_MS booked), the next schedule captures ONE
+ *    `Error().stack` (throttled per-key and globally) and refines the key
+ *    with the scheduling site's caller frame. Hermes dev stacks reference
+ *    bundle offsets, not source files — the CALLER FUNCTION NAME is the
+ *    readable part, so labels read `setInterval ← startPolling`; raw frames
+ *    are kept on the origin for future desktop symbolication.
+ */
+import { type JsTopRow, type JsTopOriginDetail, type OriginStackFrame, type TaskApi } from "../types";
+export interface Origin {
+    key: string;
+    api: TaskApi;
+    label: string;
+    /** Caller function name from the scheduling stack, once refined. */
+    caller?: string;
+    file?: string;
+    line?: number;
+    frames?: OriginStackFrame[];
+    calls: number;
+    totalMs: number;
+    maxMs: number;
+    scheduleCount: number;
+    lastSeenAt: number;
+    promoted: boolean;
+    /** On cheap origins: the refined key new work currently attributes to. */
+    activeRefinedKey?: string;
+    lastCaptureAt: number;
+    /** Dev-only Metro symbolication attempted (one shot per origin). */
+    symbolicated?: boolean;
+    ring: Float64Array;
+    ringStamps: Float64Array;
+}
+/** Pinned bucket that absorbs evicted cold origins. */
+export declare const OTHER_KEY = "other";
+/**
+ * Parse a Hermes stack into frames, skipping engine/wrapper frames. Engine
+ * functions are deliberately named with a `buoyJsTop` prefix so they are
+ * identifiable here even in bundle-offset stacks.
+ */
+export declare function parseStack(stack: string): {
+    caller?: string;
+    frames: OriginStackFrame[];
+};
+/**
+ * Resolve the origin key for a schedule. Called from patched globals at
+ * schedule time — this is the hot path; the common case is one Map get and
+ * two counter bumps.
+ */
+export declare function buoyJsTopOriginExists(key: string): boolean;
+export declare function buoyJsTopScheduleOrigin(api: TaskApi, fn: {
+    name?: string;
+    displayName?: string;
+} | ((...args: never[]) => unknown), nowT: number, 
+/**
+ * False when identity is resolved at FIRE time (callback scheduled while
+ * the engine was off, or stats cleared since): a runtime stack is not a
+ * scheduling site, so stack capture is skipped on that path.
+ */
+allowStackCapture?: boolean): string;
+/** Book a completed call's exclusive time onto its origin + global buckets. */
+export declare function buoyJsTopBookExclusive(originKey: string, exclusiveMs: number, start: number, end: number): void;
+export declare function labelForOrigin(key: string): string | null;
+/** Build the ranked table rows (excludes the pinned unattributed row — the
+ * controller assembles that from aggregator residuals). */
+export declare function buildRows(nowT: number, windowBusy: number, topN: number): JsTopRow[];
+/**
+ * Full origin detail minus freeze stats (the controller merges those). The
+ * bucket array is the origin's 5s activity trend, oldest→newest.
+ */
+export declare function getOriginDetailBase(key: string, nowT: number, windowBusy: number): Omit<JsTopOriginDetail, "freezes" | "worstFreezeMs"> | null;
+export declare function resetOrigins(): void;
+/** Test-only introspection. */
+export declare function debugGetOrigin(key: string): Origin | undefined;
+export declare function originCount(): number;
+//# sourceMappingURL=originRegistry.d.ts.map

package/lib/typescript/js-top/engine/originRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"originRegistry.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/originRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAOL,KAAK,QAAQ,EACb,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,OAAO,EACb,MAAM,UAAU,CAAC;AAOlB,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,UAAU,EAAE,YAAY,CAAC;CAC1B;AAID,uDAAuD;AACvD,eAAO,MAAM,SAAS,UAAU,CAAC;AA8DjC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B,CAuCA;AA2BD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,OAAO,EACZ,EAAE,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,EAC7E,IAAI,EAAE,MAAM;AACZ;;;;GAIG;AACH,iBAAiB,UAAO,GACvB,MAAM,CAmFR;AAuBD,+EAA+E;AAC/E,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,IAAI,CAoCN;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEzD;AAED;2DAC2D;AAC3D,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,QAAQ,EAAE,CA4DZ;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GACjB,IAAI,CAAC,iBAAiB,EAAE,SAAS,GAAG,eAAe,CAAC,GAAG,IAAI,CAmC7D;AAED,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,+BAA+B;AAC/B,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,WAAW,IAAI,MAAM,CAEpC"}

package/lib/typescript/js-top/engine/patches/bridge.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tier 2 patch: legacy-bridge call-ins. On Paper/legacy-bridge runtimes,
+ * every native→JS call (touch events via RCTEventEmitter, timer flushes via
+ * JSTimers.callTimers, module callbacks) enters through
+ * `__fbBatchedBridge.callFunctionReturnFlushedQueue` /
+ * `invokeCallbackAndReturnFlushedQueue`. Wrapping them attributes event and
+ * native-callback cost by module.method.
+ *
+ * On New Architecture (bridgeless) these globals don't exist — install
+ * reports `bridge: false` and the UI banners the coverage gap. Nested
+ * wrapped work (e.g. our wrapped rAF callbacks running inside a
+ * callTimers call-in) books exclusively via the frame stack, so this tier
+ * only ever adds its own un-nested remainder.
+ */
+import type { JsTopTiers } from "../../types";
+export declare function installBridgePatch(): Partial<JsTopTiers>;
+//# sourceMappingURL=bridge.d.ts.map

package/lib/typescript/js-top/engine/patches/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../../../src/js-top/engine/patches/bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,wBAAgB,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC,CAiDxD"}

package/lib/typescript/js-top/engine/patches/microtasks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tier 1 patch: queueMicrotask. Same install-once contract as timers.ts.
+ * (Promise reactions are Tier 1.5 — see promises.ts.)
+ */
+export declare function installMicrotaskPatches(): void;
+//# sourceMappingURL=microtasks.d.ts.map

package/lib/typescript/js-top/engine/patches/microtasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microtasks.d.ts","sourceRoot":"","sources":["../../../../../src/js-top/engine/patches/microtasks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,wBAAgB,uBAAuB,IAAI,IAAI,CAgB9C"}

package/lib/typescript/js-top/engine/patches/promises.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tier 1.5 patch: Promise reactions via Promise.prototype.then/catch/finally.
+ *
+ * All three are patched: in Hermes, catch/finally delegate to then, and the
+ * WRAPPED_TAG check in wrapTask makes the delegation harmless (a reaction
+ * wrapped by our catch patch passes through our then patch untouched).
+ *
+ * Known, documented gap: native async/await resumption never goes through
+ * `.then` — async-function bodies land in the "unattributed" row, not here.
+ *
+ * The wrapper is passthrough-first: non-function reactions
+ * (`.then(undefined, fn)`), `this` binding, and return values are preserved
+ * exactly; when the engine is inactive the original is called with the raw
+ * arguments.
+ */
+import type { JsTopTiers } from "../../types";
+export declare function installPromisePatches(): Partial<JsTopTiers>;
+//# sourceMappingURL=promises.d.ts.map

package/lib/typescript/js-top/engine/patches/promises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.d.ts","sourceRoot":"","sources":["../../../../../src/js-top/engine/patches/promises.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA+B9C,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,UAAU,CAAC,CAO3D"}

package/lib/typescript/js-top/engine/patches/timers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tier 1 patches: setTimeout / setInterval / setImmediate /
+ * requestAnimationFrame. Public globals only — RN internals (JSTimers) are
+ * private API and churn across versions.
+ *
+ * Install-once, never unpatch (see state.ts). Handles are returned from the
+ * originals unchanged, so clearTimeout/clearInterval/cancelAnimationFrame
+ * need no patching. Extra setTimeout args pass through.
+ */
+export declare function installTimerPatches(): void;
+//# sourceMappingURL=timers.d.ts.map

package/lib/typescript/js-top/engine/patches/timers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timers.d.ts","sourceRoot":"","sources":["../../../../../src/js-top/engine/patches/timers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,wBAAgB,mBAAmB,IAAI,IAAI,CAkE1C"}

package/lib/typescript/js-top/engine/state.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared engine state + pre-patch originals.
+ *
+ * `active` is the single gate every patched global checks at schedule time:
+ * patches install once and are NEVER removed (restoring originals would
+ * clobber any wrapper another library — Sentry, Reanimated — layered on top
+ * of ours after install; same reasoning as highlight-updates' CommitProfiler
+ * hook). When inactive, a patched global forwards the raw callback to the
+ * original at the cost of one boolean check.
+ *
+ * `originals` are captured BEFORE patching so the engine's own probe and
+ * notify timers never flow through the wrappers — JS TOP must not list
+ * itself as a task.
+ */
+export declare const g: any;
+export declare function isActive(): boolean;
+export declare function setActive(on: boolean): void;
+interface Originals {
+    setTimeout: typeof setTimeout;
+    setInterval: typeof setInterval;
+    clearInterval: typeof clearInterval;
+    clearTimeout: typeof clearTimeout;
+    setImmediate: typeof setImmediate | undefined;
+    requestAnimationFrame: typeof requestAnimationFrame | undefined;
+    queueMicrotask: typeof queueMicrotask | undefined;
+}
+/** Capture pre-patch globals. Idempotent; first call wins. */
+export declare function captureOriginals(): Originals;
+export declare function getOriginals(): Originals;
+/** Tag interned on patched globals so duplicate module instances skip re-patching. */
+export declare const PATCHED_TAG: unique symbol;
+/** Marker set on wrapper functions so a wrapped fn is never wrapped twice. */
+export declare const WRAPPED_TAG: unique symbol;
+export {};
+//# sourceMappingURL=state.d.ts.map

package/lib/typescript/js-top/engine/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,eAAO,MAAM,CAAC,EAAE,GAEqC,CAAC;AAItD,wBAAgB,QAAQ,IAAI,OAAO,CAElC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAE3C;AAED,UAAU,SAAS;IACjB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,YAAY,EAAE,OAAO,YAAY,GAAG,SAAS,CAAC;IAC9C,qBAAqB,EAAE,OAAO,qBAAqB,GAAG,SAAS,CAAC;IAChE,cAAc,EAAE,OAAO,cAAc,GAAG,SAAS,CAAC;CACnD;AAID,8DAA8D;AAC9D,wBAAgB,gBAAgB,IAAI,SAAS,CAa5C;AAED,wBAAgB,YAAY,IAAI,SAAS,CAExC;AAED,sFAAsF;AACtF,eAAO,MAAM,WAAW,eAAmC,CAAC;AAC5D,8EAA8E;AAC9E,eAAO,MAAM,WAAW,eAAmC,CAAC"}

package/lib/typescript/js-top/engine/symbolicate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dev-only origin symbolication via Metro's /symbolicate endpoint (the same
+ * one LogBox uses). Hermes stacks give function names + bundle offsets; for
+ * anonymous scheduling sites (the typical `useEffect(() => setInterval(…))`)
+ * that leaves an unreadable label. Metro maps the offset back to the real
+ * source file — so a row can say `setInterval ← ChatScreen.tsx:42`, which is
+ * component-level attribution in practice.
+ *
+ * Fire-and-forget with hard caps: one attempt per origin, few in flight,
+ * silent on any failure (release builds, tunnels, Metro gone). The origin's
+ * label/file/line are upgraded in place when the answer lands — the table
+ * re-renders every tick and picks it up.
+ */
+import type { Origin } from "./originRegistry";
+export declare function buoyJsTopSymbolicateOrigin(o: Origin, apiLabelText: string): void;
+//# sourceMappingURL=symbolicate.d.ts.map

package/lib/typescript/js-top/engine/symbolicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbolicate.d.ts","sourceRoot":"","sources":["../../../../src/js-top/engine/symbolicate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAuB/C,wBAAgB,0BAA0B,CACxC,CAAC,EAAE,MAAM,EACT,YAAY,EAAE,MAAM,GACnB,IAAI,CAoEN"}

package/lib/typescript/js-top/sync/jsTopSyncAdapter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Sync adapter for the JS TOP tool, consumed by @buoy-gg/external-sync's
+ * `useExternalSync` (structurally matches its ToolSyncAdapter interface so
+ * this package doesn't need a dependency on it — same pattern as
+ * perf-monitor's adapter).
+ *
+ * `subscribe` is only called while a dashboard is watching, and subscribing
+ * to JsTopController is exactly what starts the engine — so a desktop
+ * watcher auto-starts sampling and closing the desktop tool stops it. The
+ * snapshot IS the live channel; there is no heavy persisted state.
+ */
+import type { JsTopSnapshot } from "../types";
+export declare const jsTopSyncAdapter: {
+    version: number;
+    getSnapshot: () => {
+        live: JsTopSnapshot;
+        enabled: boolean;
+    };
+    subscribe: (onChange: () => void) => () => void;
+    actions: {
+        /**
+         * Silent sampling for a desktop viewer: streams snapshots without
+         * showing the device's own HUD. (Subscribing via `subscribe` already
+         * runs the engine while watched; this exists so MCP / scripted callers
+         * can force sampling on without a watch.)
+         */
+        setEnabled: (params: unknown) => void;
+        pause: () => void;
+        resume: () => void;
+        clear: () => void;
+        /** Full detail for one origin (desktop tap-through parity). */
+        getOriginDetail: (params: unknown) => import("../types").JsTopOriginDetail | null;
+        /**
+         * One-shot sample for MCP/automation: ensure the engine is running,
+         * observe for `durationMs` (default 3s, capped 30s), return the
+         * resulting snapshot. `clearFirst` resets all stats before sampling so
+         * the result attributes exactly one interaction/window. Leaves sampling
+         * in its prior state.
+         */
+        sample: (params: unknown) => Promise<JsTopSnapshot>;
+    };
+};
+//# sourceMappingURL=jsTopSyncAdapter.d.ts.map

package/lib/typescript/js-top/sync/jsTopSyncAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsTopSyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/js-top/sync/jsTopSyncAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,eAAO,MAAM,gBAAgB;;uBAEV;QAAE,IAAI,EAAE,aAAa,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE;0BAOpC,MAAM,IAAI;;QAS9B;;;;;WAKG;6BACkB,OAAO;;;;QAO5B,+DAA+D;kCACrC,OAAO;QAEjC;;;;;;WAMG;yBACoB,OAAO;;CAejC,CAAC"}

package/lib/typescript/js-top/types/index.d.ts

@@ -0,0 +1,130 @@
+/**
+ * JS TOP — live Task Manager for the React Native JS thread.
+ *
+ * Attribution model: the engine wraps every JS-thread entry point it can
+ * reach (timers, rAF, microtasks, Promise reactions, legacy-bridge call-ins)
+ * and books EXCLUSIVE time per "origin" (the place a callback was scheduled
+ * from). A high-frequency probe measures true thread occupancy; the gap
+ * between measured busy time and attributed time is surfaced honestly as an
+ * "unattributed" row rather than hidden.
+ */
+/** Which entry-point API a task came through. */
+export type TaskApi = "timeout" | "interval" | "immediate" | "raf" | "microtask" | "then" | "bridge" | "other" | "unattributed";
+/** One captured stack frame from an origin's scheduling site (dev-readable). */
+export interface OriginStackFrame {
+    file: string;
+    line: number;
+    col: number;
+}
+/**
+ * Which coverage tiers are live on this device. UIs gray out / banner what a
+ * runtime can't see (e.g. bridge call-ins don't exist on bridgeless).
+ */
+export interface JsTopTiers {
+    /** Tier 1: timers/rAF/queueMicrotask — always true once the engine runs. */
+    timers: boolean;
+    /** Tier 1.5: Promise.prototype reactions (async/await bodies excluded). */
+    promises: boolean;
+    /** Tier 2: legacy-bridge call-ins (absent on New Architecture). */
+    bridge: boolean;
+    /** PerformanceObserver('longtask') available on this runtime. */
+    longtask: boolean;
+}
+/** One row of the live table — a task origin ("process" in Task Manager terms). */
+export interface JsTopRow {
+    /** Stable identity (cheap or refined origin key). */
+    key: string;
+    /** Human label, e.g. `setInterval pollFeed` or `Promise.then @ api.ts:88`. */
+    label: string;
+    api: TaskApi;
+    /** Present once the origin was promoted and a scheduling site resolved. */
+    file?: string;
+    line?: number;
+    /** Exclusive ms booked in the rolling window (the default sort column). */
+    windowMs: number;
+    /** windowMs as a share of measured busy time in the same window, 0–100. */
+    pctOfBusy: number;
+    /** Exclusive ms since engine start / last clear. */
+    totalMs: number;
+    calls: number;
+    avgMs: number;
+    maxMs: number;
+    lastSeenAgoMs: number;
+    /** 50ms+ freezes attributed to this origin in the last 60s. */
+    freezes: number;
+    /** Worst attributed freeze duration in that window (0 when none). */
+    worstFreezeMs: number;
+}
+/** A 50ms+ blocking task reported by the runtime, with our best attribution. */
+export interface JsTopLongtask {
+    /** performance.now()-based start of the block. */
+    start: number;
+    duration: number;
+    /** Wall-clock time (Date.now()) the block was reported — for "Ns ago" UI. */
+    at: number;
+    /** Label of the wrapped origin that overlapped the block most, if any. */
+    originLabel: string | null;
+}
+/** The JSON-serializable live snapshot (device UI + external-sync payload). */
+export interface JsTopSnapshot {
+    ts: number;
+    paused: boolean;
+    /** Thread busy% over the rolling window, 0–100. */
+    busyPct: number;
+    /** Per-bucket busy% history, oldest→newest, ≤120 points (30s @ 250ms). */
+    busyHistory: number[];
+    tiers: JsTopTiers;
+    /** Top origins by windowMs, plus pinned "unattributed"/"other" rows. */
+    rows: JsTopRow[];
+    totals: {
+        attributedWindowMs: number;
+        unattributedWindowMs: number;
+        /** Wall span of the rolling window actually covered, in ms. */
+        windowMs: number;
+    };
+    /** Freezes (50ms+ blocks) over the trailing 60s — header summary chip. */
+    freezeSummary: {
+        count: number;
+        worstMs: number;
+    };
+    longtasks: JsTopLongtask[];
+}
+export type JsTopStatus = "disabled" | "running" | "paused";
+/** Everything the engine knows about one origin — the tap-through detail. */
+export interface JsTopOriginDetail {
+    key: string;
+    label: string;
+    api: TaskApi;
+    /** Scheduling site (present once the origin was promoted + captured). */
+    caller?: string;
+    file?: string;
+    line?: number;
+    frames?: OriginStackFrame[];
+    promoted: boolean;
+    /** Times a callback was scheduled from this site. */
+    scheduleCount: number;
+    /** Times a callback actually ran. */
+    calls: number;
+    totalMs: number;
+    avgMs: number;
+    maxMs: number;
+    windowMs: number;
+    pctOfBusy: number;
+    lastSeenAgoMs: number;
+    /** Exclusive ms per 250ms bucket, oldest→newest (the 5s trend). */
+    buckets: number[];
+    freezes: number;
+    worstFreezeMs: number;
+}
+/** Engine tuning constants — exported for tests. */
+export declare const BUCKET_MS = 250;
+/** Rolling "recent" window: 20 buckets = 5s. */
+export declare const WINDOW_BUCKETS = 20;
+/** Global busy history ring: 120 buckets = 30s. */
+export declare const HISTORY_BUCKETS = 120;
+export declare const MAX_ORIGINS = 500;
+/** Promotion thresholds: capture a scheduling stack once an origin is hot. */
+export declare const PROMOTE_MIN_CALLS = 25;
+export declare const PROMOTE_MIN_TOTAL_MS = 50;
+export declare const SNAPSHOT_ROWS = 30;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/js-top/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/js-top/types/index.ts"],"names":[],"mappings":"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"}

package/lib/typescript/js-top/utils/preferences.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Persisted JS TOP preferences. Same load-then-save contract as
+ * perf-monitor's hudPreferences: rehydrate async, and only persist
+ * user-driven changes after the load resolves so defaults never clobber
+ * last session's state.
+ */
+interface JsTopPrefs {
+    enabled: boolean;
+}
+export declare function loadJsTopPrefs(): Promise<JsTopPrefs>;
+export declare function saveJsTopPrefs(prefs: JsTopPrefs): Promise<void>;
+export {};
+//# sourceMappingURL=preferences.d.ts.map

package/lib/typescript/js-top/utils/preferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../../../../src/js-top/utils/preferences.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,UAAU,UAAU;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,wBAAsB,cAAc,IAAI,OAAO,CAAC,UAAU,CAAC,CAS1D;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAMrE"}