@goliapkg/sentori-react-native 0.7.5 → 0.8.0

package/src/handlers/network.ts

@@ -4,9 +4,15 @@ import { addBreadcrumb } from '../breadcrumbs';
 import { getConfig } from '../config';
 
 let _installed = false;
+let _graphqlEnabled = true;
 
 const AUTH_PARAMS = ['token', 'key', 'password', 'secret', 'access_token'];
 
+// v0.9.0 #11 — cap on body size we'll parse for `operationName`.
+// 8 KB is generous for any sensible GraphQL request and keeps the
+// hot-path JSON.parse bounded.
+const GQL_BODY_MAX_BYTES = 8 * 1024;
+
 // Requests to our own ingest endpoint shouldn't be traced — otherwise
 // every span upload spawns another http.client span, and so on.
 const isIngestUrl = (url: string): boolean => {
@@ -14,13 +20,20 @@ const isIngestUrl = (url: string): boolean => {
   return !!base && url.startsWith(base);
 };
 
-export const installNetworkHandler = (): void => {
+export const installNetworkHandler = (opts?: { graphql?: boolean }): void => {
   if (_installed) return;
   _installed = true;
+  _graphqlEnabled = opts?.graphql !== false;
   patchFetch();
   patchXhr();
 };
 
+/** Test-only — reset module state between runs. */
+export const __resetNetworkHandlerForTests = (): void => {
+  _installed = false;
+  _graphqlEnabled = true;
+};
+
 // ── fetch ──────────────────────────────────────────────────────────
 
 function patchFetch(): void {
@@ -37,13 +50,32 @@ function patchFetch(): void {
         ? (input as Request).method
         : 'GET')) as string;
 
+    // v0.9.0 #11 — GraphQL operation auto-naming. Inspect the request
+    // body cheaply (string only, < 8 KB) when the request looks like
+    // GraphQL (URL contains /graphql or content-type hints it). On
+    // success we override the span name to `graphql/<operationName>`
+    // and ride along `gql.operation` on the breadcrumb so the dashboard
+    // can group + filter by operation instead of by the useless
+    // `POST /graphql` line.
+    const gqlOp = _graphqlEnabled
+      ? extractGraphqlOpFromInit(init, input, url)
+      : undefined;
+
     // Phase 35 sub-C: also open an http.client span so the request
     // shows up in the trace waterfall. Breadcrumbs stay — they're
     // attached to error events at capture time and serve a different
     // surface (the "last 100 things" timeline on the issue page).
     const span = startSpan('http.client', {
-      name: `${method.toUpperCase()} ${normalizeUrl(scrubbed)}`,
-      tags: { 'http.method': method.toUpperCase(), 'http.url': scrubbed },
+      name: gqlOp
+        ? `graphql/${gqlOp}`
+        : `${method.toUpperCase()} ${normalizeUrl(scrubbed)}`,
+      tags: gqlOp
+        ? {
+            'http.method': method.toUpperCase(),
+            'http.url': scrubbed,
+            'gql.operation': gqlOp,
+          }
+        : { 'http.method': method.toUpperCase(), 'http.url': scrubbed },
     });
 
     // Inject traceparent header on outbound requests.
@@ -58,12 +90,20 @@ function patchFetch(): void {
       span.finish({ status: resp.status >= 400 ? 'error' : 'ok' });
       addBreadcrumb({
         type: 'net',
-        data: {
-          method,
-          url: scrubbed,
-          status: resp.status,
-          durationMs: Date.now() - start,
-        },
+        data: gqlOp
+          ? {
+              method,
+              url: scrubbed,
+              status: resp.status,
+              durationMs: Date.now() - start,
+              'gql.operation': gqlOp,
+            }
+          : {
+              method,
+              url: scrubbed,
+              status: resp.status,
+              durationMs: Date.now() - start,
+            },
       });
       return resp;
     } catch (e) {
@@ -78,6 +118,7 @@ function patchFetch(): void {
           status: 0,
           durationMs: Date.now() - start,
           error: String(e),
+          ...(gqlOp ? { 'gql.operation': gqlOp } : {}),
         },
       });
       throw e;
@@ -98,6 +139,7 @@ type TracedXhr = XMLHttpRequest & {
   __sentoriUrl?: string;
   __sentoriSpan?: ReturnType<typeof startSpan>;
   __sentoriStart?: number;
+  __sentoriGqlOp?: string;
 };
 
 function patchXhr(): void {
@@ -129,9 +171,20 @@ function patchXhr(): void {
     if (isIngestUrl(this.__sentoriUrl ?? '')) return originalSend.call(this, body);
     const method = this.__sentoriMethod ?? 'GET';
     const url = scrubUrl(this.__sentoriUrl ?? '');
+    // v0.9.0 #11 — GraphQL operation auto-naming on XHR.
+    const gqlOp = _graphqlEnabled
+      ? extractGraphqlOpFromXhr(body, this.__sentoriUrl ?? '')
+      : undefined;
+    this.__sentoriGqlOp = gqlOp;
     const span = startSpan('http.client', {
-      name: `${method} ${normalizeUrl(url)}`,
-      tags: { 'http.method': method, 'http.url': url },
+      name: gqlOp ? `graphql/${gqlOp}` : `${method} ${normalizeUrl(url)}`,
+      tags: gqlOp
+        ? {
+            'http.method': method,
+            'http.url': url,
+            'gql.operation': gqlOp,
+          }
+        : { 'http.method': method, 'http.url': url },
     });
     this.__sentoriSpan = span;
     this.__sentoriStart = Date.now();
@@ -154,14 +207,23 @@ function patchXhr(): void {
       // status 0 means network error / aborted / CORS block — treat
       // as error. The `abort` event handler below downgrades aborts.
       s.finish({ status: status === 0 || status >= 400 ? 'error' : 'ok' });
+      const op = this.__sentoriGqlOp;
       addBreadcrumb({
         type: 'net',
-        data: {
-          method,
-          url,
-          status,
-          durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
-        },
+        data: op
+          ? {
+              method,
+              url,
+              status,
+              durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
+              'gql.operation': op,
+            }
+          : {
+              method,
+              url,
+              status,
+              durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
+            },
       });
     };
 
@@ -171,9 +233,17 @@ function patchXhr(): void {
       if (!s) return;
       this.__sentoriSpan = undefined;
       s.finish({ status: 'cancelled' });
+      const op = this.__sentoriGqlOp;
       addBreadcrumb({
         type: 'net',
-        data: { method, url, status: 0, durationMs: Date.now() - (this.__sentoriStart ?? Date.now()), error: 'aborted' },
+        data: {
+          method,
+          url,
+          status: 0,
+          durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
+          error: 'aborted',
+          ...(op ? { 'gql.operation': op } : {}),
+        },
       });
     });
 
@@ -224,3 +294,113 @@ const scrubUrl = (url: string): string => {
     return url;
   }
 };
+
+// ── v0.9.0 #11 — GraphQL operation extraction ─────────────────────
+//
+// Cheap, sync, never throws. Two callers (fetch + xhr) feed in
+// whatever they have on hand; both end up calling `parseGqlOpName`.
+
+function lookGraphqlish(url: string, contentType?: string): boolean {
+  if (contentType) {
+    if (contentType.includes('graphql')) return true;
+    // application/json is too generic to gate on alone, but combined
+    // with a `/graphql` path it's a strong hint.
+  }
+  if (url.includes('/graphql')) return true;
+  return false;
+}
+
+/** Pull `operationName` out of a JSON body or a raw query body. Returns
+ *  `undefined` on any failure mode. Cap at GQL_BODY_MAX_BYTES so a
+ *  hostile / oversize body never lands in `JSON.parse`. */
+export function parseGqlOpName(body: string): string | undefined {
+  if (typeof body !== 'string' || body.length === 0) return undefined;
+  if (body.length > GQL_BODY_MAX_BYTES) return undefined;
+  // First char `{` or `[` → JSON path. Most clients (Apollo, urql,
+  // Relay) send `{"query":"…","operationName":"…","variables":{…}}`
+  // or an array of such objects (batched).
+  const first = body.charCodeAt(0);
+  if (first === 0x7b /* { */ || first === 0x5b /* [ */) {
+    try {
+      const parsed = JSON.parse(body) as unknown;
+      const candidate = Array.isArray(parsed) ? parsed[0] : parsed;
+      if (candidate && typeof candidate === 'object') {
+        const name = (candidate as { operationName?: unknown }).operationName;
+        if (typeof name === 'string' && name.length > 0 && name.length <= 200) {
+          return name;
+        }
+        // No operationName — try to sniff the `query` string for
+        // `query Foo {…}` / `mutation Bar {…}` / `subscription Baz {…}`.
+        const q = (candidate as { query?: unknown }).query;
+        if (typeof q === 'string') return parseQueryStringOpName(q);
+      }
+    } catch {
+      return undefined;
+    }
+    return undefined;
+  }
+  // `application/graphql` body is the bare query string — no JSON wrapper.
+  return parseQueryStringOpName(body);
+}
+
+function parseQueryStringOpName(query: string): string | undefined {
+  // Skip leading whitespace + comments. We only need the first non-trivial
+  // top-level operation keyword to extract a name; nested operations are
+  // a non-issue because GraphQL forbids them.
+  const m = /^\s*(?:#[^\n]*\n\s*)*(query|mutation|subscription)\s+([A-Za-z_][A-Za-z0-9_]*)/.exec(
+    query,
+  );
+  return m?.[2];
+}
+
+function extractGraphqlOpFromInit(
+  init: RequestInit | undefined,
+  input: RequestInfo | URL,
+  url: string,
+): string | undefined {
+  const method = (init?.method ??
+    (typeof input !== 'string' && 'method' in (input as Request)
+      ? (input as Request).method
+      : 'GET')) as string;
+  if (method.toUpperCase() !== 'POST') return undefined;
+  const contentType = headerValue(init, input, 'content-type');
+  if (!lookGraphqlish(url, contentType)) return undefined;
+  const body = init?.body;
+  if (typeof body !== 'string') return undefined;
+  return parseGqlOpName(body);
+}
+
+function extractGraphqlOpFromXhr(
+  body: Document | XMLHttpRequestBodyInit | null | undefined,
+  url: string,
+): string | undefined {
+  if (typeof body !== 'string') return undefined;
+  if (!lookGraphqlish(url)) return undefined;
+  return parseGqlOpName(body);
+}
+
+function headerValue(
+  init: RequestInit | undefined,
+  input: RequestInfo | URL,
+  name: string,
+): string | undefined {
+  const target = name.toLowerCase();
+  if (init?.headers) {
+    try {
+      const h = new Headers(init.headers);
+      const v = h.get(target);
+      if (v) return v;
+    } catch {
+      // ignore — bad header shape, treat as absent
+    }
+  }
+  if (typeof input !== 'string' && !(input instanceof URL)) {
+    try {
+      const v = (input as Request).headers.get(target);
+      if (v) return v;
+    } catch {
+      // ignore
+    }
+  }
+  return undefined;
+}

package/src/index.ts

@@ -9,7 +9,17 @@ import {
   setUser,
 } from './capture';
 import { ErrorBoundary } from './error-boundary';
+import {
+  clearAllFeatureFlags,
+  clearFeatureFlag,
+  getFeatureFlags,
+  setFeatureFlag,
+} from './feature-flags';
 import { clearMaskQuery, registerMaskQuery } from './mask';
+import { measureFn } from './measure';
+import { startMoment } from '@goliapkg/sentori-core';
+import { flushMetrics, recordMetric } from './metrics';
+import { RageTapCapture } from './rage-tap';
 import {
   endSession,
   markSessionCrashed,
@@ -25,7 +35,16 @@ export const sentori = {
   captureException,
   captureStep,
   sendUserFeedback,
+  recordMetric,
+  flushMetrics,
+  measureFn,
+  startMoment,
+  setFeatureFlag,
+  clearFeatureFlag,
+  clearAllFeatureFlags,
+  getFeatureFlags,
   ErrorBoundary,
+  RageTapCapture,
   registerMaskQuery,
   clearMaskQuery,
   startSession,
@@ -46,7 +65,17 @@ export {
   setUser,
 } from './capture';
 export { ErrorBoundary } from './error-boundary';
+export {
+  clearAllFeatureFlags,
+  clearFeatureFlag,
+  getFeatureFlags,
+  setFeatureFlag,
+} from './feature-flags';
 export { clearMaskQuery, registerMaskQuery } from './mask';
+export { flushMetrics, recordMetric } from './metrics';
+export { measureFn } from './measure';
+export { MomentHandle, type MomentProperties, startMoment } from '@goliapkg/sentori-core';
+export { RageTapCapture } from './rage-tap';
 export {
   startAnrWatchdog,
   stopAnrWatchdog,

package/src/init.ts

@@ -3,6 +3,12 @@ import { installGlobalHandler } from './handlers/global';
 import { installLifecycleHandler } from './handlers/lifecycle';
 import { installPromiseHandler } from './handlers/promise';
 import { installNetworkHandler } from './handlers/network';
+import { getBundleInfo } from './bundle-info';
+import {
+  markLaunchCompleted,
+  runLaunchCrashGuard,
+} from './launch-crash-guard';
+import { startMetricsTimer } from './metrics';
 import { drainNativePending, setNativeConfig } from './native';
 import { startNetworkTypeWatch } from './netinfo';
 import { startSession } from './session-tracker';
@@ -29,7 +35,14 @@ export type InitOptions = {
   capture?: {
     globalErrors?: boolean;
     promiseRejections?: boolean;
-    network?: boolean;
+    network?:
+      | boolean
+      | {
+          /** v0.9.0 #11 — auto-extract GraphQL `operationName` from
+           *  POST request bodies and use it as the breadcrumb / span
+           *  name (instead of `POST /graphql`). Default `true`. */
+          graphql?: boolean;
+        };
     /** Session tracking: opens a session on init and on each
      *  foreground (`AppState` → `active`), ends it on background.
      *  Drives crash-free rate. Set `false` to opt out. */
@@ -48,6 +61,20 @@ export type InitOptions = {
      *  the buffer is sealed and uploaded as a `sessionTrail`
      *  attachment. Defaults to false. */
     sessionTrail?: boolean;
+    /** v0.9.0 #3 — launch-crash loop guard. When two consecutive
+     *  launches don't reach `markLaunchCompleted()` (typical of an
+     *  OTA update with a fatal bug), invoke the host callback with
+     *  a 200 ms timeout to decide rollback / reset / continue. */
+    launchCrashGuard?: {
+      enabled: boolean;
+      onLaunchCrashDetected?: (
+        info: import('./launch-crash-guard').LaunchCrashInfo,
+      ) =>
+        | import('./launch-crash-guard').LaunchCrashAction
+        | Promise<import('./launch-crash-guard').LaunchCrashAction>;
+      threshold?: number;
+      timeoutMs?: number;
+    };
   };
   /** Phase 44 sub-B: client-side sampling. Each rate is `[0, 1]`;
    *  absent / null keeps everything. Defaults to 1.0 for both
@@ -75,6 +102,19 @@ export const init = (options: InitOptions): void => {
     options.environment ??
     (typeof __DEV__ !== 'undefined' && __DEV__ ? 'dev' : 'prod');
 
+  // v0.9.0 #3 — launch-crash guard. Fires *before* any other setup so
+  // a known-bad bundle can roll back instead of running JS that's
+  // about to die again. AsyncStorage-backed; if the host doesn't have
+  // it the guard is a no-op.
+  const lcg = options.capture?.launchCrashGuard;
+  if (lcg?.enabled) {
+    void runLaunchCrashGuard(
+      lcg,
+      options.release,
+      getBundleInfo()?.id ?? null,
+    );
+  }
+
   setConfig({
     token: options.token,
     release: options.release,
@@ -100,11 +140,16 @@ export const init = (options: InitOptions): void => {
   // installed; events just won't carry `device.networkType` in that
   // case.
   startNetworkTypeWatch();
+  // v0.8.3 — drain custom-metric ring every 30 s.
+  startMetricsTimer();
 
   const capture = options.capture ?? {};
   if (capture.globalErrors !== false) installGlobalHandler();
   if (capture.promiseRejections !== false) installPromiseHandler();
-  if (capture.network !== false) installNetworkHandler();
+  if (capture.network !== false) {
+    const netOpts = typeof capture.network === 'object' ? capture.network : undefined;
+    installNetworkHandler({ graphql: netOpts?.graphql });
+  }
   if (capture.sessions !== false) {
     // Open the cold-start session now (RN doesn't fire an AppState
     // `change` for the initial `active` state), then bind AppState so
@@ -151,6 +196,16 @@ export const init = (options: InitOptions): void => {
     })
     .catch(() => {});
   drainOfflineQueue().catch(() => {});
+
+  // v0.9.0 #3 — init reached the end without throwing. Schedule the
+  // "launch completed" marker after one tick so any synchronous user
+  // code right after `init()` gets to run first; we want the marker to
+  // confirm the JS bridge stayed alive, not just that `init()` returned.
+  if (lcg?.enabled) {
+    setTimeout(() => {
+      void markLaunchCompleted(getBundleInfo()?.id ?? null);
+    }, 2_000);
+  }
 };
 
 /**

package/src/launch-crash-guard.ts

@@ -0,0 +1,221 @@
+// v0.9.0 #3 — launch-crash loop guard.
+//
+// On every init we write a "launch_marker" to AsyncStorage. On
+// `markLaunchCompleted()` we write a sibling "launch_completed". On
+// startup we look at the previous launch state: marker present but
+// completed missing → previous launch did not finish → increment a
+// consecutive-crash counter.
+//
+// When the counter crosses `threshold` (default 2), we invoke the
+// host-supplied `onLaunchCrashDetected` callback with a 200 ms timeout
+// (D3) and follow its action: rollback the OTA bundle, reset a list
+// of AsyncStorage keys, or continue. Rollback / reset trigger an
+// `expo-updates` reload when available.
+//
+// v0.9.0 scope: JS-only — catches everything that runs after the JS
+// bridge is up (almost every OTA-induced launch crash). v0.9.1 will
+// add a native marker for the small set of "crashed before bridge"
+// cases.
+
+const MARKER_KEY = '@sentori/launch_marker';
+const COMPLETED_KEY = '@sentori/launch_completed';
+const COUNT_KEY = '@sentori/launch_crash_count';
+
+export type LaunchCrashInfo = {
+  /** Consecutive failed launches detected so far (this one inclusive). */
+  consecutiveCount: number;
+  /** OTA bundle id of the crashing launch, if known. */
+  crashedBundle: null | string;
+  /** Most recent bundle id that *did* reach `markLaunchCompleted`. */
+  lastSafeBundle: null | string;
+  /** Store-binary release of the crashing launch. */
+  release: string;
+};
+
+export type LaunchCrashAction =
+  | { action: 'continue' }
+  | { action: 'reset'; clearKeys: string[] }
+  | { action: 'rollback'; toBundle?: null | string };
+
+export type LaunchCrashGuardOptions = {
+  enabled: boolean;
+  onLaunchCrashDetected?: (info: LaunchCrashInfo) => LaunchCrashAction | Promise<LaunchCrashAction>;
+  /** Default 2 — fires after the second consecutive failed launch. */
+  threshold?: number;
+  /** Default 200 — D3 decision. */
+  timeoutMs?: number;
+};
+
+type AsyncStorageLike = {
+  getItem: (key: string) => Promise<null | string>;
+  multiRemove?: (keys: string[]) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+  setItem: (key: string, value: string) => Promise<void>;
+};
+
+function loadAsyncStorage(): AsyncStorageLike | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require('@react-native-async-storage/async-storage') as {
+      default?: AsyncStorageLike;
+    };
+    return mod.default ?? (mod as unknown as AsyncStorageLike);
+  } catch {
+    return null;
+  }
+}
+
+/** Returns `false` iff we triggered a bundle rollback / reset and
+ *  expect the app to reload momentarily; the caller (init) should
+ *  short-circuit further setup. */
+export async function runLaunchCrashGuard(
+  opts: LaunchCrashGuardOptions,
+  release: string,
+  currentBundleId: null | string,
+): Promise<{ shouldContinueInit: boolean; info?: LaunchCrashInfo }> {
+  if (!opts.enabled) return { shouldContinueInit: true };
+  const storage = loadAsyncStorage();
+  if (!storage) return { shouldContinueInit: true };
+
+  try {
+    const marker = await storage.getItem(MARKER_KEY);
+    const completed = await storage.getItem(COMPLETED_KEY);
+
+    if (marker && !completed) {
+      const m = safeJsonParse<{ bundleId?: string; lastSafeBundle?: string }>(marker) ?? {};
+      const prevCount = parseInt((await storage.getItem(COUNT_KEY)) ?? '0', 10) || 0;
+      const consecutiveCount = prevCount + 1;
+      await storage.setItem(COUNT_KEY, String(consecutiveCount));
+
+      if (consecutiveCount >= (opts.threshold ?? 2) && opts.onLaunchCrashDetected) {
+        const info: LaunchCrashInfo = {
+          consecutiveCount,
+          crashedBundle: m.bundleId ?? null,
+          lastSafeBundle: m.lastSafeBundle ?? null,
+          release,
+        };
+        const action = await raceWithTimeout<LaunchCrashAction>(
+          Promise.resolve(opts.onLaunchCrashDetected(info)),
+          opts.timeoutMs ?? 200,
+          { action: 'continue' },
+        );
+        const handled = await applyAction(action, storage);
+        if (!handled.shouldContinueInit) {
+          return { ...handled, info };
+        }
+        return { ...handled, info };
+      }
+    } else {
+      // Previous launch completed; clean the counter.
+      await storage.setItem(COUNT_KEY, '0');
+    }
+
+    // Write the marker for THIS launch. lastSafeBundle = previous
+    // completed bundle id, so the user's callback can target it.
+    const lastSafeBundle =
+      (completed && safeJsonParse<{ bundleId?: string }>(completed)?.bundleId) ?? null;
+    await storage.setItem(
+      MARKER_KEY,
+      JSON.stringify({
+        bundleId: currentBundleId,
+        lastSafeBundle,
+        release,
+        ts: Date.now(),
+      }),
+    );
+    await storage.removeItem(COMPLETED_KEY);
+  } catch {
+    // AsyncStorage glitches must never block init.
+  }
+
+  return { shouldContinueInit: true };
+}
+
+export async function markLaunchCompleted(currentBundleId: null | string): Promise<void> {
+  const storage = loadAsyncStorage();
+  if (!storage) return;
+  try {
+    await storage.setItem(
+      COMPLETED_KEY,
+      JSON.stringify({ bundleId: currentBundleId, ts: Date.now() }),
+    );
+    await storage.setItem(COUNT_KEY, '0');
+  } catch {
+    // ignore
+  }
+}
+
+async function applyAction(
+  action: LaunchCrashAction,
+  storage: AsyncStorageLike,
+): Promise<{ shouldContinueInit: boolean }> {
+  if (action.action === 'continue') return { shouldContinueInit: true };
+  if (action.action === 'reset') {
+    if (storage.multiRemove && Array.isArray(action.clearKeys)) {
+      try {
+        await storage.multiRemove(action.clearKeys);
+      } catch {
+        // ignore
+      }
+    }
+    await reloadOTAIfPossible();
+    return { shouldContinueInit: false };
+  }
+  if (action.action === 'rollback') {
+    await reloadOTAIfPossible();
+    return { shouldContinueInit: false };
+  }
+  return { shouldContinueInit: true };
+}
+
+async function reloadOTAIfPossible(): Promise<void> {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Updates = require('expo-updates') as {
+      reloadAsync?: () => Promise<void>;
+    };
+    if (typeof Updates.reloadAsync === 'function') {
+      await Updates.reloadAsync();
+    }
+  } catch {
+    // expo-updates not installed — caller will fall through and
+    // continue init; their callback returned `rollback` but we can't
+    // perform it without the OTA library. Document accordingly.
+  }
+}
+
+export function raceWithTimeout<T>(p: Promise<T>, ms: number, fallback: T): Promise<T> {
+  return new Promise<T>((resolve) => {
+    let done = false;
+    const t = setTimeout(() => {
+      if (!done) {
+        done = true;
+        resolve(fallback);
+      }
+    }, ms);
+    p.then(
+      (v) => {
+        if (!done) {
+          done = true;
+          clearTimeout(t);
+          resolve(v);
+        }
+      },
+      () => {
+        if (!done) {
+          done = true;
+          clearTimeout(t);
+          resolve(fallback);
+        }
+      },
+    );
+  });
+}
+
+function safeJsonParse<T>(s: string): null | T {
+  try {
+    return JSON.parse(s) as T;
+  } catch {
+    return null;
+  }
+}