catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/bridge/perf/collectors/NavigationCollector.js

@@ -31,6 +31,10 @@ var _session = require("../core/session.js");
  */
 
 class NavigationCollector {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor(measure, nativeToWeb) {
     this._measure = measure;
     this._nativeToWeb = nativeToWeb ?? (t => t);

package/dist/native/bridge/perf/collectors/NetworkTimingCollector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * NetworkTimingCollector.js
+ *
+ * Adds lightweight Catalyst timeline spans for fetch() and XMLHttpRequest.
+ * Chrome already has detailed network timing; these spans exist to attach
+ * network work to Catalyst interaction sessions via sessionId.
+ */
+export declare class NetworkTimingCollector {
+    [key: string]: any;
+    constructor(measure: any);
+    setInteractionSource(fn: any): void;
+    setWaterfallSource(fn: any): void;
+    init(): void;
+    _wrapFetch(): void;
+    _wrapXhr(): void;
+    _start(api: any, method: any, rawUrl: any): {
+        api: any;
+        method: string;
+        url: string;
+        label: string;
+        requestId: string;
+        startMark: string;
+        startTime: number;
+        interactionId: any;
+    };
+    _finish(span: any, result?: any): void;
+    _normalizeUrl(rawUrl: any): string;
+    _labelForUrl(url: any): string;
+    _statusOk(status: any): boolean;
+}

package/dist/native/bridge/perf/collectors/NetworkTimingCollector.js

@@ -18,6 +18,10 @@ const XHR_WRAPPED = "__catalystNetworkTimingXhrWrapped";
 const XHR_META = "__catalystNetworkTimingMeta";
 const MAX_LABEL_LENGTH = 72;
 class NetworkTimingCollector {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor(measure) {
     this._measure = measure;
     this._getInteraction = null;

package/dist/native/bridge/perf/collectors/RenderCollector.d.ts

@@ -0,0 +1,47 @@
+/**
+ * RenderCollector.js
+ *
+ * Instruments: bugs #1, #6, #10, #14, #15, #16
+ *   #1  page slowness / cache miss     → LoAF during navigation session = render blocked by loading
+ *   #6  blank screens                  → LoAF blocks first render; LCP may never fire
+ *   #10 footer flash on Drug/OTC       → layout-shift fires just after navigation session closes
+ *   #14 transitions not soft           → layout-shift during nav = skeleton→content swap too abrupt
+ *   #15 quantity selector slow         → LoAF burst in the 2s after interaction (lazy chunk blocks)
+ *   #16 prescription screen touch lag  → same LoAF burst pattern after tap
+ *
+ * Spans emitted:
+ *   catalyst:loaf|<ms>ms           — long animation frame (Track: Render)
+ *                                    detail: blockingDuration, scriptCount, sessionContext
+ *   catalyst:layout-shift|<value>  — unexpected layout shift (Track: Render)
+ *                                    detail: value, sessionContext
+ *   catalyst:fps-drop|<fps>fps-min|<ms>ms — native fps-drop episode (Track: Render)
+ *                                    detail: minFps, avgFps, durationMs, sessionContext
+ *                                    closes on recovery >55fps OR after 10s max
+ *   catalyst:long-task|<ms>ms      — native long task > 16ms (Track: Render)
+ *   catalyst:mem/jvm|<MB>MB     — JVM heap PSS — Kotlin/Java objects (Track: Render, blue)
+ *   catalyst:mem/native|<MB>MB  — native heap PSS — V8 + Blink + JNI, WebView proxy (Track: Render, orange)
+ *   catalyst:mem/total|<MB>MB   — total process PSS — what Android OOM killer sees (Track: Render, purple→red)
+ *
+ * Notifies:
+ *   ScrollCollector.onLoaf()       — so scroll session can increment its loafCount
+ *   HookCollector.onLoaf()         — so hook mount sessions can detect LoAF bursts
+ */
+export declare class RenderCollector {
+    [key: string]: any;
+    constructor(measure: any, getSessionContext: any, nativeToWeb: any);
+    /** Called by index.js to wire up interaction session context. */
+    setInteractionSource(fn: any): void;
+    /** Called by index.js to wire up insights notifications. */
+    setInsightsSource(fn: any): void;
+    /** Called by index.js to feed the normalized perf store. */
+    setWaterfallSource(fn: any): void;
+    addLoafListener(fn: any): void;
+    init(): void;
+    onNativeEvent(event: any): {
+        interactionId: any;
+        startTime: number;
+        endTime: number;
+    };
+    _observeLoAF(): void;
+    _observeLayoutShift(): void;
+}

package/dist/native/bridge/perf/collectors/RenderCollector.js

@@ -35,6 +35,10 @@ var _constants = require("../core/constants.js");
  */
 
 class RenderCollector {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor(measure, getSessionContext, nativeToWeb) {
     this._measure = measure;
     // getSessionContext() returns 'navigation'|'scroll'|'keyboard'|'none'
@@ -204,6 +208,8 @@ class RenderCollector {
   _observeLoAF() {
     if (!PerformanceObserver.supportedEntryTypes?.includes("long-animation-frame")) return;
     const obs = new PerformanceObserver(list => {
+      // long-animation-frame entries carry blockingDuration/scripts, which the
+      // base PerformanceEntry type in lib.dom does not declare.
       for (const entry of list.getEntries()) {
         const start = entry.startTime;
         const end = start + entry.duration;
@@ -243,6 +249,8 @@ class RenderCollector {
   _observeLayoutShift() {
     if (!PerformanceObserver.supportedEntryTypes?.includes("layout-shift")) return;
     const obs = new PerformanceObserver(list => {
+      // layout-shift entries carry hadRecentInput/value, which the base
+      // PerformanceEntry type in lib.dom does not declare.
       for (const entry of list.getEntries()) {
         if (entry.hadRecentInput) continue; // user-initiated shift, ignore
 

package/dist/native/bridge/perf/collectors/ScrollCollector.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ScrollCollector.js
+ *
+ * Instruments: bugs #3, #13
+ *   #3  keyboard sticky scroll bug   → scroll fires during keyboard session → sticky recalc → layout thrash
+ *   #13 cart computation jank        → fps-drop-episode during scroll → scroll session marked janky
+ *
+ * Spans emitted:
+ *   catalyst:session/scroll — scroll-start → scroll-end (Track: Input, shared with keyboard)
+ *                             detail: frameDropCount, minFps, janky, scrollDuration
+ *
+ * Native events consumed (via index.js _routeNativeEvent):
+ *   scroll-start  { nativeTime }   — GestureDetector first onScroll() in CustomWebview.kt
+ *   scroll-end    { nativeTime }   — GestureDetector ACTION_UP / ACTION_CANCEL
+ *
+ * fps-drop-episode routed here (Option B) when scroll session is open:
+ *   index.js checks this._scroll._session.isOpen before calling onFpsDrop(event)
+ */
+export declare class ScrollCollector {
+    [key: string]: any;
+    constructor(measure: any, nativeToWeb: any);
+    init(): void;
+    setInsightsSource(cb: any): void;
+    setWaterfallSource(fn: any): void;
+    onLoaf(): void;
+    onScrollStart(event: any): void;
+    onScrollEnd(event: any): void;
+    onFpsDrop(event: any): void;
+}

package/dist/native/bridge/perf/collectors/ScrollCollector.js

@@ -26,6 +26,10 @@ var _session = require("../core/session.js");
  */
 
 class ScrollCollector {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor(measure, nativeToWeb) {
     this._measure = measure;
     this._nativeToWeb = nativeToWeb;

package/dist/native/bridge/perf/collectors/ThreadCollector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ThreadCollector.js
+ *
+ * Instruments: thread visibility gap during cache serving.
+ *
+ * Problem: when shouldInterceptRequest serves from cache it calls
+ * disableHardwareAcceleration() / enableHardwareAcceleration() on the WebView.
+ * This creates a software-render window that is invisible in the Render track
+ * because it happens on a bg thread and neither the thread name nor the
+ * hw-accel state appears in any existing span.
+ *
+ * Native events received (via index.js router):
+ *   hw-accel-change  { state: 'off'|'on', trigger: 'cache-serve'|'cleanup',
+ *                      thread, nativeTime }
+ *
+ * Spans emitted (on Render track):
+ *   catalyst:hw-accel/off  — software-render window open (error = bad, overlaps frames)
+ *   catalyst:hw-accel/on   — hardware acceleration restored (primary)
+ *
+ * Overlap detection:
+ *   If a LoAF overlaps a software-render window → notifyInsights so
+ *   InsightsCollector can fire an 'hw-accel-during-frame' critical insight.
+ */
+export declare class ThreadCollector {
+    [key: string]: any;
+    constructor(measure: any, nativeToWeb: any);
+    /** Called by index.js to wire up insights notifications. */
+    setInsightsSource(fn: any): void;
+    init(): void;
+    onNativeEvent(event: any): void;
+}

package/dist/native/bridge/perf/collectors/ThreadCollector.js

@@ -30,6 +30,10 @@ var _constants = require("../core/constants.js");
  */
 
 class ThreadCollector {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor(measure, nativeToWeb) {
     this._measure = measure;
     this._nativeToWeb = nativeToWeb;

package/dist/native/bridge/perf/core/constants.d.ts

@@ -0,0 +1,76 @@
+/**
+ * constants.js
+ *
+ * Single source of truth for track names, thresholds, and color rules.
+ * All collectors import from here — no magic strings scattered across files.
+ */
+export declare const TRACK_GROUP = "Catalyst";
+export declare const TRACK: {
+    NAVIGATION: string;
+    SCROLL: string;
+    INPUT: string;
+    KEYBOARD: string;
+    RENDER: string;
+    MEMORY: string;
+    CACHE: string;
+    NETWORK: string;
+    HOOK: string;
+    INTERACTION: string;
+    INSIGHTS: string;
+    NATIVE_API: string;
+};
+export declare const PREFIX: {
+    SESSION_NAV: string;
+    SESSION_SCROLL: string;
+    SESSION_INPUT: string;
+    SESSION_KEYBOARD: string;
+    LCP: string;
+    FCP: string;
+    LOAF: string;
+    LAYOUT_SHIFT: string;
+    VIEWPORT_RESIZE: string;
+    ROUTE_TRANSITION: string;
+    CACHE: string;
+    CACHE_GROUP: string;
+    NETWORK_TIMING: string;
+    NATIVE_API: string;
+    HOOK_MOUNT: string;
+    HOOK_LAZY: string;
+    INTERACTION: string;
+    SESSION_INTERACTION: string;
+    LONG_PRESS: string;
+    INSIGHT: string;
+    HW_ACCEL: string;
+    PAGE_LOAD: string;
+    COLD_START: string;
+    FPS_DROP: string;
+    LONG_TASK: string;
+    MEMORY_JVM: string;
+    MEMORY_NATIVE: string;
+    MEMORY_TOTAL: string;
+};
+export declare const THRESHOLD: {
+    LCP_BAD_MS: number;
+    NAV_SESSION_BAD_MS: number;
+    FETCH_SLOW_MS: number;
+    SCROLL_IDLE_MS: number;
+    VIEWPORT_MIN_DELTA: number;
+    CACHE_GROUP_IDLE_MS: number;
+    LOAF_WINDOW: number;
+    LONG_PRESS_MS: number;
+    INTERACTION_SLOW_MS: number;
+    LAZY_LOAF_WINDOW_MS: number;
+    CLS_BAD: number;
+};
+export declare const COLOR: {
+    ERROR: string;
+    PRIMARY: string;
+    PRIMARY_LIGHT: string;
+    PRIMARY_DARK: string;
+    SECONDARY: string;
+    SECONDARY_LIGHT: string;
+    SECONDARY_DARK: string;
+    TERTIARY: string;
+    TERTIARY_LIGHT: string;
+    TERTIARY_DARK: string;
+};

package/dist/native/bridge/perf/core/measure.d.ts

@@ -0,0 +1,39 @@
+/**
+ * measure.js
+ *
+ * Shared _measure() and _colorFor() logic used by every collector.
+ * Injected as a dependency — collectors never call performance.measure() directly.
+ *
+ * Chrome DevTools Extensibility API rules (Chrome 128+):
+ *   - detail must be { devtools: { dataType:'track-entry', ... } }
+ *   - custom data goes in properties[] as [key, value] pairs
+ *   - start AND end must both be numeric ms timestamps — passing a mark name
+ *     string as start causes silent fallback to Timings row (confirmed Chrome 145)
+ */
+export declare class Measure {
+    [key: string]: any;
+    constructor();
+    /**
+     * Record a LoAF entry so overlap detection stays current.
+     * Called by RenderCollector whenever a long-animation-frame fires.
+     */
+    recordLoaf(start: any, end: any): void;
+    overlapsLoaf(startMs: any, endMs: any): any;
+    /**
+     * Emit a performance.measure() with Chrome DevTools Extensibility API metadata.
+     *
+     * @param {string} name      - measure name (catalyst:...)
+     * @param {string} startMark - name of the opening performance.mark()
+     * @param {number} endTime   - end time in ms (performance.now()-space)
+     * @param {object} detail    - arbitrary detail fields added as properties[]
+     * @param {string} track     - Chrome DevTools track name (from TRACK constant)
+     * @param {string} [color]   - override color; if omitted, derived from name+detail
+     * @param {string} [trackGroup] - Chrome DevTools track group
+     */
+    emit(name: any, startMark: any, endTime: any, detail: {}, track: any, color?: any, trackGroup?: string): void;
+    marker(name: any, startTime: any, detail?: {}, color?: string): void;
+    _properties(detail: any): any[][];
+    _propertyName(key: any): any;
+    _propertyValue(value: any): string;
+    _colorFor(name: any, detail: any, startTime: any, endTime: any): string;
+}

package/dist/native/bridge/perf/core/measure.js

@@ -37,6 +37,10 @@ const PROPERTY_PRIORITY = {
   responseMs: 5
 };
 class Measure {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor() {
     // Rolling window of recent LoAF entries — shared across all collectors
     // so any collector can check loafOverlap without knowing about others.

package/dist/native/bridge/perf/core/session.d.ts

@@ -0,0 +1,49 @@
+/**
+ * session.js
+ *
+ * Reusable open/close session pattern.
+ * A session is a named span that stays open until explicitly closed.
+ *
+ * Usage:
+ *   const session = new Session('catalyst:session/scroll', measure, TRACK.SCROLL)
+ *   session.open({ loafCount: 0 })
+ *   session.close({ loafCount: 3, janky: true })
+ *
+ * The session owns its own start mark so callers don't track mark names.
+ */
+export declare class Session {
+    [key: string]: any;
+    /**
+     * @param {string}  name    - base measure name (catalyst:session/...)
+     * @param {Measure} measure - shared Measure instance
+     * @param {string}  track   - Chrome DevTools track name
+     */
+    constructor(name: any, measure: any, track: any);
+    get isOpen(): boolean;
+    get startTime(): any;
+    /**
+     * Open the session.
+     * @param {object} extra - any fields to carry in state (e.g. loafCount)
+     * @param {number} [atTime] - override start time (default: performance.now())
+     */
+    open(extra?: {}, atTime?: any): void;
+    /**
+     * Close the session and emit the measure.
+     * @param {object} detail - fields added to properties[] in DevTools
+     * @param {number} [atTime] - override end time (default: performance.now())
+     * @param {string} [color]  - override color
+     */
+    close(detail?: {}, atTime?: any, color?: any): void;
+    /**
+     * Read a value stored in session state (e.g. loafCount).
+     */
+    get(key: any): any;
+    /**
+     * Update a value in session state without closing.
+     */
+    set(key: any, value: any): void;
+    /**
+     * Increment a numeric counter in session state.
+     */
+    increment(key: any): void;
+}

package/dist/native/bridge/perf/core/session.js

@@ -19,6 +19,10 @@ exports.Session = void 0;
  */
 
 class Session {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   /**
    * @param {string}  name    - base measure name (catalyst:session/...)
    * @param {Measure} measure - shared Measure instance

package/dist/native/bridge/perf/core/store.d.ts

@@ -0,0 +1,37 @@
+export declare class PerfStore {
+    [key: string]: any;
+    constructor(nativeToWeb: any);
+    expose(): void;
+    snapshot(): any;
+    clear(): void;
+    recordNativeEvent(event: any, source?: string): void;
+    recordNavigation(data: any): void;
+    recordInteraction(data: any): void;
+    recordNetwork(data: any): void;
+    recordNativeApi(data: any): void;
+    recordRender(data: any): void;
+    recordHook(data: any): void;
+    recordScroll(data: any): void;
+    recordKeyboard(data: any): void;
+    recordInsight(data: any): void;
+    _recordNativeDerivedData(event: any, time: any): void;
+    _recordCacheRequest(event: any, time: any): void;
+    _recordHwAccel(event: any, time: any): void;
+    _updateMemorySummary(event: any, time: any): void;
+    _nativeEventTime(event: any): any;
+    _nativeEventLabel(event: any): any;
+    _eventKind(type: any): "cache" | "event" | "keyboard" | "page-load" | "render" | "scroll" | "startup";
+    _renderLabel(data: any): any;
+    _renderUnit(metric: any): "fps" | "ms" | "score";
+    _add(bucket: any, record: any): any;
+    _id(prefix: any): string;
+    _createData(): {
+        version: number;
+        createdAt: string;
+        events: undefined[];
+        requests: undefined[];
+        sessions: undefined[];
+        metrics: undefined[];
+        insights: undefined[];
+    };
+}

package/dist/native/bridge/perf/core/store.js

@@ -40,6 +40,10 @@ function isFiniteNumber(value) {
   return Number.isFinite(value);
 }
 class PerfStore {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor(nativeToWeb) {
     this._nativeToWeb = nativeToWeb ?? (time => time);
     this._seq = 0;

package/dist/native/bridge/perf/core/summary.d.ts

@@ -0,0 +1,60 @@
+export declare function buildSummary(data: any): {
+    generatedAt: string;
+    counts: {
+        events: any;
+        sessions: any;
+        requests: any;
+        metrics: any;
+        insights: any;
+    };
+    byKind: {
+        sessions: any;
+        requests: any;
+        metrics: any;
+    };
+    slowest: {
+        interactions: {
+            id: any;
+            label: any;
+            durationMs: any;
+        }[];
+        requests: {
+            id: any;
+            kind: any;
+            label: any;
+            durationMs: any;
+        }[];
+        render: {
+            id: any;
+            kind: any;
+            label: any;
+            durationMs: any;
+        }[];
+    };
+    interactions: {
+        id: any;
+        label: any;
+        target: any;
+        startTime: any;
+        durationMs: any;
+        requestCount: any;
+        renderIssueCount: any;
+        insightCount: any;
+        nativeApiTimeMs: any;
+        networkTimeMs: any;
+        slowestRequest: {
+            id: any;
+            kind: any;
+            label: any;
+            durationMs: any;
+        };
+        severity: string;
+    }[];
+    memory: {
+        label: any;
+        latest: any;
+        peak: any;
+        sampleCount: any;
+    };
+    findings: any[];
+};

package/dist/native/bridge/perf/core/traceExport.d.ts

@@ -0,0 +1,10 @@
+export declare function buildChromeTrace(data: any): {
+    traceEvents: any[];
+    metadata: {
+        source: string;
+        createdAt: string;
+        storeCreatedAt: any;
+        version: any;
+    };
+};
+export declare function downloadChromeTrace(data: any, filename: any): void;

package/dist/native/bridge/perf/core/waterfalls.d.ts

@@ -0,0 +1,2 @@
+export declare function buildWaterfall(data: any, type?: string): any;
+export declare function listWaterfalls(): string[];

package/dist/native/bridge/perf/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * perf/index.js — WebPerfCollector
+ *
+ * Thin orchestrator. Responsibilities:
+ *   1. Create all collectors with shared dependencies injected
+ *   2. Route native events to the correct collector
+ *   3. Wire cross-collector notifications (LoAF → Scroll, Keyboard → Scroll,
+ *      Render → Interaction session, all events → Insights)
+ *   4. Expose WebPerfCollector.init(bridge) — called from WebBridge.init()
+ *   5. Drain native batch buffer via __catalystPerfBatch + requestIdleCallback
+ *   6. Keep a normalized queryable store for console APIs and future DevTools UI
+ *
+ * No instrumentation logic lives here. All span logic is in collectors/.
+ *
+ * Native event routing (live path — __catalystPerfEvent):
+ *   keyboard-show / keyboard-hide       → KeyboardCollector
+ *   cold-start → NavigationCollector (live — emitted after page finishes, JS is ready)
+ *   page-load-start / page-load-end / page-load-error → NavigationCollector.onBatchEvent
+ *     (buffered — emitted during WebView lifecycle before JS is ready, flushed post-load)
+ *   fps-drop-episode / long-task / memory-snapshot → RenderCollector
+ *   hw-accel-change                               → ThreadCollector
+ *   scroll-start / scroll-end                     → ScrollCollector
+ *
+ * Native batch routing (post-load idle drain — __catalystPerfBatch):
+ *   boot-activity-created / boot-webview-constructed /
+ *   boot-load-url / boot-page-started / boot-page-finished → NavigationCollector.onBatchEvent
+ *   cache-hit-* / cache-miss-* / network-fetch-complete    → CacheCollector.onBatchEvent
+ *   cache-summary                                          → CacheCollector.onBatchEvent
+ *   api-call                                               → ApiCollector.onBatchEvent
+ *
+ * Web-side instrumentation:
+ *   fetch / XMLHttpRequest                                 → NetworkTimingCollector
+ *
+ * Cross-collector wiring:
+ *   RenderCollector.addLoafListener → ScrollCollector.onLoaf
+ *   RenderCollector.addLoafListener → HookCollector.onLoaf
+ *   KeyboardCollector (scroll during keyboard) → ScrollCollector.onScrollDuringKeyboard
+ *   NavigationCollector.isLoading → RenderCollector session context
+ *   InteractionCollector interaction range → RenderCollector spans
+ *   InteractionCollector.activeInteractionId → NetworkTimingCollector fetch/XHR spans
+ *   RenderCollector → InteractionCollector (onFpsDrop)
+ *   CacheCollector.cache-summary → InsightsCollector.notifyCacheSummary
+ *   All collectors → InsightsCollector (reactive warnings + session summary)
+ *   All high-level collector outputs → PerfStore for waterfalls/tables/export
+ */
+declare class WebPerfCollector {
+    [key: string]: any;
+    constructor();
+    static init(bridge: any): void;
+    _setup(bridge: any): void;
+    _drainBatch(events: any): void;
+    _routeBatchEvent(event: any): void;
+    _routeNativeEvent(event: any): void;
+    _nativeRange(event: any): {
+        startTime?: undefined;
+        endTime?: undefined;
+    } | {
+        startTime: number;
+        endTime: any;
+    };
+    _sessionContext(): "keyboard" | "navigation" | "none" | "scroll";
+}
+export default WebPerfCollector;

package/dist/native/bridge/perf/index.js

@@ -64,6 +64,10 @@ var _NetworkTimingCollector = require("./collectors/NetworkTimingCollector.js");
  */
 
 class WebPerfCollector {
+  // Internal collector state, assigned in the constructor. The perf module is
+  // internal to the bridge and deliberately left loosely typed during the
+  // migration, so an index signature stands in for per-field declarations.
+
   constructor() {
     // Align native timestamps (SystemClock.elapsedRealtime) to performance.now() space.
     // Read lazily on each call — __NATIVE_TIME_OFFSET is injected via evaluateJavascript

package/dist/native/bridge/safeArea.d.ts

@@ -0,0 +1,11 @@
+/** Device safe-area insets in CSS pixels. Every value is non-negative. */
+export interface SafeAreaInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export declare const DEFAULT_INSETS: SafeAreaInsets;
+export declare const getSafeAreaFromGlobal: () => SafeAreaInsets | null;
+export declare const setSafeAreaGlobal: (insets: any) => SafeAreaInsets;
+export declare const getSafeArea: () => SafeAreaInsets;

package/dist/native/bridge/safeArea.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.setSafeAreaGlobal = exports.getSafeAreaFromGlobal = exports.getSafeArea = exports.DEFAULT_INSETS = void 0;
+/** Device safe-area insets in CSS pixels. Every value is non-negative. */
+
 const DEFAULT_INSETS = exports.DEFAULT_INSETS = {
   top: 0,
   right: 0,