react-native-nitro-tracing 0.6.0

package/lib/module/release-profiler.mjs

@@ -0,0 +1,137 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Tracing: () => Tracing
+});
+import { NitroModules } from "react-native-nitro-modules";
+var Tracing;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    Tracing = NitroModules.createHybridObject("Tracing");
+  }
+});
+
+// src/plugins/releaseProfiler.ts
+var owner;
+var stopHermesSampler = () => {
+  try {
+    const { Tracing: Tracing2 } = (init_src(), __toCommonJS(src_exports));
+    Tracing2.disableHermesSampling();
+  } catch {
+  }
+};
+function createReleaseProfilerPlugin(api, options = {}) {
+  const identity = {};
+  let context;
+  let active = false;
+  let span;
+  let path;
+  let stopping;
+  const plugin = {
+    id: "release-profiler",
+    start(next) {
+      if (context)
+        throw new Error("Release profiler plugin is already attached");
+      context = next;
+      return {
+        async stop() {
+          try {
+            if (active) await plugin.stopProfiling();
+          } finally {
+            context = void 0;
+          }
+        }
+      };
+    },
+    startProfiling() {
+      if (!context)
+        throw new Error("Attach release-profiler plugin before profiling");
+      if (owner) throw new Error("A release profiler session is already active");
+      if (api.startProfiling() === false)
+        throw new Error("Hermes sampling profiler is unavailable in this build");
+      owner = identity;
+      active = true;
+      path = void 0;
+      try {
+        span = context.recording.startSpan({
+          name: "hermes.profile",
+          correlationId: "",
+          attributes: [{ key: "source", value: "release-profiler" }]
+        });
+      } catch (error) {
+        context.reportError(error);
+      }
+    },
+    stopProfiling() {
+      if (stopping) return stopping;
+      if (!active)
+        return Promise.reject(
+          new Error("No release profiler session is active")
+        );
+      stopping = Promise.resolve().then(async () => {
+        try {
+          path = await api.stopProfiling(false);
+          span?.end("success");
+          try {
+            context?.recording.mark({
+              name: "hermes.profile.saved",
+              correlationId: "",
+              attributes: [
+                { key: "source", value: "release-profiler" },
+                { key: "path", value: path.slice(0, 512) }
+              ]
+            });
+          } catch (error) {
+            context?.reportError(error);
+          }
+          return path;
+        } catch (error) {
+          span?.end("error");
+          throw error;
+        } finally {
+          ;
+          (options.stopSampler ?? stopHermesSampler)();
+          active = false;
+          if (owner === identity) owner = void 0;
+          span = void 0;
+          stopping = void 0;
+        }
+      });
+      return stopping;
+    },
+    isProfiling: () => active,
+    getProfilePath: () => path
+  };
+  return plugin;
+}
+export {
+  createReleaseProfilerPlugin
+};
+//# sourceMappingURL=release-profiler.mjs.map

package/lib/module/release-profiler.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts", "../../src/plugins/releaseProfiler.ts"],
+  "sourcesContent": ["import { NitroModules } from 'react-native-nitro-modules'\nimport type { Tracing as TracingFactory } from './specs/Tracing.nitro'\n/** Native recording factory. See Recording for ownership and cleanup. */\nexport const Tracing =\n  NitroModules.createHybridObject<TracingFactory>('Tracing')\nexport type { Recording } from './specs/Recording.nitro'\nexport type { TraceSpan } from './specs/TraceSpan.nitro'\nexport type * from './types'\n", "import type { TraceSpan } from '../specs/TraceSpan.nitro'\nimport type { PluginContext, TracePlugin } from './TracePlugin'\n/** Injected optional react-native-release-profiler module; never imported by core. */\nexport interface ReleaseProfilerApi {\n  /** Start the process-wide Hermes sampler; false means unavailable. */\n  startProfiling(): boolean | void\n  /** Stop and save a local profile artifact. */\n  stopProfiling(saveToDownloads?: boolean): Promise<string>\n}\n/** Manually controlled profiler integration. Sampling never starts on plugin setup. */\nexport interface ReleaseProfilerPlugin extends TracePlugin {\n  /** Start one session owned by this plugin. */\n  startProfiling(): void\n  /** Finish profiling and return the artifact's local path. */\n  stopProfiling(): Promise<string>\n  /** Whether this plugin owns an active or stopping profile. */\n  isProfiling(): boolean\n  /** Last successful artifact; not sent to remote exporters. */\n  getProfilePath(): string | undefined\n}\n// Hermes profiling is process-wide, so two plugin instances must not compete.\nlet owner: object | undefined\n/** Stops Hermes sampling for real; on RN 0.85 Android the profiler's own stop restarts it. */\nconst stopHermesSampler = () => {\n  try {\n    const { Tracing } = require('../index') as typeof import('../index')\n    Tracing.disableHermesSampling()\n  } catch {\n    // No native module (tests, non-native hosts): nothing is sampling.\n  }\n}\nexport interface ReleaseProfilerOptions {\n  /** Runs after every stop. Defaults to Tracing.disableHermesSampling(). */\n  stopSampler?: () => void\n}\n/** Attach manual Hermes profile controls to a recording. */\nexport function createReleaseProfilerPlugin(\n  api: ReleaseProfilerApi,\n  options: ReleaseProfilerOptions = {}\n): ReleaseProfilerPlugin {\n  const identity = {}\n  let context: PluginContext | undefined\n  let active = false\n  let span: TraceSpan | undefined\n  let path: string | undefined\n  let stopping: Promise<string> | undefined\n  const plugin: ReleaseProfilerPlugin = {\n    id: 'release-profiler',\n    start(next) {\n      if (context)\n        throw new Error('Release profiler plugin is already attached')\n      context = next\n      return {\n        async stop() {\n          try {\n            if (active) await plugin.stopProfiling()\n          } finally {\n            context = undefined\n          }\n        },\n      }\n    },\n    startProfiling() {\n      if (!context)\n        throw new Error('Attach release-profiler plugin before profiling')\n      if (owner) throw new Error('A release profiler session is already active')\n      if (api.startProfiling() === false)\n        throw new Error('Hermes sampling profiler is unavailable in this build')\n      owner = identity\n      active = true\n      path = undefined\n      try {\n        span = context.recording.startSpan({\n          name: 'hermes.profile',\n          correlationId: '',\n          attributes: [{ key: 'source', value: 'release-profiler' }],\n        })\n      } catch (error) {\n        context.reportError(error)\n      }\n    },\n    stopProfiling() {\n      if (stopping) return stopping\n      if (!active)\n        return Promise.reject(\n          new Error('No release profiler session is active')\n        )\n      stopping = Promise.resolve().then(async () => {\n        try {\n          path = await api.stopProfiling(false)\n          span?.end('success')\n          // Lets a Perfetto export point at the .cpuprofile covering the span above.\n          try {\n            context?.recording.mark({\n              name: 'hermes.profile.saved',\n              correlationId: '',\n              attributes: [\n                { key: 'source', value: 'release-profiler' },\n                { key: 'path', value: path.slice(0, 512) },\n              ],\n            })\n          } catch (error) {\n            context?.reportError(error)\n          }\n          return path\n        } catch (error) {\n          span?.end('error')\n          throw error\n        } finally {\n          ;(options.stopSampler ?? stopHermesSampler)()\n          active = false\n          if (owner === identity) owner = undefined\n          span = undefined\n          stopping = undefined\n        }\n      })\n      return stopping\n    },\n    isProfiling: () => active,\n    getProfilePath: () => path,\n  }\n  return plugin\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA,SAAS,oBAAoB;AAA7B,IAGa;AAHb;AAAA;AAAA;AAGO,IAAM,UACX,aAAa,mBAAmC,SAAS;AAAA;AAAA;;;ACiB3D,IAAI;AAEJ,IAAM,oBAAoB,MAAM;AAC9B,MAAI;AACF,UAAM,EAAE,SAAAA,SAAQ,IAAI;AACpB,IAAAA,SAAQ,sBAAsB;AAAA,EAChC,QAAQ;AAAA,EAER;AACF;AAMO,SAAS,4BACd,KACA,UAAkC,CAAC,GACZ;AACvB,QAAM,WAAW,CAAC;AAClB,MAAI;AACJ,MAAI,SAAS;AACb,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,QAAM,SAAgC;AAAA,IACpC,IAAI;AAAA,IACJ,MAAM,MAAM;AACV,UAAI;AACF,cAAM,IAAI,MAAM,6CAA6C;AAC/D,gBAAU;AACV,aAAO;AAAA,QACL,MAAM,OAAO;AACX,cAAI;AACF,gBAAI,OAAQ,OAAM,OAAO,cAAc;AAAA,UACzC,UAAE;AACA,sBAAU;AAAA,UACZ;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA,iBAAiB;AACf,UAAI,CAAC;AACH,cAAM,IAAI,MAAM,iDAAiD;AACnE,UAAI,MAAO,OAAM,IAAI,MAAM,8CAA8C;AACzE,UAAI,IAAI,eAAe,MAAM;AAC3B,cAAM,IAAI,MAAM,uDAAuD;AACzE,cAAQ;AACR,eAAS;AACT,aAAO;AACP,UAAI;AACF,eAAO,QAAQ,UAAU,UAAU;AAAA,UACjC,MAAM;AAAA,UACN,eAAe;AAAA,UACf,YAAY,CAAC,EAAE,KAAK,UAAU,OAAO,mBAAmB,CAAC;AAAA,QAC3D,CAAC;AAAA,MACH,SAAS,OAAO;AACd,gBAAQ,YAAY,KAAK;AAAA,MAC3B;AAAA,IACF;AAAA,IACA,gBAAgB;AACd,UAAI,SAAU,QAAO;AACrB,UAAI,CAAC;AACH,eAAO,QAAQ;AAAA,UACb,IAAI,MAAM,uCAAuC;AAAA,QACnD;AACF,iBAAW,QAAQ,QAAQ,EAAE,KAAK,YAAY;AAC5C,YAAI;AACF,iBAAO,MAAM,IAAI,cAAc,KAAK;AACpC,gBAAM,IAAI,SAAS;AAEnB,cAAI;AACF,qBAAS,UAAU,KAAK;AAAA,cACtB,MAAM;AAAA,cACN,eAAe;AAAA,cACf,YAAY;AAAA,gBACV,EAAE,KAAK,UAAU,OAAO,mBAAmB;AAAA,gBAC3C,EAAE,KAAK,QAAQ,OAAO,KAAK,MAAM,GAAG,GAAG,EAAE;AAAA,cAC3C;AAAA,YACF,CAAC;AAAA,UACH,SAAS,OAAO;AACd,qBAAS,YAAY,KAAK;AAAA,UAC5B;AACA,iBAAO;AAAA,QACT,SAAS,OAAO;AACd,gBAAM,IAAI,OAAO;AACjB,gBAAM;AAAA,QACR,UAAE;AACA;AAAC,WAAC,QAAQ,eAAe,mBAAmB;AAC5C,mBAAS;AACT,cAAI,UAAU,SAAU,SAAQ;AAChC,iBAAO;AACP,qBAAW;AAAA,QACb;AAAA,MACF,CAAC;AACD,aAAO;AAAA,IACT;AAAA,IACA,aAAa,MAAM;AAAA,IACnB,gBAAgB,MAAM;AAAA,EACxB;AACA,SAAO;AACT;",
+  "names": ["Tracing"]
+}

package/lib/module/sentry.mjs

@@ -0,0 +1,165 @@
+// src/plugins/orderSpans.ts
+function orderSpans(spans) {
+  const byId = new Map(spans.map((span) => [span.spanId, span]));
+  const children = /* @__PURE__ */ new Map();
+  const ordered = [];
+  for (const span of byId.values()) {
+    if (!span.parentSpanId || !byId.has(span.parentSpanId)) ordered.push(span);
+    else {
+      const siblings = children.get(span.parentSpanId);
+      if (siblings) siblings.push(span);
+      else children.set(span.parentSpanId, [span]);
+    }
+  }
+  for (let index = 0; index < ordered.length; index++) {
+    const descendants = children.get(ordered[index].spanId);
+    if (descendants) for (const child of descendants) ordered.push(child);
+  }
+  if (ordered.length !== byId.size)
+    throw new Error("Cannot export cyclic span parents");
+  return ordered;
+}
+
+// src/plugins/sentry.ts
+function createSentryPlugin(options) {
+  return {
+    id: "sentry",
+    start({ recording, reportError }) {
+      const { sentry } = options;
+      const stats = recording.getStats();
+      const anchor = stats.startedAtUnixMs;
+      const client = sentry.getClient();
+      if (options.captureSpans && !client)
+        throw new Error("Initialize Sentry before enabling local capture");
+      const recordMeasurements = (data, start, anchorMs) => {
+        const end = (data.timestamp ?? data.start_timestamp) * 1e3 - anchorMs;
+        const metric = (name, value, unit) => {
+          if (typeof value !== "number" || !Number.isFinite(value)) return;
+          recording.recordMetric({
+            name,
+            value,
+            unit,
+            timestampMs: Math.max(0, end),
+            correlationId: data.trace_id,
+            attributes: [
+              { key: "source", value: "sentry" },
+              {
+                key: "span",
+                value: (data.description || data.op || "").slice(0, 256)
+              }
+            ]
+          });
+        };
+        metric("ui.frames.total", data.data?.["frames.total"], "count");
+        metric("ui.frames.slow", data.data?.["frames.slow"], "count");
+        metric("ui.frames.frozen", data.data?.["frames.frozen"], "count");
+        if (data.op === "app.start.cold" || data.op === "app.start.warm")
+          metric(data.op, end - start, "ms");
+      };
+      const unsubscribe = options.captureSpans ? client.on("spanEnd", (span) => {
+        try {
+          const data = sentry.spanToJSON(span);
+          if (data.data?.["nitro.exported"] || data.timestamp === void 0)
+            return;
+          const start = data.start_timestamp * 1e3 - anchor;
+          if (start < 0) return;
+          recording.recordSpan({
+            name: (data.description || data.op || "sentry.span").slice(
+              0,
+              128
+            ),
+            correlationId: data.trace_id,
+            timestampMs: start,
+            sourceSpanId: `sentry:${data.trace_id}:${data.span_id}`,
+            sourceParentSpanId: data.parent_span_id ? `sentry:${data.trace_id}:${data.parent_span_id}` : void 0,
+            durationMs: Math.max(
+              0,
+              (data.timestamp - data.start_timestamp) * 1e3
+            ),
+            outcome: data.status && data.status !== "ok" ? "error" : "success",
+            attributes: [
+              { key: "source", value: "sentry" },
+              { key: "sentry.span_id", value: data.span_id },
+              {
+                key: "sentry.parent_span_id",
+                value: data.parent_span_id || ""
+              }
+            ]
+          });
+          recordMeasurements(data, start, anchor);
+        } catch (error) {
+          reportError(error);
+        }
+      }) : void 0;
+      return {
+        stop() {
+          unsubscribe?.();
+        },
+        async flush() {
+          if (options.exportSpans !== true) return;
+          if (!sentry.getClient())
+            throw new Error("Initialize Sentry before exporting traces");
+          const spans = [];
+          let cursor = 0;
+          while (true) {
+            const page = await recording.readEvents({
+              afterSequence: cursor,
+              limit: 1e3
+            });
+            spans.push(
+              ...page.spans.filter(
+                (s) => !s.attributes.some(
+                  (a) => a.key === "source" && a.value === "sentry"
+                )
+              )
+            );
+            if (page.nextSequence === cursor) break;
+            cursor = page.nextSequence;
+          }
+          const ordered = orderSpans(spans);
+          const handles = /* @__PURE__ */ new Map();
+          const keys = new Set(options.exportedAttributeKeys ?? []);
+          for (let index = 0; index < ordered.length; index++) {
+            if (index > 0 && index % 250 === 0)
+              await new Promise((resolve) => setTimeout(resolve, 0));
+            const span = ordered[index];
+            const id = span.spanId;
+            const parentSpan = handles.get(span.parentSpanId);
+            const exported = sentry.startInactiveSpan({
+              name: span.name,
+              op: "nitro.trace",
+              startTime: (anchor + span.timestampMs) / 1e3,
+              parentSpan: parentSpan ?? null,
+              forceTransaction: !parentSpan,
+              attributes: {
+                ...Object.fromEntries(
+                  span.attributes.filter((a) => keys.has(a.key)).map((a) => [a.key, a.value])
+                ),
+                "nitro.exported": true,
+                "nitro.span_id": id,
+                "nitro.parent_missing": Boolean(
+                  span.parentSpanId && !parentSpan
+                ),
+                "nitro.outcome": span.outcome
+              }
+            });
+            exported.setStatus(
+              span.outcome === "success" ? { code: 1 } : { code: 2, message: span.outcome }
+            );
+            handles.set(id, exported);
+          }
+          for (let index = ordered.length - 1; index >= 0; index--) {
+            const span = ordered[index];
+            handles.get(span.spanId).end((anchor + span.timestampMs + span.durationMs) / 1e3);
+            if (index > 0 && index % 250 === 0)
+              await new Promise((resolve) => setTimeout(resolve, 0));
+          }
+        }
+      };
+    }
+  };
+}
+export {
+  createSentryPlugin
+};
+//# sourceMappingURL=sentry.mjs.map

package/lib/module/sentry.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/plugins/orderSpans.ts", "../../src/plugins/sentry.ts"],
+  "sourcesContent": ["import type { SpanEvent } from '../types'\n/** Parent-first order in O(n), including parents delivered after their children. */\nexport function orderSpans(spans: readonly SpanEvent[]): SpanEvent[] {\n  const byId = new Map(spans.map((span) => [span.spanId, span]))\n  const children = new Map<string, SpanEvent[]>()\n  const ordered: SpanEvent[] = []\n  for (const span of byId.values()) {\n    if (!span.parentSpanId || !byId.has(span.parentSpanId)) ordered.push(span)\n    else {\n      const siblings = children.get(span.parentSpanId)\n      if (siblings) siblings.push(span)\n      else children.set(span.parentSpanId, [span])\n    }\n  }\n  for (let index = 0; index < ordered.length; index++) {\n    const descendants = children.get(ordered[index]!.spanId)\n    if (descendants) for (const child of descendants) ordered.push(child)\n  }\n  if (ordered.length !== byId.size)\n    throw new Error('Cannot export cyclic span parents')\n  return ordered\n}\n", "import type * as Sentry from '@sentry/react-native'\nimport type { SpanEvent } from '../types'\nimport type { TracePlugin } from './TracePlugin'\nimport { orderSpans } from './orderSpans'\n/** Optional Sentry capabilities; SDK initialization and consent remain app-owned. */\nexport interface SentryPluginOptions {\n  /** Inject an installed SDK. This module has no runtime SDK dependency. */\n  sentry: Pick<typeof Sentry, 'getClient' | 'spanToJSON' | 'startInactiveSpan'>\n  /** Capture observable SDK spans locally. Defaults to false; sampling applies. */\n  captureSpans?: boolean\n  /** Explicitly opt into sending retained span names/timing/status to Sentry on stop. Defaults to false. */\n  exportSpans?: boolean\n  /** Only these sanitized custom attribute keys may leave the device. Defaults to none. */\n  exportedAttributeKeys?: readonly string[]\n}\n/** Optional SDK measurements and opt-in export; neither direction is enabled implicitly. */\nexport function createSentryPlugin(options: SentryPluginOptions): TracePlugin {\n  return {\n    id: 'sentry',\n    start({ recording, reportError }) {\n      const { sentry } = options\n      const stats = recording.getStats()\n      const anchor = stats.startedAtUnixMs\n      const client = sentry.getClient()\n      if (options.captureSpans && !client)\n        throw new Error('Initialize Sentry before enabling local capture')\n      /** Sentry as the measurement layer: its frame and app-start data use the native metric names. */\n      const recordMeasurements = (\n        data: ReturnType<typeof sentry.spanToJSON>,\n        start: number,\n        anchorMs: number\n      ) => {\n        const end = (data.timestamp ?? data.start_timestamp) * 1000 - anchorMs\n        const metric = (name: string, value: unknown, unit: string) => {\n          if (typeof value !== 'number' || !Number.isFinite(value)) return\n          recording.recordMetric({\n            name,\n            value,\n            unit,\n            timestampMs: Math.max(0, end),\n            correlationId: data.trace_id,\n            attributes: [\n              { key: 'source', value: 'sentry' },\n              {\n                key: 'span',\n                value: (data.description || data.op || '').slice(0, 256),\n              },\n            ],\n          })\n        }\n        // Set by Sentry's nativeFrames integration on spans it measured.\n        metric('ui.frames.total', data.data?.['frames.total'], 'count')\n        metric('ui.frames.slow', data.data?.['frames.slow'], 'count')\n        metric('ui.frames.frozen', data.data?.['frames.frozen'], 'count')\n        // appStart integration spans: app.start.cold / app.start.warm.\n        if (data.op === 'app.start.cold' || data.op === 'app.start.warm')\n          metric(data.op, end - start, 'ms')\n      }\n      const unsubscribe = options.captureSpans\n        ? client!.on('spanEnd', (span) => {\n            try {\n              const data = sentry.spanToJSON(span)\n              if (data.data?.['nitro.exported'] || data.timestamp === undefined)\n                return\n              const start = data.start_timestamp * 1000 - anchor\n              if (start < 0) return\n              recording.recordSpan({\n                name: (data.description || data.op || 'sentry.span').slice(\n                  0,\n                  128\n                ),\n                correlationId: data.trace_id,\n                timestampMs: start,\n                sourceSpanId: `sentry:${data.trace_id}:${data.span_id}`,\n                sourceParentSpanId: data.parent_span_id\n                  ? `sentry:${data.trace_id}:${data.parent_span_id}`\n                  : undefined,\n                durationMs: Math.max(\n                  0,\n                  (data.timestamp - data.start_timestamp) * 1000\n                ),\n                outcome:\n                  data.status && data.status !== 'ok' ? 'error' : 'success',\n                attributes: [\n                  { key: 'source', value: 'sentry' },\n                  { key: 'sentry.span_id', value: data.span_id },\n                  {\n                    key: 'sentry.parent_span_id',\n                    value: data.parent_span_id || '',\n                  },\n                ],\n              })\n              recordMeasurements(data, start, anchor)\n            } catch (error) {\n              reportError(error)\n            }\n          })\n        : undefined\n      return {\n        stop() {\n          unsubscribe?.()\n        },\n        async flush() {\n          if (options.exportSpans !== true) return\n          if (!sentry.getClient())\n            throw new Error('Initialize Sentry before exporting traces')\n          const spans: SpanEvent[] = []\n          let cursor = 0\n          while (true) {\n            const page = await recording.readEvents({\n              afterSequence: cursor,\n              limit: 1000,\n            })\n            spans.push(\n              ...page.spans.filter(\n                (s) =>\n                  !s.attributes.some(\n                    (a) => a.key === 'source' && a.value === 'sentry'\n                  )\n              )\n            )\n            if (page.nextSequence === cursor) break\n            cursor = page.nextSequence\n          }\n          const ordered = orderSpans(spans)\n          const handles = new Map<\n            string,\n            ReturnType<typeof sentry.startInactiveSpan>\n          >()\n          const keys = new Set(options.exportedAttributeKeys ?? [])\n          for (let index = 0; index < ordered.length; index++) {\n            if (index > 0 && index % 250 === 0)\n              await new Promise<void>((resolve) => setTimeout(resolve, 0))\n            const span = ordered[index]!\n            const id = span.spanId\n            const parentSpan = handles.get(span.parentSpanId)\n            const exported = sentry.startInactiveSpan({\n              name: span.name,\n              op: 'nitro.trace',\n              startTime: (anchor + span.timestampMs) / 1000,\n              parentSpan: parentSpan ?? null,\n              forceTransaction: !parentSpan,\n              attributes: {\n                ...Object.fromEntries(\n                  span.attributes\n                    .filter((a) => keys.has(a.key))\n                    .map((a) => [a.key, a.value])\n                ),\n                'nitro.exported': true,\n                'nitro.span_id': id,\n                'nitro.parent_missing': Boolean(\n                  span.parentSpanId && !parentSpan\n                ),\n                'nitro.outcome': span.outcome,\n              },\n            })\n            exported.setStatus(\n              span.outcome === 'success'\n                ? { code: 1 }\n                : { code: 2, message: span.outcome }\n            )\n            handles.set(id, exported)\n          }\n          for (let index = ordered.length - 1; index >= 0; index--) {\n            const span = ordered[index]!\n            handles\n              .get(span.spanId)!\n              .end((anchor + span.timestampMs + span.durationMs) / 1000)\n            if (index > 0 && index % 250 === 0)\n              await new Promise<void>((resolve) => setTimeout(resolve, 0))\n          }\n        },\n      }\n    },\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/typescript/client.d.ts

@@ -0,0 +1,4 @@
+export { createTraceClient } from './src/client/createTraceClient';
+export type { TraceClient, TraceClientOptions, TraceClientSnapshot, ClientAttributes, TraceFormat, } from './src/client/createTraceClient';
+export type { PlaygroundReport, PlaygroundCheckId, } from './src/client/playground';
+export type { TracingEntry, TracingSink } from './src/client/TracingSink';

package/lib/typescript/expo.d.ts

@@ -0,0 +1,2 @@
+export { createExpoTraceSharing, registerTraceDevMenu } from './src/expo';
+export type { ExpoSharingOptions } from './src/expo';

package/lib/typescript/performance.d.ts

@@ -0,0 +1,2 @@
+export { createPerformancePlugin } from './src/plugins/performance';
+export type { PerformancePluginOptions } from './src/plugins/performance';

package/lib/typescript/plugins.d.ts

@@ -0,0 +1,12 @@
+export { startPlugins } from './src/plugins/startPlugins';
+export type { TracePlugin, PluginContext, PluginHandle, } from './src/plugins/TracePlugin';
+export { createRuntimeMetricsPlugin } from './src/plugins/runtimeMetrics';
+export type { RuntimeMetricsOptions } from './src/plugins/runtimeMetrics';
+export { createNavigationPlugin, createScreenTracker, } from './src/plugins/navigation';
+export type { NavigationRefLike, NavigationPluginOptions, } from './src/plugins/navigation';
+export { createNetworkPlugin, urlTemplate } from './src/plugins/network';
+export type { NetworkPluginOptions } from './src/plugins/network';
+export { createErrorsPlugin } from './src/plugins/errors';
+export type { ErrorsPluginOptions, ErrorUtilsLike } from './src/plugins/errors';
+export { createNativeMetricsPlugin } from './src/plugins/nativeMetrics';
+export type { NativeMetricsOptions } from './src/plugins/nativeMetrics';

package/lib/typescript/react.d.ts

@@ -0,0 +1,5 @@
+export { TraceInspector } from './src/react/TraceInspector';
+export { TraceOverlay } from './src/react/TraceOverlay';
+export { defaultLabels } from './src/react/labels';
+export type { InspectorLabels, InspectorTranslator, InspectorLabelKey, } from './src/react/labels';
+export { useAppReadyMetric } from './src/react/useAppReadyMetric';

package/lib/typescript/release-profiler.d.ts

@@ -0,0 +1,2 @@
+export { createReleaseProfilerPlugin } from './src/plugins/releaseProfiler';
+export type { ReleaseProfilerApi, ReleaseProfilerOptions, ReleaseProfilerPlugin, } from './src/plugins/releaseProfiler';

package/lib/typescript/sentry.d.ts

@@ -0,0 +1,2 @@
+export { createSentryPlugin } from './src/plugins/sentry';
+export type { SentryPluginOptions } from './src/plugins/sentry';

package/lib/typescript/src/client/TracingSink.d.ts

@@ -0,0 +1,10 @@
+/** Optional compatibility output for app logs and breadcrumbs, separate from native retention. */
+export interface TracingEntry {
+    name: string;
+    entryType: string;
+    durationMs: number;
+    value?: number | string;
+    attributes?: Record<string, unknown>;
+}
+export type TracingSink = (line: string, entry: TracingEntry) => void;
+export declare function formatTracingEntry(entry: TracingEntry): string;

package/lib/typescript/src/client/createTraceClient.d.ts

@@ -0,0 +1,82 @@
+import { type RuntimeMetricsOptions } from '../plugins/runtimeMetrics';
+import { type TracingSink } from './TracingSink';
+import type { Recording } from '../specs/Recording.nitro';
+import type { RecordingOptions } from '../types';
+import type { PerformancePluginOptions } from '../plugins/performance';
+import type { TracePlugin } from '../plugins/TracePlugin';
+import type { ReleaseProfilerPlugin } from '../plugins/releaseProfiler';
+import { type PlaygroundReport } from './playground';
+/** `recording`: lossless native schema. `perfetto`: Chrome Trace Events for ui.perfetto.dev. */
+export type TraceFormat = 'recording' | 'perfetto';
+export type ClientAttributes = Record<string, string | number | boolean | undefined>;
+export interface TraceClientOptions {
+    /** Optional app log/breadcrumb output; failures never affect measured work. */
+    sink?: TracingSink;
+    plugins?: TracePlugin[];
+    performance?: false | PerformancePluginOptions;
+    /** Opt in to foreground JS event-loop and frame-callback metrics. */
+    runtimeMetrics?: boolean | RuntimeMetricsOptions;
+    onError?: (error: unknown) => void;
+    recordingOptions?: Partial<RecordingOptions>;
+    /** Serialize and deliver a recording; `format` picks raw recording JSON or Perfetto trace events. */
+    share?: (recording: Recording, format: TraceFormat) => Promise<void>;
+    shareProfile?: (path: string) => Promise<void>;
+    /** Start Hermes sampling with each recording; stopped and saved with it. */
+    autoProfile?: boolean;
+    /**
+     * CPU profile window captured by `flag()` when a profiler is attached and idle.
+     * Default 10000 ms; 0 records only the flag mark.
+     */
+    flagProfileMs?: number;
+    profiler?: ReleaseProfilerPlugin;
+}
+export interface TraceClientSnapshot {
+    visible: boolean;
+    recording: boolean;
+    busy: boolean;
+    disposed: boolean;
+    error?: string;
+    profiling: boolean;
+    profilePath?: string;
+    playground?: PlaygroundReport;
+    /** Plugin IDs started for the current recording, so the UI can tell untracked from quiet. */
+    collectors?: string[];
+}
+/** Each client exclusively owns its recording and producers. Consumers must dispose it. */
+export declare function createTraceClient(options?: TraceClientOptions): {
+    /** Once per client lifetime: elapsed time from client creation to the app-defined ready signal. */
+    reportAppReady(): void;
+    trace: {
+        mark(name: string, attributes?: ClientAttributes): void;
+        metric(name: string, value: number | string, attributes?: ClientAttributes): void;
+        measure<T>(name: string, fn: () => Promise<T>, attributes?: ClientAttributes): Promise<T>;
+        measureSince(name: string, startName: string, id: string, attributes?: ClientAttributes): void;
+        clear(id: string): void;
+    };
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    clear: () => Promise<void>;
+    getRecording: () => Recording | undefined;
+    getError: () => string | undefined;
+    getSnapshot: () => TraceClientSnapshot;
+    subscribe(listener: () => void): () => void;
+    open(): void;
+    close(): void;
+    reportError: (error: unknown) => void;
+    canShare: boolean;
+    canProfile: boolean;
+    canShareProfile: boolean;
+    export: () => Promise<void>;
+    /** Share a snapshot while recording continues, e.g. right after catching a problem. */
+    shareTrace: (format?: TraceFormat) => Promise<void>;
+    /**
+     * Mark the moment a tester saw a problem. With an idle profiler this also captures
+     * a bounded Hermes profile, so the flag ships with what the JS thread was doing.
+     */
+    flag: (note?: string) => void;
+    toggleProfile: () => Promise<void>;
+    shareProfile: () => Promise<void>;
+    playground: () => Promise<void>;
+    dispose(): Promise<void>;
+};
+export type TraceClient = ReturnType<typeof createTraceClient>;

package/lib/typescript/src/client/playground.d.ts

@@ -0,0 +1,12 @@
+import type { Recording } from '../specs/Recording.nitro';
+export type PlaygroundCheckId = 'nested' | 'concurrency' | 'cancelled' | 'idempotent' | 'error' | 'metrics';
+export interface PlaygroundReport {
+    correlationId: string;
+    checks: {
+        id: PlaygroundCheckId;
+        passed: boolean;
+    }[];
+    passed: boolean;
+}
+/** Adds a small isolated scenario; never resets or stops the user's recording. */
+export declare const recordPlayground: (current: Recording) => Promise<PlaygroundReport>;

package/lib/typescript/src/expo/ExpoAdapter.d.ts

@@ -0,0 +1,15 @@
+import type { TraceClient, TraceFormat } from '../client/createTraceClient';
+import type { Recording } from '../specs/Recording.nitro';
+export interface ExpoSharingOptions {
+    dialogTitle?: string;
+}
+/** Native OS file sharing. No remote upload or file-path export to telemetry. */
+export declare function createExpoTraceSharing(options?: ExpoSharingOptions): {
+    share(recording: Recording, format?: TraceFormat): Promise<void>;
+    shareProfile(path: string): Promise<void>;
+};
+/** Register only in a development build. The consumer owns client disposal. */
+export declare function registerTraceDevMenu(client: TraceClient, options?: {
+    name?: string;
+    registerDevMenuItems?: typeof import('expo-dev-client').registerDevMenuItems;
+}): Promise<void>;

package/lib/typescript/src/expo/index.d.ts

@@ -0,0 +1,2 @@
+export { createExpoTraceSharing, registerTraceDevMenu } from './ExpoAdapter';
+export type { ExpoSharingOptions } from './ExpoAdapter';

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,6 @@
+import type { Tracing as TracingFactory } from './specs/Tracing.nitro';
+/** Native recording factory. See Recording for ownership and cleanup. */
+export declare const Tracing: TracingFactory;
+export type { Recording } from './specs/Recording.nitro';
+export type { TraceSpan } from './specs/TraceSpan.nitro';
+export type * from './types';

package/lib/typescript/src/plugins/TracePlugin.d.ts

@@ -0,0 +1,22 @@
+import type { Recording } from '../specs/Recording.nitro';
+/** Shared native destination supplied to measurement and export plugins. */
+export interface PluginContext {
+    /** Active native recording. */
+    recording: Recording;
+    /** Surface plugin failures without changing application operations. */
+    reportError(error: unknown): void;
+}
+/** Cleanup owned by a started plugin. */
+export interface PluginHandle {
+    /** Disconnect observers and finish export before native recording disposal. */
+    stop(): void | Promise<void>;
+    /** Optional exporter flush after sources stop and native history freezes. */
+    flush?(): void | Promise<void>;
+}
+/** Optional measurement source, exporter or profiler integration. */
+export interface TracePlugin {
+    /** Unique stable configuration identity. */
+    readonly id: string;
+    /** Start once per recording; must roll back resources if setup throws. */
+    start(context: PluginContext): PluginHandle;
+}

package/lib/typescript/src/plugins/errors.d.ts

@@ -0,0 +1,15 @@
+import type { TracePlugin } from './TracePlugin';
+type Handler = (error: unknown, isFatal?: boolean) => void;
+export interface ErrorUtilsLike {
+    getGlobalHandler(): Handler;
+    setGlobalHandler(handler: Handler): void;
+}
+export interface ErrorsPluginOptions {
+    /** Defaults to React Native's global ErrorUtils. */
+    errorUtils?: ErrorUtilsLike;
+    /** Also record console.error calls. Default false; libraries log non-fatal noise there. */
+    console?: boolean;
+}
+/** Records uncaught JS errors as `js.error` marks, then calls the previous handler unchanged. */
+export declare function createErrorsPlugin(options?: ErrorsPluginOptions): TracePlugin;
+export {};

package/lib/typescript/src/plugins/nativeMetrics.d.ts

@@ -0,0 +1,13 @@
+import type { TracePlugin } from './TracePlugin';
+export interface NativeMetricsOptions {
+    /** Metric window; 250–60000 ms. Default 1000. */
+    intervalMs?: number;
+    /** Main-thread frame metrics (ui.fps, ui.frame_gap.max, ui.frames.slow/frozen). Default true. */
+    frames?: boolean;
+}
+/**
+ * Native measurement layer: a sampler thread writes process.cpu, process.memory and
+ * main-thread frame windows straight into the recording, with no per-frame JS work.
+ * Alternative or complement to Sentry's measurements; each metric carries source=native.
+ */
+export declare function createNativeMetricsPlugin(options?: NativeMetricsOptions): TracePlugin;

package/lib/typescript/src/plugins/navigation.d.ts

@@ -0,0 +1,29 @@
+import type { TracePlugin } from './TracePlugin';
+/** Structural subset of a React Navigation container ref (expo-router: useNavigationContainerRef()). */
+export interface NavigationRefLike {
+    addListener(event: 'state' | 'ready', listener: () => void): () => void;
+    getCurrentRoute(): {
+        name: string;
+        key?: string;
+    } | undefined;
+    /** React Navigation logs an error when getCurrentRoute() runs before mount. */
+    isReady?(): boolean;
+}
+export interface NavigationPluginOptions {
+    /** Defaults to requestAnimationFrame. */
+    requestFrame?: (callback: () => void) => unknown;
+}
+/**
+ * Per focused route: a `navigation.enter` mark, a `screen <name>` visit span (dwell time)
+ * and a `navigation.transition` metric from state change to the second frame callback.
+ * The transition is a render-opportunity estimate, not content readiness.
+ */
+export declare function createNavigationPlugin(ref: NavigationRefLike, options?: NavigationPluginOptions): TracePlugin;
+/** For apps without React Navigation (custom tabs): pass to createNavigationPlugin, call setScreen on change. */
+export declare function createScreenTracker(initial?: string): {
+    addListener(_event: "state" | "ready", listener: () => void): () => undefined;
+    getCurrentRoute: () => {
+        name: string;
+    } | undefined;
+    setScreen(name: string): void;
+};

package/lib/typescript/src/plugins/network.d.ts

@@ -0,0 +1,23 @@
+import type { TracePlugin } from './TracePlugin';
+type Fetch = typeof fetch;
+export interface NetworkPluginOptions {
+    /** Defaults to the global XMLHttpRequest, which backs axios and React Native's polyfilled fetch. */
+    XMLHttpRequest?: {
+        prototype: XMLHttpRequest;
+    };
+    /** Object whose `fetch` is wrapped. Defaults to globalThis. */
+    fetchHost?: {
+        fetch?: Fetch;
+    };
+    /** Skip matching URLs. Defaults to Metro symbolication requests. */
+    ignore?: (url: string) => boolean;
+}
+/** Path without origin/query; numeric, UUID and long hex segments become `:id` so requests group. */
+export declare const urlTemplate: (url: string) => string;
+/**
+ * Opt-in request timing: method, URL without query, status and duration. Bodies and headers
+ * are never read. XMLHttpRequest spans end at loadend; native fetch spans (expo/fetch,
+ * nitro-fetch) end when response headers arrive, since reading bodies is left to the app.
+ */
+export declare function createNetworkPlugin(options?: NetworkPluginOptions): TracePlugin;
+export {};

package/lib/typescript/src/plugins/orderSpans.d.ts

@@ -0,0 +1,3 @@
+import type { SpanEvent } from '../types';
+/** Parent-first order in O(n), including parents delivered after their children. */
+export declare function orderSpans(spans: readonly SpanEvent[]): SpanEvent[];