diff --git a/apps/native-component-list/src/screens/AppMetricsScreen.tsx b/apps/native-component-list/src/screens/AppMetricsScreen.tsx
index 7cd94905dc28d6..b39061ad171998 100644
--- a/apps/native-component-list/src/screens/AppMetricsScreen.tsx
+++ b/apps/native-component-list/src/screens/AppMetricsScreen.tsx
@@ -1,19 +1,19 @@
 import { useFocusEffect } from '@react-navigation/native';
 import { useTheme } from 'ThemeProvider';
-import AppMetrics, { type MainSession, type Metric } from 'expo-app-metrics';
+import AppMetrics, { type Metric } from 'expo-app-metrics';
 import * as React from 'react';
 import { RefreshControl, ScrollView, StyleSheet, Text, View } from 'react-native';
 
 export default function AppMetricsScreen() {
   const { theme } = useTheme();
-  const [session, setSession] = React.useState<MainSession | null>(null);
+  const [metrics, setMetrics] = React.useState<Metric[]>([]);
   const [refreshing, setRefreshing] = React.useState(false);
 
   useFocusEffect(
     React.useCallback(() => {
       let cancelled = false;
       AppMetrics.getMainSession().then((s) => {
-        if (!cancelled) setSession(s);
+        if (!cancelled) setMetrics(s?.metrics ?? []);
       });
       return () => {
         cancelled = true;
@@ -24,13 +24,13 @@ export default function AppMetricsScreen() {
   const onRefresh = React.useCallback(async () => {
     setRefreshing(true);
     try {
-      setSession(await AppMetrics.getMainSession());
+      setMetrics((await AppMetrics.getMainSession())?.metrics ?? []);
     } finally {
       setRefreshing(false);
     }
   }, []);
 
-  const navMetrics: Metric[] = (session?.metrics ?? []).filter((m) => m.category === 'navigation');
+  const navMetrics: Metric[] = metrics.filter((m) => m.category === 'navigation');
 
   return (
     <ScrollView
diff --git a/apps/observe-tester/app/(tabs)/(metrics)/index.tsx b/apps/observe-tester/app/(tabs)/(metrics)/index.tsx
index 7837b6ab0581d2..0f611f6c9f43b5 100644
--- a/apps/observe-tester/app/(tabs)/(metrics)/index.tsx
+++ b/apps/observe-tester/app/(tabs)/(metrics)/index.tsx
@@ -14,6 +14,13 @@ export default function Index() {
   const { markInteractive } = useObserve();
 
   async function handleMarkInteractive() {
+    // Fire a network request first so it lands inside the launch→TTI window and shows up in the
+    // TTI metric's expo.network.requests.* params. Failures are swallowed — this is exercise code.
+    try {
+      await fetch('https://expo.dev');
+    } catch {
+      // ignore
+    }
     await markInteractive();
   }
 
diff --git a/apps/observe-tester/app/(tabs)/(sessions)/_layout.tsx b/apps/observe-tester/app/(tabs)/(sessions)/_layout.tsx
index feba87885a0a5b..73de611c9bb335 100644
--- a/apps/observe-tester/app/(tabs)/(sessions)/_layout.tsx
+++ b/apps/observe-tester/app/(tabs)/(sessions)/_layout.tsx
@@ -11,6 +11,7 @@ export default function SessionsLayout() {
         headerTintColor: theme.text.default,
       }}>
       <Stack.Screen name="sessions/index" options={{ title: 'Sessions' }} />
+      <Stack.Screen name="sessions/main" options={{ title: 'Main session' }} />
       <Stack.Screen name="sessions/[id]" options={{ title: 'Session' }} />
     </Stack>
   );
diff --git a/apps/observe-tester/app/(tabs)/(sessions)/sessions/[id].tsx b/apps/observe-tester/app/(tabs)/(sessions)/sessions/[id].tsx
index a9abe9a66097b3..1c2d658121b5e7 100644
--- a/apps/observe-tester/app/(tabs)/(sessions)/sessions/[id].tsx
+++ b/apps/observe-tester/app/(tabs)/(sessions)/sessions/[id].tsx
@@ -1,157 +1,27 @@
 import AppMetrics, { type Session } from 'expo-app-metrics';
-import { useObserve } from 'expo-observe';
-import { Stack, useFocusEffect, useLocalSearchParams } from 'expo-router';
-import { useCallback, useEffect, useState } from 'react';
-import { Platform, Pressable, ScrollView, StyleSheet, Text } from 'react-native';
+import { useFocusEffect, useLocalSearchParams } from 'expo-router';
+import { useCallback, useState } from 'react';
 
-import { CallStackTreeView } from '@/components/CallStackTreeView';
-import { Chevron } from '@/components/Chevron';
-import { CrashReportPanel } from '@/components/CrashReportPanel';
-import { Divider } from '@/components/Divider';
-import { JSONView } from '@/components/JSONView';
-import { LogsPanel } from '@/components/LogsPanel';
-import { MetricsFilter } from '@/components/MetricsFilter';
-import { MetricsPanel } from '@/components/MetricsPanel';
-import { SessionHeader } from '@/components/SessionHeader';
-import { useTheme } from '@/utils/theme';
+import { SessionDetail } from '@/components/SessionDetail';
 
-export default function SessionDetail() {
+export default function InactiveSessionScreen() {
   const { id } = useLocalSearchParams<{ id: string }>();
-  const theme = useTheme();
   const [session, setSession] = useState<Session | null>(null);
   const [loaded, setLoaded] = useState(false);
-  const [showRawJson, setShowRawJson] = useState(false);
-  const [selectedMetricNames, setSelectedMetricNames] = useState<Set<string>>(() => new Set());
-
-  // Seed the selection to every distinct metric name once per session id. Keyed on `session?.id`
-  // so refocusing the tab (which reloads sessions and creates a new metrics array reference)
-  // doesn't wipe the user's filter.
-  useEffect(() => {
-    if (!session) return;
-    const names = new Set<string>();
-    for (const metric of session.metrics) names.add(metric.name);
-    setSelectedMetricNames(names);
-  }, [session?.id]);
-
-  const { markInteractive } = useObserve();
-  useEffect(() => {
-    setTimeout(() => {
-      markInteractive();
-    }, 100);
-  }, []);
 
   useFocusEffect(
     useCallback(() => {
-      AppMetrics.getAllSessions().then((sessions) => {
+      let cancelled = false;
+      AppMetrics.getInactiveSessions().then((sessions) => {
+        if (cancelled) return;
         setSession(sessions.find((s) => s.id === id) ?? null);
         setLoaded(true);
       });
+      return () => {
+        cancelled = true;
+      };
     }, [id])
   );
 
-  return (
-    <ScrollView
-      style={[styles.container, { backgroundColor: theme.background.screen }]}
-      contentContainerStyle={styles.contentContainer}>
-      <Stack.Screen options={{ title: id?.slice(0, 8) ?? 'Session' }} />
-      {!loaded ? null : session ? (
-        <>
-          <SessionHeader session={session} />
-          <Divider style={styles.divider} />
-          {session.type === 'main' && session.crashReport ? (
-            <>
-              <Text style={[styles.sectionTitle, { color: theme.text.default }]}>Crash report</Text>
-              <CrashReportPanel report={session.crashReport} />
-              {session.crashReport.callStackTree ? (
-                <>
-                  <Divider style={styles.divider} />
-                  <Text style={[styles.sectionTitle, { color: theme.text.default }]}>
-                    Call stacks
-                  </Text>
-                  <CallStackTreeView tree={session.crashReport.callStackTree} />
-                </>
-              ) : null}
-              <Divider style={styles.divider} />
-            </>
-          ) : null}
-          <Text style={[styles.sectionTitle, { color: theme.text.default }]}>Metrics</Text>
-          <MetricsFilter
-            metrics={session.metrics}
-            selected={selectedMetricNames}
-            onChange={setSelectedMetricNames}
-          />
-          <MetricsPanel metrics={session.metrics} filter={selectedMetricNames} />
-          <Divider style={styles.divider} />
-          <Text style={[styles.sectionTitle, { color: theme.text.default }]}>Log events</Text>
-          <LogsPanel logs={session.logs} />
-          <Divider style={styles.divider} />
-          <Pressable
-            onPress={() => setShowRawJson((v) => !v)}
-            style={({ pressed }) => [
-              styles.rawJsonHeader,
-              showRawJson && styles.rawJsonHeaderExpanded,
-              pressed && { opacity: 0.6 },
-            ]}>
-            <Text style={[styles.sectionTitle, styles.rawJsonTitle, { color: theme.text.default }]}>
-              Raw JSON
-            </Text>
-            <Chevron expanded={showRawJson} />
-          </Pressable>
-          {showRawJson ? <JSONView value={stripCallStackTree(session)} /> : null}
-        </>
-      ) : (
-        <Text style={[styles.notFound, { color: theme.text.default }]}>Session not found</Text>
-      )}
-    </ScrollView>
-  );
-}
-
-// The call stack tree balloons the raw JSON to the point where it can fail to render. It's
-// already shown visually in the "Call stacks" section above, so we omit it from the raw JSON
-// and replace it with a marker noting that.
-function stripCallStackTree(session: Session): Session {
-  if (session.type !== 'main' || !session.crashReport?.callStackTree) {
-    return session;
-  }
-  return {
-    ...session,
-    crashReport: {
-      ...session.crashReport,
-      callStackTree: '<omitted, see Call stacks section>' as never,
-    },
-  };
+  return <SessionDetail session={session} loaded={loaded} title={id?.slice(0, 8) ?? 'Session'} />;
 }
-
-const styles = StyleSheet.create({
-  container: {
-    padding: 20,
-  },
-  contentContainer: {
-    paddingBottom: Platform.select({ ios: 30, android: 150 }),
-  },
-  notFound: {
-    fontSize: 16,
-    fontWeight: 'bold',
-    textAlign: 'center',
-  },
-  sectionTitle: {
-    fontSize: 18,
-    fontWeight: '700',
-    marginBottom: 12,
-  },
-  divider: {
-    marginVertical: 16,
-  },
-  rawJsonHeader: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'space-between',
-    gap: 12,
-  },
-  rawJsonTitle: {
-    marginBottom: 0,
-  },
-  rawJsonHeaderExpanded: {
-    marginBottom: 12,
-  },
-});
diff --git a/apps/observe-tester/app/(tabs)/(sessions)/sessions/index.tsx b/apps/observe-tester/app/(tabs)/(sessions)/sessions/index.tsx
index 9465c70e224d33..39578cbdfe4e24 100644
--- a/apps/observe-tester/app/(tabs)/(sessions)/sessions/index.tsx
+++ b/apps/observe-tester/app/(tabs)/(sessions)/sessions/index.tsx
@@ -1,6 +1,6 @@
-import AppMetrics, { type Session } from 'expo-app-metrics';
+import AppMetrics, { type Session, type SessionType } from 'expo-app-metrics';
 import { useObserve } from 'expo-observe';
-import { router, Stack, useFocusEffect } from 'expo-router';
+import { type Href, router, Stack, useFocusEffect } from 'expo-router';
 import { useCallback, useEffect, useState } from 'react';
 import {
   ActivityIndicator,
@@ -15,14 +15,28 @@ import {
 
 import { useTheme } from '@/utils/theme';
 
+// A row's worth of session data, normalized from a `Session` record — the live
+// main session or an inactive one.
+type SessionRowData = {
+  id: string;
+  type: SessionType;
+  startDate: string;
+  endDate: string | null;
+  isActive: boolean;
+  metricCount: number;
+  crashed: boolean;
+  // Detail route: the live sessions have dedicated `main` screens;
+  // inactive ones are looked up by id via the `[id]` screen.
+  href: Href;
+};
+
+type Section = { title: string; data: SessionRowData[] };
+
 export default function SessionsList() {
   const theme = useTheme();
-  const [sessions, setSessions] = useState<Session[]>([]);
+  const [sections, setSections] = useState<Section[]>([]);
   const [loaded, setLoaded] = useState(false);
   const [refreshing, setRefreshing] = useState(false);
-  const currentMainStart = sessions.find((s) => s.type === 'main')?.startDate;
-  const isActive = (s: Session) =>
-    !s.endDate && currentMainStart != null && s.startDate >= currentMainStart;
 
   const { markInteractive } = useObserve();
   useEffect(() => {
@@ -32,9 +46,34 @@ export default function SessionsList() {
   }, []);
 
   const refresh = useCallback(async () => {
-    const result = await AppMetrics.getAllSessions();
-    const sorted = [...result].sort((a, b) => (a.startDate < b.startDate ? 1 : -1));
-    setSessions(sorted);
+    const mainSession = await AppMetrics.getMainSession();
+    const active: SessionRowData[] = mainSession
+      ? [
+          {
+            id: mainSession.id,
+            type: mainSession.type,
+            startDate: mainSession.startDate,
+            endDate: null,
+            isActive: true,
+            metricCount: mainSession?.metrics?.length ?? 0,
+            // A live session is always active, so it never has a crash report.
+            crashed: false,
+            // `main` is the live sessions' dedicated detail routes.
+            href: `/sessions/${mainSession.type}`,
+          },
+        ]
+      : [];
+
+    // Inactive sessions come back as plain eager records.
+    const records = await AppMetrics.getInactiveSessions();
+    const inactive: SessionRowData[] = records
+      .map(inactiveSessionToRow)
+      .sort((a, b) => (a.startDate < b.startDate ? 1 : -1));
+
+    setSections([
+      ...(active.length ? [{ title: 'Active', data: active }] : []),
+      ...(inactive.length ? [{ title: 'Inactive', data: inactive }] : []),
+    ]);
     setLoaded(true);
   }, []);
 
@@ -53,7 +92,7 @@ export default function SessionsList() {
     }, [refresh])
   );
 
-  if (typeof AppMetrics.getAllSessions !== 'function') {
+  if (typeof AppMetrics.getInactiveSessions !== 'function') {
     return (
       <View style={[styles.container, styles.center, { backgroundColor: theme.background.screen }]}>
         <Text style={[styles.emptyText, { color: theme.text.default }]}>
@@ -63,9 +102,8 @@ export default function SessionsList() {
     );
   }
 
-  const sections = groupByDay(sessions);
-
-  const title = sessions.length > 0 ? `Sessions (${sessions.length})` : 'Sessions';
+  const total = sections.reduce((sum, section) => sum + section.data.length, 0);
+  const title = total > 0 ? `Sessions (${total})` : 'Sessions';
 
   return (
     <>
@@ -110,46 +148,28 @@ export default function SessionsList() {
             {section.title}
           </Text>
         )}
-        renderItem={({ item }) => <SessionRow session={item} isActive={isActive(item)} />}
+        renderItem={({ item }) => <SessionRow session={item} />}
       />
     </>
   );
 }
 
-function groupByDay(sessions: Session[]): { title: string; data: Session[] }[] {
-  const today = new Date();
-  today.setHours(0, 0, 0, 0);
-  const yesterday = new Date(today);
-  yesterday.setDate(today.getDate() - 1);
-
-  const sectionsByKey = new Map<string, { title: string; data: Session[] }>();
-  for (const session of sessions) {
-    const date = new Date(session.startDate);
-    const day = new Date(date);
-    day.setHours(0, 0, 0, 0);
-
-    let title: string;
-    if (day.getTime() === today.getTime()) {
-      title = 'Today';
-    } else if (day.getTime() === yesterday.getTime()) {
-      title = 'Yesterday';
-    } else {
-      title = sectionDateFormatter.format(date);
-    }
-
-    const key = day.toISOString();
-    const existing = sectionsByKey.get(key);
-    if (existing) {
-      existing.data.push(session);
-    } else {
-      sectionsByKey.set(key, { title, data: [session] });
-    }
-  }
-  return Array.from(sectionsByKey.values());
+function inactiveSessionToRow(session: Session): SessionRowData {
+  return {
+    id: session.id,
+    type: session.type,
+    startDate: session.startDate,
+    endDate: session.endDate ?? null,
+    isActive: false,
+    metricCount: session.metrics.length,
+    crashed: 'crashReport' in session ? !!session.crashReport : false,
+    href: `/sessions/${session.id}`,
+  };
 }
 
-function SessionRow({ session, isActive }: { session: Session; isActive: boolean }) {
+function SessionRow({ session }: { session: SessionRowData }) {
   const theme = useTheme();
+  const { metricCount, isActive } = session;
   const startDate = new Date(session.startDate);
   const endDate = session.endDate ? new Date(session.endDate) : null;
   const duration = endDate ? formatDuration(endDate.getTime() - startDate.getTime()) : null;
@@ -157,7 +177,7 @@ function SessionRow({ session, isActive }: { session: Session; isActive: boolean
 
   return (
     <Pressable
-      onPress={() => router.push(`/sessions/${session.id}`)}
+      onPress={() => router.push(session.href)}
       style={({ pressed }) => [
         styles.row,
         {
@@ -178,7 +198,7 @@ function SessionRow({ session, isActive }: { session: Session; isActive: boolean
           {formatDate(startDate)}
         </Text>
         <View style={styles.badges}>
-          {session.type === 'main' && session.crashReport ? (
+          {session.crashed ? (
             <View style={[styles.badge, { backgroundColor: theme.background.danger }]}>
               <Text style={[styles.badgeText, { color: theme.text.danger }]}>Crashed</Text>
             </View>
@@ -195,8 +215,8 @@ function SessionRow({ session, isActive }: { session: Session; isActive: boolean
         numberOfLines={1}
         ellipsizeMode="tail">
         {shortId}
-        {duration ? ` · ${duration}` : isActive ? ' · active' : ''} · {session.metrics.length}{' '}
-        metric{session.metrics.length === 1 ? '' : 's'}
+        {duration ? ` · ${duration}` : isActive ? ' · active' : ''} · {metricCount} metric
+        {metricCount === 1 ? '' : 's'}
       </Text>
     </Pressable>
   );
@@ -211,13 +231,6 @@ const dateFormatter = new Intl.DateTimeFormat('en-GB', {
   second: '2-digit',
 });
 
-const sectionDateFormatter = new Intl.DateTimeFormat('en-GB', {
-  weekday: 'short',
-  day: '2-digit',
-  month: 'short',
-  year: 'numeric',
-});
-
 function formatDate(date: Date) {
   return dateFormatter.format(date);
 }
diff --git a/apps/observe-tester/app/(tabs)/(sessions)/sessions/main.tsx b/apps/observe-tester/app/(tabs)/(sessions)/sessions/main.tsx
new file mode 100644
index 00000000000000..7b05be5c63c696
--- /dev/null
+++ b/apps/observe-tester/app/(tabs)/(sessions)/sessions/main.tsx
@@ -0,0 +1,26 @@
+import AppMetrics, { type Session } from 'expo-app-metrics';
+import { useFocusEffect } from 'expo-router';
+import { useCallback, useState } from 'react';
+
+import { SessionDetail, liveSessionToRecord } from '@/components/SessionDetail';
+
+export default function MainSessionScreen() {
+  const [session, setSession] = useState<Session | null>(null);
+  const [loaded, setLoaded] = useState(false);
+
+  useFocusEffect(
+    useCallback(() => {
+      let cancelled = false;
+      AppMetrics.getMainSession().then((mainSession) => {
+        if (cancelled) return;
+        setSession(mainSession ? liveSessionToRecord(mainSession) : null);
+        setLoaded(true);
+      });
+      return () => {
+        cancelled = true;
+      };
+    }, [])
+  );
+
+  return <SessionDetail session={session} loaded={loaded} title="Main session" />;
+}
diff --git a/apps/observe-tester/app/(tabs)/debug/index.tsx b/apps/observe-tester/app/(tabs)/debug/index.tsx
index bfa4946b55de1e..7225821f7fd1da 100644
--- a/apps/observe-tester/app/(tabs)/debug/index.tsx
+++ b/apps/observe-tester/app/(tabs)/debug/index.tsx
@@ -9,6 +9,7 @@ import { Divider } from '@/components/Divider';
 import { GlobalAttributesSection } from '@/components/GlobalAttributesSection';
 import { JSAnimation } from '@/components/JSAnimation';
 import { LogEventsSection } from '@/components/LogEventsSection';
+import { NetworkRequestObserverSection } from '@/components/NetworkRequestObserverSection';
 import { useTheme } from '@/utils/theme';
 
 export default function Debug() {
@@ -29,6 +30,8 @@ export default function Debug() {
       contentContainerStyle={styles.container}>
       <LogEventsSection />
       <Divider />
+      <NetworkRequestObserverSection />
+      <Divider />
       <CrashReportsSection />
       {typeof AppMetrics.triggerCrash === 'function' ? <Divider /> : null}
       <GlobalAttributesSection />
@@ -41,7 +44,15 @@ export default function Debug() {
       {showAnimation && <JSAnimation />}
       <Button
         title="Log main session to console"
-        onPress={() => AppMetrics.getMainSession().then(JSON.stringify).then(console.log)}
+        onPress={async () => {
+          const session = await AppMetrics.getMainSession();
+
+          if (session) {
+            console.log(JSON.stringify(session, null, 2));
+          } else {
+            console.error('Main session is null');
+          }
+        }}
         theme="secondary"
       />
     </ScrollView>
diff --git a/apps/observe-tester/components/NetworkRequestObserverSection.tsx b/apps/observe-tester/components/NetworkRequestObserverSection.tsx
new file mode 100644
index 00000000000000..c369b80da3ed31
--- /dev/null
+++ b/apps/observe-tester/components/NetworkRequestObserverSection.tsx
@@ -0,0 +1,354 @@
+import { useNetworkRequestObserver, type NetworkRequestRedirect } from 'expo-app-metrics';
+import { useRef, useState } from 'react';
+import { Pressable, StyleSheet, Text, View } from 'react-native';
+
+import { useTheme } from '@/utils/theme';
+
+const RECENT_LIMIT = 30;
+
+type StartedRow = {
+  kind: 'started';
+  id: string;
+  url: string;
+  method: string;
+  startedAt: number;
+};
+
+type CompletedRow = {
+  kind: 'completed';
+  id: string;
+  url: string;
+  method: string;
+  statusCode: number | null;
+  totalDuration: number;
+  requestBytesSent: number | null;
+  responseBytesReceived: number | null;
+  errorDescription: string | null;
+  redirects: NetworkRequestRedirect[];
+  networkProtocol: string | null;
+};
+
+type Row = StartedRow | CompletedRow;
+
+export function NetworkRequestObserverSection() {
+  const theme = useTheme();
+  const [rows, setRows] = useState<Row[]>([]);
+  // Tracks which started ids have already been collapsed into a completed row,
+  // so we don't render duplicates when both events arrive.
+  const completedIds = useRef<Set<string>>(new Set());
+
+  useNetworkRequestObserver({
+    onStarted(event) {
+      setRows((prev) => {
+        const next: StartedRow = {
+          kind: 'started',
+          id: event.id,
+          url: event.url,
+          method: event.method,
+          startedAt: Date.parse(event.startedAt),
+        };
+        return [next, ...prev].slice(0, RECENT_LIMIT);
+      });
+    },
+    onCompleted(event) {
+      completedIds.current.add(event.id);
+      setRows((prev) => {
+        const completed: CompletedRow = {
+          kind: 'completed',
+          id: event.id,
+          url: event.url,
+          method: event.method,
+          statusCode: event.statusCode,
+          totalDuration: event.totalDuration,
+          requestBytesSent: event.requestBytesSent,
+          responseBytesReceived: event.responseBytesReceived,
+          errorDescription: event.errorDescription,
+          redirects: event.redirects,
+          networkProtocol: event.networkProtocol,
+        };
+        // Replace the matching started row if it's still on screen, else prepend.
+        const existing = prev.findIndex((r) => r.id === event.id);
+        if (existing >= 0) {
+          const out = prev.slice();
+          out[existing] = completed;
+          return out;
+        }
+        return [completed, ...prev].slice(0, RECENT_LIMIT);
+      });
+    },
+  });
+
+  function fireSample() {
+    fetch('https://expo.dev').catch(() => {});
+  }
+
+  function fireRandomImage() {
+    // `picsum.photos/seed/<seed>/<width>/<height>` returns a random image deterministically
+    // keyed by the seed, with payloads ranging from tens of KB to a few MB depending on size.
+    const seed = Math.floor(Math.random() * 1_000_000);
+    const size = 200 + Math.floor(Math.random() * 800);
+    fetch(`https://picsum.photos/seed/${seed}/${size}/${size}`).catch(() => {});
+  }
+
+  function fireFailing() {
+    fetch('https://expo.dev/this-route-does-not-exist-' + Date.now()).catch(() => {});
+  }
+
+  function firePost() {
+    fetch('https://httpbin.org/post', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ hello: 'from observe-tester', at: new Date().toISOString() }),
+    }).catch(() => {});
+  }
+
+  function fireSlow() {
+    fetch('https://httpbin.org/delay/3').catch(() => {});
+  }
+
+  function fireMultiRedirect() {
+    fetch('https://httpbin.org/redirect/3').catch(() => {});
+  }
+
+  return (
+    <>
+      <Text style={[styles.sectionTitle, { color: theme.text.default }]}>Network requests</Text>
+      <Text style={[styles.sectionHint, { color: theme.text.secondary }]}>
+        Subscribes a `NetworkRequestObserver` and streams every HTTP request through the panel. Each
+        row shows the started state first, then collapses into the completed snapshot when the
+        request finishes.
+      </Text>
+      <View style={styles.buttonRow}>
+        <CompactButton title="GET expo.dev" onPress={fireSample} />
+        <CompactButton title="Random image" onPress={fireRandomImage} />
+        <CompactButton title="POST JSON" onPress={firePost} />
+        <CompactButton title="Slow (3s)" onPress={fireSlow} />
+        <CompactButton title="Multi-redirect" onPress={fireMultiRedirect} />
+        <CompactButton title="Failing request" onPress={fireFailing} />
+        <CompactButton title="Clear" onPress={() => setRows([])} />
+      </View>
+      {rows.length === 0 ? (
+        <Text style={[styles.empty, { color: theme.text.secondary }]}>
+          No requests observed yet. Press a button above, or trigger any other fetch in the app.
+        </Text>
+      ) : (
+        rows.map((row) => <RequestRow key={row.id} row={row} />)
+      )}
+    </>
+  );
+}
+
+function RequestRow({ row }: { row: Row }) {
+  const theme = useTheme();
+  const isCompleted = row.kind === 'completed';
+  const status = isCompleted ? row.statusCode : null;
+  const isError =
+    isCompleted &&
+    (row.errorDescription != null || (status != null && (status < 200 || status >= 300)));
+  const leftBorderColor = isError
+    ? theme.icon.danger
+    : isCompleted
+      ? theme.icon.success
+      : theme.border.default;
+  const statusColor = statusCodeColor(
+    theme,
+    isCompleted,
+    status,
+    row.kind === 'completed' ? row.errorDescription : null
+  );
+
+  return (
+    <View
+      style={[
+        styles.row,
+        {
+          backgroundColor: theme.background.element,
+          borderColor: theme.border.default,
+          borderLeftWidth: 3,
+          borderLeftColor: leftBorderColor,
+        },
+      ]}>
+      <View style={styles.rowHeader}>
+        <Text style={[styles.method, { color: theme.text.default }]}>{row.method}</Text>
+        <View style={styles.rowHeaderRight}>
+          {isCompleted && row.networkProtocol ? (
+            <Text
+              style={[
+                styles.badge,
+                { color: theme.text.secondary, borderColor: theme.border.default },
+              ]}>
+              {row.networkProtocol}
+            </Text>
+          ) : null}
+          <Text style={[styles.status, { color: statusColor }]}>
+            {isCompleted
+              ? status != null
+                ? String(status)
+                : (row.errorDescription ?? 'error')
+              : '…'}
+          </Text>
+        </View>
+      </View>
+      <Text numberOfLines={1} style={[styles.url, { color: theme.text.default }]}>
+        {row.url}
+      </Text>
+      {isCompleted && row.redirects.length > 0 ? (
+        <View style={styles.redirectList}>
+          {row.redirects.map((r, index) => (
+            <Text
+              key={`${r.toUrl}-${index}`}
+              numberOfLines={1}
+              style={[styles.redirects, { color: theme.text.secondary }]}>
+              via {r.statusCode} {r.toUrl}
+            </Text>
+          ))}
+        </View>
+      ) : null}
+      {isCompleted ? (
+        <Text style={[styles.meta, { color: theme.text.secondary }]}>
+          {(row.totalDuration * 1000).toFixed(0)} ms · ↑ {formatBytes(row.requestBytesSent)} · ↓{' '}
+          {formatBytes(row.responseBytesReceived)}
+        </Text>
+      ) : null}
+    </View>
+  );
+}
+
+function statusCodeColor(
+  theme: ReturnType<typeof useTheme>,
+  isCompleted: boolean,
+  status: number | null,
+  errorDescription: string | null
+): string {
+  if (!isCompleted) {
+    return theme.text.secondary;
+  }
+  if (errorDescription != null) {
+    return theme.text.danger;
+  }
+  if (status == null) {
+    return theme.text.secondary;
+  }
+  if (status >= 200 && status < 300) {
+    return theme.text.success;
+  }
+  if (status >= 300 && status < 400) {
+    return theme.text.warning;
+  }
+  return theme.text.danger;
+}
+
+function CompactButton({ title, onPress }: { title: string; onPress: () => void }) {
+  const theme = useTheme();
+  const tokens = theme.button.secondary;
+  return (
+    <Pressable
+      onPress={onPress}
+      style={({ pressed }) => [
+        styles.compactButton,
+        { backgroundColor: tokens.background, borderColor: tokens.border },
+        pressed ? styles.compactButtonPressed : null,
+      ]}>
+      <Text style={[styles.compactButtonText, { color: tokens.text }]}>{title}</Text>
+    </Pressable>
+  );
+}
+
+function formatBytes(value: number | null): string {
+  if (value == null) {
+    return '–';
+  }
+  if (value < 1024) {
+    return `${value} B`;
+  }
+  if (value < 1024 * 1024) {
+    return `${(value / 1024).toFixed(1)} KB`;
+  }
+  return `${(value / 1024 / 1024).toFixed(1)} MB`;
+}
+
+const styles = StyleSheet.create({
+  sectionTitle: {
+    fontSize: 18,
+    fontWeight: '700',
+    marginBottom: 4,
+  },
+  sectionHint: {
+    fontSize: 13,
+    marginBottom: 16,
+  },
+  buttonRow: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: 6,
+    marginBottom: 16,
+  },
+  compactButton: {
+    paddingHorizontal: 10,
+    paddingVertical: 6,
+    borderRadius: 5,
+    borderWidth: 1,
+  },
+  compactButtonPressed: {
+    opacity: 0.5,
+  },
+  compactButtonText: {
+    fontSize: 13,
+    fontWeight: '500',
+  },
+  empty: {
+    fontSize: 13,
+    fontStyle: 'italic',
+  },
+  row: {
+    paddingVertical: 8,
+    paddingHorizontal: 10,
+    marginBottom: 6,
+    borderRadius: 6,
+  },
+  rowHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'baseline',
+  },
+  rowHeaderRight: {
+    flexDirection: 'row',
+    alignItems: 'flex-start',
+    gap: 6,
+    marginTop: -2,
+  },
+  badge: {
+    fontSize: 10,
+    fontFamily: 'Menlo',
+    paddingHorizontal: 5,
+    paddingVertical: 1,
+    borderWidth: 1,
+    borderRadius: 3,
+    overflow: 'hidden',
+  },
+  method: {
+    fontSize: 13,
+    fontWeight: '700',
+    fontFamily: 'Menlo',
+  },
+  status: {
+    fontSize: 13,
+    fontFamily: 'Menlo',
+  },
+  url: {
+    fontSize: 12,
+    fontFamily: 'Menlo',
+    marginTop: 6,
+  },
+  redirectList: {
+    marginTop: 2,
+  },
+  redirects: {
+    fontSize: 11,
+    fontFamily: 'Menlo',
+  },
+  meta: {
+    fontSize: 11,
+    marginTop: 4,
+  },
+});
diff --git a/apps/observe-tester/components/SessionDetail.tsx b/apps/observe-tester/components/SessionDetail.tsx
new file mode 100644
index 00000000000000..538b32eec8ed63
--- /dev/null
+++ b/apps/observe-tester/components/SessionDetail.tsx
@@ -0,0 +1,177 @@
+import type { Session } from 'expo-app-metrics';
+import { useObserve } from 'expo-observe';
+import { Stack } from 'expo-router';
+import { useEffect, useState } from 'react';
+import { Platform, Pressable, ScrollView, StyleSheet, Text } from 'react-native';
+
+import { CallStackTreeView } from '@/components/CallStackTreeView';
+import { Chevron } from '@/components/Chevron';
+import { CrashReportPanel } from '@/components/CrashReportPanel';
+import { Divider } from '@/components/Divider';
+import { JSONView } from '@/components/JSONView';
+import { LogsPanel } from '@/components/LogsPanel';
+import { MetricsFilter } from '@/components/MetricsFilter';
+import { MetricsPanel } from '@/components/MetricsPanel';
+import { SessionHeader } from '@/components/SessionHeader';
+import { useTheme } from '@/utils/theme';
+
+/**
+ * Presentational session detail screen. Renders a resolved `Session` record
+ * (or loading / not-found states). The data loading is the caller's
+ * responsibility — the `main` and `[id]` routes each fetch from their own
+ * source and hand the result here.
+ */
+export function SessionDetail({
+  session,
+  loaded,
+  title,
+}: {
+  session: Session | null;
+  loaded: boolean;
+  title: string;
+}) {
+  const theme = useTheme();
+  const [showRawJson, setShowRawJson] = useState(false);
+  const [selectedMetricNames, setSelectedMetricNames] = useState<Set<string>>(() => new Set());
+
+  // Seed the selection to every distinct metric name once per session id. Keyed on `session?.id`
+  // so refocusing the tab (which reloads sessions and creates a new metrics array reference)
+  // doesn't wipe the user's filter.
+  useEffect(() => {
+    if (!session) return;
+    const names = new Set<string>();
+    for (const metric of session.metrics) names.add(metric.name);
+    setSelectedMetricNames(names);
+  }, [session?.id]);
+
+  const { markInteractive } = useObserve();
+  useEffect(() => {
+    setTimeout(() => {
+      markInteractive();
+    }, 100);
+  }, []);
+
+  return (
+    <ScrollView
+      style={[styles.container, { backgroundColor: theme.background.screen }]}
+      contentContainerStyle={styles.contentContainer}>
+      <Stack.Screen options={{ title }} />
+      {!loaded ? null : session ? (
+        <>
+          <SessionHeader session={session} />
+          <Divider style={styles.divider} />
+          {session.type === 'main' && session.crashReport ? (
+            <>
+              <Text style={[styles.sectionTitle, { color: theme.text.default }]}>Crash report</Text>
+              <CrashReportPanel report={session.crashReport} />
+              {session.crashReport.callStackTree ? (
+                <>
+                  <Divider style={styles.divider} />
+                  <Text style={[styles.sectionTitle, { color: theme.text.default }]}>
+                    Call stacks
+                  </Text>
+                  <CallStackTreeView tree={session.crashReport.callStackTree} />
+                </>
+              ) : null}
+              <Divider style={styles.divider} />
+            </>
+          ) : null}
+          <Text style={[styles.sectionTitle, { color: theme.text.default }]}>Metrics</Text>
+          <MetricsFilter
+            metrics={session.metrics}
+            selected={selectedMetricNames}
+            onChange={setSelectedMetricNames}
+          />
+          <MetricsPanel metrics={session.metrics} filter={selectedMetricNames} />
+          <Divider style={styles.divider} />
+          <Text style={[styles.sectionTitle, { color: theme.text.default }]}>Log events</Text>
+          <LogsPanel logs={session.logs} />
+          <Divider style={styles.divider} />
+          <Pressable
+            onPress={() => setShowRawJson((v) => !v)}
+            style={({ pressed }) => [
+              styles.rawJsonHeader,
+              showRawJson && styles.rawJsonHeaderExpanded,
+              pressed && { opacity: 0.6 },
+            ]}>
+            <Text style={[styles.sectionTitle, styles.rawJsonTitle, { color: theme.text.default }]}>
+              Raw JSON
+            </Text>
+            <Chevron expanded={showRawJson} />
+          </Pressable>
+          {showRawJson ? <JSONView value={stripCallStackTree(session)} /> : null}
+        </>
+      ) : (
+        <Text style={[styles.notFound, { color: theme.text.default }]}>Session not found</Text>
+      )}
+    </ScrollView>
+  );
+}
+
+/**
+ * Normalizes a `Session` into a plain record, forcing `crashReport` to null
+ * since a live (active) session can't have crashed yet. Lets the `main` route
+ * render through the same presentational component as the inactive records.
+ */
+export function liveSessionToRecord(session: Session): Session {
+  return {
+    id: session.id,
+    type: session.type,
+    startDate: session.startDate,
+    endDate: session.endDate,
+    metrics: session.metrics,
+    logs: session.logs,
+    // A live session is always active, so it never has a crash report.
+    crashReport: null,
+  };
+}
+
+// The call stack tree balloons the raw JSON to the point where it can fail to render. It's
+// already shown visually in the "Call stacks" section above, so we omit it from the raw JSON
+// and replace it with a marker noting that.
+function stripCallStackTree(session: Session): Session {
+  if (!('crashReport' in session) || !session.crashReport?.callStackTree) {
+    return session;
+  }
+  return {
+    ...session,
+    crashReport: {
+      ...session.crashReport,
+      callStackTree: '<omitted, see Call stacks section>' as never,
+    },
+  };
+}
+
+const styles = StyleSheet.create({
+  container: {
+    padding: 20,
+  },
+  contentContainer: {
+    paddingBottom: Platform.select({ ios: 30, android: 150 }),
+  },
+  notFound: {
+    fontSize: 16,
+    fontWeight: 'bold',
+    textAlign: 'center',
+  },
+  sectionTitle: {
+    fontSize: 18,
+    fontWeight: '700',
+    marginBottom: 12,
+  },
+  divider: {
+    marginVertical: 16,
+  },
+  rawJsonHeader: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    gap: 12,
+  },
+  rawJsonTitle: {
+    marginBottom: 0,
+  },
+  rawJsonHeaderExpanded: {
+    marginBottom: 12,
+  },
+});
diff --git a/apps/test-suite/TestModules.ts b/apps/test-suite/TestModules.ts
index 5ed6408390c327..c51c72f7a04b2e 100644
--- a/apps/test-suite/TestModules.ts
+++ b/apps/test-suite/TestModules.ts
@@ -85,6 +85,7 @@ export function getTestModules() {
   }
 
   if (['android', 'ios'].includes(Platform.OS)) {
+    modules.push(require('./tests/AppMetrics'));
     modules.push(require('./tests/Blob'));
     modules.push(require('./tests/FileSystem'));
     modules.push(require('./tests/CalendarNext'));
diff --git a/apps/test-suite/package.json b/apps/test-suite/package.json
index 0b331c853e1d1f..03c8fd31e88b3a 100644
--- a/apps/test-suite/package.json
+++ b/apps/test-suite/package.json
@@ -20,6 +20,7 @@
     "@react-navigation/stack": "^7.8.5",
     "async-retry": "^1.1.4",
     "expo": "workspace:*",
+    "expo-app-metrics": "workspace:*",
     "expo-application": "workspace:*",
     "expo-asset": "workspace:*",
     "expo-audio": "workspace:*",
diff --git a/apps/test-suite/tests/AppMetrics.ts b/apps/test-suite/tests/AppMetrics.ts
new file mode 100644
index 00000000000000..18230da4e73f48
--- /dev/null
+++ b/apps/test-suite/tests/AppMetrics.ts
@@ -0,0 +1,183 @@
+import { fetch } from 'expo/fetch';
+import AppMetrics, {
+  type NetworkRequestCompletedEvent,
+  type NetworkRequestObserver,
+  type NetworkRequestStartedEvent,
+} from 'expo-app-metrics';
+
+export const name = 'AppMetrics';
+
+const TEST_HOST = 'https://httpbin.io';
+const EVENT_TIMEOUT_MS = 5_000;
+
+type EventCapture = {
+  started: NetworkRequestStartedEvent[];
+  completed: NetworkRequestCompletedEvent[];
+};
+
+/**
+ * Subscribes to a fresh `NetworkRequestObserver` and returns the capture buffer plus a teardown
+ * function. The buffer is populated as events fire on the native side. Filters by URL so tests
+ * don't see events from unrelated background traffic.
+ */
+function captureEvents(filterUrl: (url: string) => boolean): {
+  capture: EventCapture;
+  observer: NetworkRequestObserver;
+  release: () => void;
+} {
+  const observer = new AppMetrics.NetworkRequestObserver();
+  const capture: EventCapture = { started: [], completed: [] };
+
+  const startedSub = observer.addListener('requestStarted', (event) => {
+    if (filterUrl(event.url)) {
+      capture.started.push(event);
+    }
+  });
+  const completedSub = observer.addListener('requestCompleted', (event) => {
+    if (filterUrl(event.url)) {
+      capture.completed.push(event);
+    }
+  });
+
+  return {
+    capture,
+    observer,
+    release: () => {
+      startedSub.remove();
+      completedSub.remove();
+      // Drop the SharedObject too so the native delegate slot is reclaimed deterministically
+      // — otherwise we'd leak one observer instance per test until JS GC eventually fires
+      // `sharedObjectWillRelease`.
+      observer.release();
+    },
+  };
+}
+
+async function waitForCompletion(
+  capture: EventCapture,
+  timeoutMs = EVENT_TIMEOUT_MS
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (capture.completed.length > 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms waiting for requestCompleted event`);
+}
+
+export function test({ describe, expect, it, beforeAll }) {
+  describe('NetworkRequestObserver', () => {
+    it('emits requestStarted with the documented field shape', async () => {
+      const url = `${TEST_HOST}/get?case=started-shape`;
+      const { capture, release } = captureEvents((u) => u === url);
+      try {
+        await fetch(url);
+        await waitForCompletion(capture);
+
+        expect(capture.started.length).toBe(1);
+        const started = capture.started[0];
+        expect(typeof started.id).toBe('string');
+        expect(started.url).toBe(url);
+        expect(started.method).toBe('GET');
+        expect(typeof started.startedAt).toBe('string');
+        // ISO 8601 in UTC, truncated to whole seconds.
+        expect(started.startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/);
+      } finally {
+        release();
+      }
+    });
+
+    it('emits requestCompleted with all documented fields and a matching id', async () => {
+      const url = `${TEST_HOST}/get?case=completed-shape`;
+      const { capture, release } = captureEvents((u) => u === url);
+      try {
+        await fetch(url);
+        await waitForCompletion(capture);
+
+        expect(capture.completed.length).toBe(1);
+        const completed = capture.completed[0];
+        const started = capture.started[0];
+
+        expect(completed.id).toBe(started.id);
+        expect(completed.url).toBe(url);
+        expect(completed.method).toBe('GET');
+        expect(completed.statusCode).toBe(200);
+        // Wire protocol is platform-dependent — assert non-null/string only.
+        expect(
+          typeof completed.networkProtocol === 'string' || completed.networkProtocol === null
+        ).toBe(true);
+        expect(typeof completed.requestBytesSent).toBe('number');
+        expect(typeof completed.responseBytesReceived).toBe('number');
+        expect(completed.errorDescription).toBeNull();
+        expect(completed.startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/);
+        expect(completed.completedAt).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/);
+        expect(typeof completed.totalDuration).toBe('number');
+        expect(completed.totalDuration).toBeGreaterThan(0);
+        expect(Array.isArray(completed.redirects)).toBe(true);
+        expect(completed.redirects.length).toBe(0);
+      } finally {
+        release();
+      }
+    });
+
+    it('captures the redirect chain on the completed event', async () => {
+      // httpbin.io's `/redirect-to?url=...` returns a single 302 to the target URL.
+      const target = `${TEST_HOST}/get?case=redirect-target`;
+      const url = `${TEST_HOST}/redirect-to?url=${encodeURIComponent(target)}`;
+      const { capture, release } = captureEvents((u) => u === url || u === target);
+      try {
+        await fetch(url);
+        await waitForCompletion(capture);
+
+        // One logical fetch → one completion event observed at the caller-supplied URL.
+        const completed = capture.completed.find((event) => event.url === url);
+        expect(completed).toBeDefined();
+        expect(completed!.statusCode).toBe(200);
+        expect(completed!.redirects.length).toBe(1);
+        expect(completed!.redirects[0].fromUrl).toBe(url);
+        expect(completed!.redirects[0].toUrl).toBe(target);
+        expect(completed!.redirects[0].statusCode).toBeGreaterThanOrEqual(300);
+        expect(completed!.redirects[0].statusCode).toBeLessThan(400);
+      } finally {
+        release();
+      }
+    });
+
+    it('does not emit events after the observer is released', async () => {
+      const beforeUrl = `${TEST_HOST}/get?case=before-release`;
+      const afterUrl = `${TEST_HOST}/get?case=after-release`;
+      const { capture, release } = captureEvents((u) => u === beforeUrl || u === afterUrl);
+
+      await fetch(beforeUrl);
+      await waitForCompletion(capture);
+      expect(capture.completed.length).toBe(1);
+
+      // Tears down both the JS listeners and the SharedObject itself. After this, the native
+      // monitor must drop its weak delegate slot and no further events should reach our buffer.
+      release();
+
+      await fetch(afterUrl);
+      // Give a stray event time to land if cleanup is broken.
+      await new Promise((resolve) => setTimeout(resolve, 1_500));
+      expect(capture.completed.filter((event) => event.url === afterUrl).length).toBe(0);
+      expect(capture.started.filter((event) => event.url === afterUrl).length).toBe(0);
+    });
+
+    it('skips requests that opt out via the Expo-AppMetrics-Skip header', async () => {
+      const url = `${TEST_HOST}/get?case=opt-out`;
+      const { capture, release } = captureEvents((u) => u === url);
+      try {
+        await fetch(url, { headers: { 'Expo-AppMetrics-Skip': '1' } });
+        // No deterministic event to wait for — give the native side a window to (incorrectly)
+        // record before asserting the buffer is empty.
+        await new Promise((resolve) => setTimeout(resolve, 1_500));
+        expect(capture.started.length).toBe(0);
+        expect(capture.completed.length).toBe(0);
+      } finally {
+        release();
+      }
+    });
+  });
+}
diff --git a/docs/pages/guides/icons.mdx b/docs/pages/guides/icons.mdx
index ac8697dbc8db3b..92e62a20dd93c1 100644
--- a/docs/pages/guides/icons.mdx
+++ b/docs/pages/guides/icons.mdx
@@ -5,11 +5,13 @@ description: Learn how to use various types of icons in your Expo app, including
 
 import { SnackInline } from '~/ui/components/Snippet';
 
-Not every app needs to use emojis for icons. You can use a popular icon set through an icon font such as FontAwesome, Glyphicons, or Ionicons, or choose PNGs from [The Noun Project](https://thenounproject.com/). This guide explains various ways to use icons in your Expo app.
+You can use popular icon sets through icon fonts such as FontAwesome, Glyphicons, or Ionicons, or choose PNGs from [The Noun Project](https://thenounproject.com/). This guide explains various ways to use icons in your Expo app.
 
 ## `@expo/vector-icons`
 
-The `@expo/vector-icons` library is installed by default on the template project using `npx create-expo-app` and is part of the `expo` package. It is built on top of [`react-native-vector-icons`](https://github.com/oblador/react-native-vector-icons) and uses a similar API. It includes popular icon sets you can browse at [icons.expo.fyi](https://icons.expo.fyi).
+> **warning** `@expo/vector-icons` will be deprecated and is not recommended. [Learn more about migrating to `@react-native-vector-icons`](https://expo.dev/blog/moving-away-from-expo-vector-icons).
+
+The `@expo/vector-icons` library is built on top of [`react-native-vector-icons`](https://github.com/oblador/react-native-vector-icons) and uses a similar API. It includes popular icon sets you can browse at [icons.expo.fyi](https://icons.expo.fyi).
 
 The component loads the `Ionicons` font and renders a checkmark icon in the following example:
 
diff --git a/packages/@expo/cli/e2e/playwright/dev/dev-console-errors.test.ts b/packages/@expo/cli/e2e/playwright/dev/dev-console-errors.test.ts
index ad5cd570124572..46d24d6c86ae95 100644
--- a/packages/@expo/cli/e2e/playwright/dev/dev-console-errors.test.ts
+++ b/packages/@expo/cli/e2e/playwright/dev/dev-console-errors.test.ts
@@ -1,4 +1,5 @@
 import { test, expect } from '@playwright/test';
+import { platform } from 'node:process';
 import { stripVTControlCharacters } from 'node:util';
 
 import { clearEnv, restoreEnv } from '../../__tests__/export/export-side-effects';
@@ -11,6 +12,7 @@ test.beforeAll(() => clearEnv());
 test.afterAll(() => restoreEnv());
 
 const projectRoot = getRouterE2ERoot();
+const isWindows = platform === 'win32';
 
 test.describe('dev console errors', () => {
   const expoStart = createExpoStart({
@@ -47,8 +49,11 @@ test.describe('dev console errors', () => {
     await openPageAndEagerlyLoadJS(expoStart, page);
     await page.getByText('throw new Error()', { exact: true }).click();
 
-    const expectedConsoleOutput = `
-Web  ERROR  [Error: unhandled-throw] 
+    if (isWindows) {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  [Error: unhandled-throw]
 
 Code: index.tsx
   42 |         title="throw new Error()"
@@ -59,7 +64,37 @@ Code: index.tsx
   46 |       />
   47 |       <BigButton
 Call Stack
-  BigButton.props.onPress (apps/router-e2e/__e2e__/06-errors/app/index.tsx:44:17) 
+  BigButton.props.onPress (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:44:17)
+
+Code: index.tsx
+  139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
+  140 |   return (
+> 141 |     <Text
+      |     ^
+  142 |       style={{ fontSize: 24, backgroundColor: 'darkcyan', color: 'white', padding: 16 }}
+  143 |       onPress={onPress}>
+  144 |       {title}
+Call Stack
+  BigButton (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:141:5)
+  App (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:41:7)
+        `.trim()
+      );
+    } else {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  [Error: unhandled-throw]
+
+Code: index.tsx
+  42 |         title="throw new Error()"
+  43 |         onPress={() => {
+> 44 |           throw new Error('unhandled-throw');
+     |                 ^
+  45 |         }}
+  46 |       />
+  47 |       <BigButton
+Call Stack
+  BigButton.props.onPress (apps/router-e2e/__e2e__/06-errors/app/index.tsx:44:17)
 
 Code: index.tsx
   139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
@@ -72,9 +107,9 @@ Code: index.tsx
 Call Stack
   BigButton (apps/router-e2e/__e2e__/06-errors/app/index.tsx:141:5)
   App (apps/router-e2e/__e2e__/06-errors/app/index.tsx:41:7)
-    `.trim();
-
-    await expectOutput(output, expectedConsoleOutput);
+        `.trim()
+      );
+    }
   });
 
   test('prints call stack of unhandled rejections', async ({ page }) => {
@@ -83,8 +118,11 @@ Call Stack
     await openPageAndEagerlyLoadJS(expoStart, page);
     await page.getByText('async throw new Error()').click();
 
-    const expectedConsoleOutput = `
-Web  ERROR  [Error: unhandled-async-throw] 
+    if (isWindows) {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  [Error: unhandled-async-throw]
 
 Code: index.tsx
   49 |         onPress={() => {
@@ -95,10 +133,29 @@ Code: index.tsx
   53 |           void throwAsyncError();
   54 |         }}
 Call Stack
-  throwAsyncError (apps/router-e2e/__e2e__/06-errors/app/index.tsx:51:19)
-    `.trim();
+  throwAsyncError (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:51:19)
+  BigButton.props.onPress (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:53:16)
+        `.trim()
+      );
+    } else {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  [Error: unhandled-async-throw]
 
-    await expectOutput(output, expectedConsoleOutput);
+Code: index.tsx
+  49 |         onPress={() => {
+  50 |           async function throwAsyncError() {
+> 51 |             throw new Error('unhandled-async-throw');
+     |                   ^
+  52 |           }
+  53 |           void throwAsyncError();
+  54 |         }}
+Call Stack
+  throwAsyncError (apps/router-e2e/__e2e__/06-errors/app/index.tsx:51:19)
+        `.trim()
+      );
+    }
   });
 
   test('prints component stack of unhandled thrown non-Error values (strings)', async ({ page }) => {
@@ -107,8 +164,30 @@ Call Stack
     await openPageAndEagerlyLoadJS(expoStart, page);
     await page.getByText('throw string').click();
 
-    const expectedConsoleOutput = `
-Web  ERROR  unhandled-throw-string 
+    if (isWindows) {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  unhandled-throw-string
+
+Code: index.tsx
+  139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
+  140 |   return (
+> 141 |     <Text
+      |     ^
+  142 |       style={{ fontSize: 24, backgroundColor: 'darkcyan', color: 'white', padding: 16 }}
+  143 |       onPress={onPress}>
+  144 |       {title}
+Call Stack
+  BigButton (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:141:5)
+  App (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:56:7)
+        `.trim()
+      );
+    } else {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  unhandled-throw-string
 
 Code: index.tsx
   139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
@@ -121,9 +200,9 @@ Code: index.tsx
 Call Stack
   BigButton (apps/router-e2e/__e2e__/06-errors/app/index.tsx:141:5)
   App (apps/router-e2e/__e2e__/06-errors/app/index.tsx:56:7)
-    `.trim();
-
-    await expectOutput(output, expectedConsoleOutput);
+        `.trim()
+      );
+    }
   });
 
   test('prints no stack for unhandled rejected non-Error values (strings)', async ({ page }) => {
@@ -142,8 +221,41 @@ Call Stack
     await openPageAndEagerlyLoadJS(expoStart, page);
     await page.getByText('console.error(new Error())').click();
 
-    const expectedConsoleOutput = `
-Web  ERROR  [Error: console-error-object] 
+    if (isWindows) {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  [Error: console-error-object]
+
+Code: index.tsx
+  89 |         title="console.error(new Error())"
+  90 |         onPress={() => {
+> 91 |           console.error(new Error('console-error-object'));
+     |                         ^
+  92 |         }}
+  93 |       />
+  94 |       <BigButton
+Call Stack
+  BigButton.props.onPress (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:91:25)
+
+Code: index.tsx
+  139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
+  140 |   return (
+> 141 |     <Text
+      |     ^
+  142 |       style={{ fontSize: 24, backgroundColor: 'darkcyan', color: 'white', padding: 16 }}
+  143 |       onPress={onPress}>
+  144 |       {title}
+Call Stack
+  BigButton (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:141:5)
+  App (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:88:7)
+        `.trim()
+      );
+    } else {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  [Error: console-error-object]
 
 Code: index.tsx
   89 |         title="console.error(new Error())"
@@ -154,7 +266,7 @@ Code: index.tsx
   93 |       />
   94 |       <BigButton
 Call Stack
-  BigButton.props.onPress (apps/router-e2e/__e2e__/06-errors/app/index.tsx:91:25) 
+  BigButton.props.onPress (apps/router-e2e/__e2e__/06-errors/app/index.tsx:91:25)
 
 Code: index.tsx
   139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
@@ -167,9 +279,9 @@ Code: index.tsx
 Call Stack
   BigButton (apps/router-e2e/__e2e__/06-errors/app/index.tsx:141:5)
   App (apps/router-e2e/__e2e__/06-errors/app/index.tsx:88:7)
-    `.trim();
-
-    await expectOutput(output, expectedConsoleOutput);
+        `.trim()
+      );
+    }
   });
 
   test('prints call stack and component stack of console.error non-Error values (strings)', async ({ page }) => {
@@ -178,8 +290,33 @@ Call Stack
     await openPageAndEagerlyLoadJS(expoStart, page);
     await page.getByText('console.error(string)').click();
 
-    const expectedConsoleOutput = `
-Web  ERROR  console-error-string 
+    if (isWindows) {
+      // NOTE: On Windows the call stack additionally leads with internal
+      // `packages/expo` and `packages/@expo/log-box` frames, because in this monorepo
+      // those workspace packages resolve to real `packages/...` paths instead of
+      // `node_modules/...` (so the node_modules collapse patterns miss them). A real app
+      // installs them under node_modules and they collapse. We assert the component stack here.
+      await expectOutput(
+        output,
+        `
+Code: index.tsx
+  139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
+  140 |   return (
+> 141 |     <Text
+      |     ^
+  142 |       style={{ fontSize: 24, backgroundColor: 'darkcyan', color: 'white', padding: 16 }}
+  143 |       onPress={onPress}>
+  144 |       {title}
+Call Stack
+  BigButton (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:141:5)
+  App (apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx:94:7)
+        `.trim()
+      );
+    } else {
+      await expectOutput(
+        output,
+        `
+Web  ERROR  console-error-string
 
 Code: index.tsx
    95 |         title="console.error(string)"
@@ -190,7 +327,7 @@ Code: index.tsx
    99 |       />
   100 |       <BigButton
 Call Stack
-  BigButton.props.onPress (apps/router-e2e/__e2e__/06-errors/app/index.tsx:97:19) 
+  BigButton.props.onPress (apps/router-e2e/__e2e__/06-errors/app/index.tsx:97:19)
 
 Code: index.tsx
   139 | function BigButton({ title, onPress }: { title: string; onPress: () => void }) {
@@ -203,9 +340,9 @@ Code: index.tsx
 Call Stack
   BigButton (apps/router-e2e/__e2e__/06-errors/app/index.tsx:141:5)
   App (apps/router-e2e/__e2e__/06-errors/app/index.tsx:94:7)
-    `.trim();
-
-    await expectOutput(output, expectedConsoleOutput);
+        `.trim()
+      );
+    }
   });
 
   test('prints console.warn strings without stack traces', async ({ page }) => {
@@ -221,14 +358,22 @@ Call Stack
 
 async function expectOutput(output: { all: string }, expectedConsoleOutput: string) {
   await expect
-    .poll(() => stripVTControlCharacters(output.all), { timeout: 30_000 })
-    .toContain(expectedConsoleOutput);
+    .poll(() => normalizeConsoleOutput(output.all), { timeout: 30_000 })
+    .toContain(normalizeConsoleOutput(expectedConsoleOutput));
 }
 
 function expectNoStackTrace(output: { all: string }) {
-  const terminalOutput = stripVTControlCharacters(output.all);
+  const terminalOutput = normalizeConsoleOutput(output.all);
   // `http://localhost:8081/apps/router-e2e` would mean an unsymbolicated stack trace leaked.
   expect(terminalOutput).not.toContain('http://localhost:8081/apps/router-e2e');
   // `apps/router-e2e/__e2e__/06-errors/app/index.tsx` would mean a symbolicated stack trace leaked.
   expect(terminalOutput).not.toContain('apps/router-e2e/__e2e__/06-errors/app/index.tsx');
+  // `apps\router-e2e\__e2e__\06-errors\app\index.tsx` would mean a symbolicated stack trace leaked.
+  expect(terminalOutput).not.toContain('apps\\router-e2e\\__e2e__\\06-errors\\app\\index.tsx');
+}
+
+function normalizeConsoleOutput(output: string) {
+  return stripVTControlCharacters(output)
+    // Remove trailing whitespace from each line.
+    .replace(/[ \t]+$/gm, '');
 }
diff --git a/packages/@expo/metro-config/CHANGELOG.md b/packages/@expo/metro-config/CHANGELOG.md
index 90b2f600830b06..eecf3056642b85 100644
--- a/packages/@expo/metro-config/CHANGELOG.md
+++ b/packages/@expo/metro-config/CHANGELOG.md
@@ -8,6 +8,7 @@
 
 ### 🐛 Bug fixes
 
+- Fix stack frame collapsing for Windows paths. ([#46645](https://github.com/expo/expo/pull/46645) by [@krystofwoldrich](https://github.com/krystofwoldrich))
 - Bump `hermes-parser` to `^0.36.0` to parse newer Flow syntax (e.g. `readonly` property modifiers) shipped in recent React Native versions ([#46636](https://github.com/expo/expo/pull/46636) by [@zoontek](https://github.com/zoontek))
 
 ### 💡 Others
diff --git a/packages/@expo/metro-config/build/customizeFrame.js b/packages/@expo/metro-config/build/customizeFrame.js
index 8849109162b4a2..c4fd94b692edde 100644
--- a/packages/@expo/metro-config/build/customizeFrame.js
+++ b/packages/@expo/metro-config/build/customizeFrame.js
@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.INTERNAL_CALLSITES_REGEX = void 0;
 exports.getDefaultCustomizeFrame = getDefaultCustomizeFrame;
-const url_1 = require("url");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const filePath_1 = require("./utils/filePath");
 // Import only the types here, the values will be imported from the project, at runtime.
 exports.INTERNAL_CALLSITES_REGEX = new RegExp([
     '/Libraries/Renderer/implementations/.+\\.js$',
@@ -62,9 +67,15 @@ exports.INTERNAL_CALLSITES_REGEX = new RegExp([
     'node_modules/.+/',
 ].join('|'));
 function isUrl(value) {
+    // Windows absolute paths (e.g. `C:\path\to\file.js`) are parsed as a URL with a
+    // single-letter (drive) protocol by `new URL`. Treat those as file paths, not URLs,
+    // otherwise every Windows frame is incorrectly collapsed and stripped of its location.
+    if (node_path_1.default.isAbsolute(value)) {
+        return false;
+    }
     try {
         // eslint-disable-next-line no-new
-        new url_1.URL(value);
+        new node_url_1.URL(value);
         return true;
     }
     catch {
@@ -88,7 +99,9 @@ function getDefaultCustomizeFrame() {
                 collapse: true,
             };
         }
-        let collapse = Boolean(frame.file && exports.INTERNAL_CALLSITES_REGEX.test(frame.file));
+        // INTERNAL_CALLSITES_REGEX uses POSIX separators (`/`). On Windows `frame.file`
+        // uses `\`, so it must be normalized to POSIX or no library frames would collapse.
+        let collapse = Boolean(frame.file && exports.INTERNAL_CALLSITES_REGEX.test((0, filePath_1.toPosixPath)(frame.file)));
         if (!collapse) {
             // This represents the first frame of the stacktrace.
             // Often this looks like: `__r(0);`.
diff --git a/packages/@expo/metro-config/build/customizeFrame.js.map b/packages/@expo/metro-config/build/customizeFrame.js.map
index 37c18fe291712d..c7958080f21e77 100644
--- a/packages/@expo/metro-config/build/customizeFrame.js.map
+++ b/packages/@expo/metro-config/build/customizeFrame.js.map
@@ -1 +1 @@
-{"version":3,"file":"customizeFrame.js","sourceRoot":"","sources":["../src/customizeFrame.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
+{"version":3,"file":"customizeFrame.js","sourceRoot":"","sources":["../src/customizeFrame.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/packages/@expo/metro-config/src/__tests__/customizeFrame.test.ts b/packages/@expo/metro-config/src/__tests__/customizeFrame.test.ts
new file mode 100644
index 00000000000000..fa2f71bab1a68b
--- /dev/null
+++ b/packages/@expo/metro-config/src/__tests__/customizeFrame.test.ts
@@ -0,0 +1,126 @@
+import { getDefaultCustomizeFrame } from '../customizeFrame';
+
+describe(getDefaultCustomizeFrame, () => {
+  it('collapses URL frames and removes their locations', () => {
+    const customizeFrame = getDefaultCustomizeFrame();
+
+    expect(
+      customizeFrame({
+        file: 'http://localhost:8081/index.bundle?platform=ios',
+        lineNumber: 10,
+        column: 20,
+        methodName: 'render',
+      })
+    ).toEqual({
+      file: 'http://localhost:8081/index.bundle?platform=ios',
+      lineNumber: null,
+      column: null,
+      methodName: 'render',
+      collapse: true,
+    });
+  });
+
+  it('does not collapse valid source file frames', () => {
+    const customizeFrame = getDefaultCustomizeFrame();
+
+    expect(
+      customizeFrame({
+        file: '/Users/app/src/index.tsx',
+        lineNumber: 10,
+        column: 20,
+        methodName: 'render',
+      })
+    ).toEqual({
+      file: '/Users/app/src/index.tsx',
+      lineNumber: 10,
+      column: 20,
+      methodName: 'render',
+      collapse: false,
+    });
+  });
+
+  it('collapses node_modules frames with POSIX separators', () => {
+    const customizeFrame = getDefaultCustomizeFrame();
+
+    expect(
+      customizeFrame({
+        file: '/Users/app/node_modules/react/index.js',
+        lineNumber: 10,
+        column: 20,
+        methodName: 'render',
+      })
+    ).toEqual({
+      file: '/Users/app/node_modules/react/index.js',
+      lineNumber: 10,
+      column: 20,
+      methodName: 'render',
+      collapse: true,
+    });
+  });
+
+  it('collapses node_modules frames with Windows separators', () => {
+    jest.isolateModules(() => {
+      mockWindowsPath();
+
+      const { getDefaultCustomizeFrame } =
+        require('../customizeFrame') as typeof import('../customizeFrame');
+      const customizeFrame = getDefaultCustomizeFrame();
+
+      expect(
+        customizeFrame({
+          file: 'C:\\Users\\app\\node_modules\\react\\index.js',
+          lineNumber: 10,
+          column: 20,
+          methodName: 'render',
+        })
+      ).toEqual({
+        file: 'C:\\Users\\app\\node_modules\\react\\index.js',
+        lineNumber: 10,
+        column: 20,
+        methodName: 'render',
+        collapse: true,
+      });
+    });
+  });
+
+  it.each([
+    'C:\\Users\\app\\src\\index.tsx',
+    'D:/Users/app/src/index.tsx',
+    'K:\\Users\\app\\src\\index.tsx',
+  ])('does not treat Windows absolute path %s as a URL', (file) => {
+    jest.isolateModules(() => {
+      mockWindowsPath();
+
+      const { getDefaultCustomizeFrame } =
+        require('../customizeFrame') as typeof import('../customizeFrame');
+      const customizeFrame = getDefaultCustomizeFrame();
+
+      expect(
+        customizeFrame({
+          file,
+          lineNumber: 10,
+          column: 20,
+          methodName: 'render',
+        })
+      ).toEqual({
+        file,
+        lineNumber: 10,
+        column: 20,
+        methodName: 'render',
+        collapse: false,
+      });
+    });
+  });
+});
+
+function mockWindowsPath() {
+  const path = jest.requireActual<typeof import('node:path')>('node:path');
+  const windowsPath = {
+    __esModule: true,
+    ...path.win32,
+    default: path.win32,
+  };
+
+  jest.doMock('node:path', () => windowsPath);
+  jest.doMock('path', () => windowsPath);
+}
diff --git a/packages/@expo/metro-config/src/customizeFrame.ts b/packages/@expo/metro-config/src/customizeFrame.ts
index c380b28e3117f6..e4dbc2dc8248f9 100644
--- a/packages/@expo/metro-config/src/customizeFrame.ts
+++ b/packages/@expo/metro-config/src/customizeFrame.ts
@@ -1,6 +1,9 @@
 // Copyright 2023-present 650 Industries (Expo). All rights reserved.
 import type { SymbolicatorConfigT } from '@expo/metro/metro-config';
-import { URL } from 'url';
+import path from 'node:path';
+import { URL } from 'node:url';
+
+import { toPosixPath } from './utils/filePath';
 
 type CustomizeFrameFunc = SymbolicatorConfigT['customizeFrame'];
 
@@ -68,6 +71,12 @@ export const INTERNAL_CALLSITES_REGEX = new RegExp(
 );
 
 function isUrl(value: string): boolean {
+  // Windows absolute paths (e.g. `C:\path\to\file.js`) are parsed as a URL with a
+  // single-letter (drive) protocol by `new URL`. Treat those as file paths, not URLs,
+  // otherwise every Windows frame is incorrectly collapsed and stripped of its location.
+  if (path.isAbsolute(value)) {
+    return false;
+  }
   try {
     // eslint-disable-next-line no-new
     new URL(value);
@@ -94,7 +103,9 @@ export function getDefaultCustomizeFrame(): CustomizeFrameFunc {
         collapse: true,
       };
     }
-    let collapse = Boolean(frame.file && INTERNAL_CALLSITES_REGEX.test(frame.file));
+    // INTERNAL_CALLSITES_REGEX uses POSIX separators (`/`). On Windows `frame.file`
+    // uses `\`, so it must be normalized to POSIX or no library frames would collapse.
+    let collapse = Boolean(frame.file && INTERNAL_CALLSITES_REGEX.test(toPosixPath(frame.file)));
 
     if (!collapse) {
       // This represents the first frame of the stacktrace.
diff --git a/packages/expo-app-metrics/CHANGELOG.md b/packages/expo-app-metrics/CHANGELOG.md
new file mode 100644
index 00000000000000..55b1bfae94f8c4
--- /dev/null
+++ b/packages/expo-app-metrics/CHANGELOG.md
@@ -0,0 +1,13 @@
+# Changelog
+
+## Unpublished
+
+### 🛠 Breaking changes
+
+### 🎉 New features
+
+- Observe HTTP requests on iOS and Android and expose them to JS via the `NetworkRequestObserver` class and `useNetworkRequestObserver` hook. The TTI metric also carries an `expo.network.requests.*` summary for requests that completed in the launch window. ([#46475](https://github.com/expo/expo/pull/46475) by [@tsapeta](https://github.com/tsapeta))
+
+### 🐛 Bug fixes
+
+### 💡 Others
diff --git a/packages/expo-app-metrics/android/build.gradle b/packages/expo-app-metrics/android/build.gradle
index 4369894c7ddcff..02262aca314b35 100644
--- a/packages/expo-app-metrics/android/build.gradle
+++ b/packages/expo-app-metrics/android/build.gradle
@@ -73,6 +73,12 @@ repositories {
 dependencies {
     implementation project(':expo-updates-interface')
     implementation "com.facebook.react:react-android"
+    // `api` because `NetworkRequestInterceptor` and `NetworkRequestEventListener` are part of the
+    // public surface (apps with their own `OkHttpClient.Builder` opt in by adding our interceptor
+    // and event listener factory), and consumers need `okhttp3.Interceptor` /
+    // `okhttp3.EventListener.Factory` on the classpath to write that wiring. RN already exposes
+    // OkHttp via its own `api` dep, but we don't want to rely on that.
+    api "com.squareup.okhttp3:okhttp:${expoModule.safeExtGet("okHttpVersion", '4.9.2')}"
     // This is a workaround for IDE warning - https://youtrack.jetbrains.com/issue/KTIJ-31549
     implementation "androidx.annotation:annotation-experimental:1.5.1"
     implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0"
@@ -87,4 +93,5 @@ dependencies {
     testImplementation 'androidx.test:core:1.5.0'
     testImplementation 'io.mockk:mockk:1.13.8'
     testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3'
+    testImplementation "com.squareup.okhttp3:mockwebserver:${expoModule.safeExtGet("okHttpVersion", '4.9.2')}"
 }
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsApplicationLifecycleListeners.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsApplicationLifecycleListeners.kt
index 1f30006fdb5b0e..6d5d38cf5ada33 100644
--- a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsApplicationLifecycleListeners.kt
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsApplicationLifecycleListeners.kt
@@ -2,11 +2,21 @@ package expo.modules.appmetrics
 
 import android.app.Application
 import expo.modules.appmetrics.appstartup.AppStartupManager
+import expo.modules.appmetrics.networkrequests.OkHttpClientProviderHook
 import expo.modules.core.interfaces.ApplicationLifecycleListener
 
 class AppMetricsApplicationLifecycleListeners : ApplicationLifecycleListener {
   override fun onCreate(application: Application) {
     super.onCreate(application)
     AppStartupManager.recordAppCreated(application)
+    // Install the OkHttp factory hook as early as possible - before React Native lazily caches
+    // its client. See `OkHttpClientProviderHook` for the race we're trying to win.
+    //
+    // `Application.onCreate` runs once per process. When Android keeps the process alive across
+    // activity recreations (see expo/expo#44879), this method isn't called again - but it doesn't
+    // need to be: `OkHttpClientProvider.factory` and `.client` are both process-scope statics, so
+    // the previous install survives and RN's next `getOkHttpClient()` still returns a client with
+    // our interceptor.
+    OkHttpClientProviderHook.installIfNeeded()
   }
 }
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsModule.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsModule.kt
index a832864809f3e9..d1d41d43f52d30 100644
--- a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsModule.kt
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/AppMetricsModule.kt
@@ -3,6 +3,7 @@ package expo.modules.appmetrics
 import android.content.Context
 import expo.modules.appmetrics.appstartup.AppStartupManager
 import expo.modules.appmetrics.logevents.LogEventOptions
+import expo.modules.appmetrics.networkrequests.NetworkRequestObserver
 import expo.modules.appmetrics.logevents.Severity
 import expo.modules.appmetrics.logevents.sanitizeLogEventAttributes
 import expo.modules.appmetrics.logevents.validateEventBody
@@ -119,7 +120,7 @@ class AppMetricsModule : Module(), UpdatesStateChangeListener {
         appSessionId = sessionManager.createSessionId()
 
         // Persist the session row eagerly so it's visible to readers
-        // (`getAllSessions`, `addCustomMetricToSession`, …) before any startup
+        // (`getMainSession`, `addCustomMetricToSession`, …) before any startup
         // metrics arrive. Older app runs are deactivated in the same coroutine
         // to keep the order well-defined. The `Job` is captured so `OnDestroy`
         // can wait for the INSERT before stamping `endTimestamp`.
@@ -165,8 +166,10 @@ class AppMetricsModule : Module(), UpdatesStateChangeListener {
         }
       }
 
-      AsyncFunction("getAllSessions") Coroutine { ->
-        sessionManager.getAllSessions().map { JsSession.fromSessionWithMetrics(it) }
+      // Debug-only: surfaces the inactive (ended) sessions for on-device
+      // inspection (e.g. the ObserveTester app)
+      AsyncFunction("getInactiveSessions") Coroutine { ->
+        sessionManager.getInactiveSessions().map { JsSession.fromSessionWithMetrics(it) }
       }
 
       AsyncFunction("takeMemoryUsageSnapshotAsync") Coroutine { sessionId: String? ->
@@ -182,6 +185,12 @@ class AppMetricsModule : Module(), UpdatesStateChangeListener {
       AsyncFunction("getMainSession") Coroutine { ->
         sessionManager.getSessionById(appSessionId)?.let { JsSession.fromSessionWithMetrics(it) }
       }
+
+      Class(NetworkRequestObserver::class) {
+        Constructor {
+          NetworkRequestObserver(appContext)
+        }
+      }
     }
 
   fun setEnvironment(environment: String) {
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/appstartup/AppStartupManager.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/appstartup/AppStartupManager.kt
index d0461a61b18a87..84f4f44e974039 100644
--- a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/appstartup/AppStartupManager.kt
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/appstartup/AppStartupManager.kt
@@ -11,6 +11,7 @@ import expo.modules.appmetrics.AppStartupMetric
 import expo.modules.appmetrics.TAG
 import expo.modules.appmetrics.frames.FrameMetricsRecord
 import expo.modules.appmetrics.frames.FrameMetricsRecorder
+import expo.modules.appmetrics.networkrequests.NetworkRequestMonitor
 import expo.modules.appmetrics.storage.Metric
 import expo.modules.appmetrics.utils.DeviceConditions
 import expo.modules.appmetrics.utils.MetricParamsBuilder
@@ -18,6 +19,7 @@ import expo.modules.appmetrics.utils.TimeUtils.getCurrentTimeInMillis
 import expo.modules.appmetrics.utils.TimeUtils.getCurrentTimestampInISOFormat
 import expo.modules.appmetrics.utils.TimeUtils.getProcessStartTimeInMillis
 import org.json.JSONObject
+import java.util.Date
 import java.util.concurrent.CopyOnWriteArrayList
 
 enum class AppStartType { COLD, WARM }
@@ -233,11 +235,18 @@ object AppStartupManager {
     frameMetrics: FrameMetricsRecord,
     userParams: Map<String, Any>?
   ): Map<String, Any> {
+    // Window the network summary to `launchTimeInMillis -> now` - same anchor iOS uses
+    // (`markers.finishedLaunchingDate`). When the anchor is missing we skip the summary
+    // entirely; an unbounded window would silently include requests from before launch.
+    val networkRequests = launchTimeInMillis?.let { launchStart ->
+      NetworkRequestMonitor.shared.summarize(start = Date(launchStart), end = Date())
+    }
     return MetricParamsBuilder.build(
       userParams = userParams,
       frameMetrics = frameMetrics,
       deviceState = DeviceConditions.deviceState(context),
-      networkState = DeviceConditions.networkState(context)
+      networkState = DeviceConditions.networkState(context),
+      networkRequests = networkRequests
     )
   }
 
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequest.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequest.kt
new file mode 100644
index 00000000000000..e8a7b2037e23bd
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequest.kt
@@ -0,0 +1,106 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+package expo.modules.appmetrics.networkrequests
+
+import java.util.Date
+import java.util.UUID
+
+/**
+ * Snapshot of an HTTP request seen by `NetworkRequestInterceptor`.
+ * Matches the iOS `NetworkRequest` struct so request data is consistent across platforms.
+ *
+ * The URL is stored as-is, including query parameters. Any redaction of sensitive data
+ * (for example, query parameter tokens or auth headers) must be handled by downstream code
+ * before the request is stored or reported.
+ */
+data class NetworkRequest(
+  /** Stable identifier for this observation. */
+  val id: UUID,
+
+  /** Request URL as supplied to OkHttp. May include query parameters and fragments. */
+  val url: String,
+
+  /** HTTP method (`GET`, `POST`, …). */
+  val method: String,
+
+  /** Response status code, or `null` if the request failed before headers were received. */
+  val statusCode: Int?,
+
+  /** Negotiated wire protocol - `http/1.1`, `h2`, `h3` - as reported by OkHttp's `Protocol`. */
+  val networkProtocol: String?,
+
+  /** Number of bytes sent on the wire for the request (headers + body). */
+  val requestBytesSent: Long?,
+
+  /** Number of bytes received on the wire for the response (headers + body). */
+  val responseBytesReceived: Long?,
+
+  /** Phase-by-phase timings, populated from OkHttp `EventListener` callbacks where available. */
+  val timings: Timings,
+
+  /**
+   * Short human-readable error description if the request completed with an exception. Kept as a
+   * string rather than carrying the throwable so the type stays serializable.
+   */
+  val errorDescription: String?,
+
+  /**
+   * Ordered list of redirect hops that preceded the final response. Empty when the request landed
+   * directly. Each entry's `fromUrl` is the URL that returned the redirect, `toUrl` is where the
+   * redirect pointed, and `statusCode` is the 3xx code that caused the hop.
+   */
+  val redirects: List<Redirect>
+) {
+  data class Redirect(
+    /** The URL that returned the redirect. */
+    val fromUrl: String,
+    /** The URL the request was redirected to. */
+    val toUrl: String,
+    /** The 3xx status code returned by `fromUrl` that caused this hop. */
+    val statusCode: Int
+  )
+
+  data class Timings(
+    /** When the request was dispatched (interceptor entry). */
+    val fetchStart: Date?,
+
+    /** When DNS resolution began. `null` if the host was resolved from cache or the connection was reused. */
+    val domainLookupStart: Date?,
+    val domainLookupEnd: Date?,
+
+    /** When the TCP connection began. `null` if a connection was reused. */
+    val connectStart: Date?,
+    val connectEnd: Date?,
+
+    /** TLS handshake window. `null` for cleartext or reused connections. */
+    val secureConnectionStart: Date?,
+    val secureConnectionEnd: Date?,
+
+    /** When the request line/headers began being sent. */
+    val requestStart: Date?,
+    val requestEnd: Date?,
+
+    /** When the first byte of the response arrived (TTFB). */
+    val responseStart: Date?,
+    val responseEnd: Date?,
+
+    /**
+     * Total wall-clock duration of the request in seconds. Convenience: callers don't have to
+     * subtract `fetchStart` from `responseEnd` themselves, and we can populate this even when
+     * individual phases are `null` (cache hits, errors before headers).
+     */
+    val totalDuration: Double
+  )
+}
+
+/**
+ * Lightweight snapshot emitted when a request begins, before any response or timing data exists.
+ * Shares its `id` with the corresponding completion-time `NetworkRequest`, so JS subscribers can
+ * correlate the two events.
+ */
+data class NetworkRequestStarted(
+  val id: UUID,
+  val url: String,
+  val method: String,
+  val startedAt: Date
+)
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestInterceptor.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestInterceptor.kt
new file mode 100644
index 00000000000000..8fe4370d615a07
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestInterceptor.kt
@@ -0,0 +1,551 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+package expo.modules.appmetrics.networkrequests
+
+import okhttp3.Call
+import okhttp3.EventListener
+import okhttp3.Handshake
+import okhttp3.Headers
+import okhttp3.Interceptor
+import okhttp3.MediaType
+import okhttp3.Protocol
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.ResponseBody
+import okio.Buffer
+import okio.BufferedSource
+import okio.ForwardingSource
+import okio.buffer
+import java.io.IOException
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.net.Proxy
+import java.util.Date
+import java.util.UUID
+import java.util.WeakHashMap
+
+/**
+ * Sentinel header recognised by `NetworkRequestInterceptor` to skip observation. expo-observe's
+ * dispatcher sets it on outgoing telemetry so our own uploads don't recurse through the monitor.
+ * Mirrors `NetworkRequestTaskSwizzling.internalHeaderName` on iOS — keep the literal in sync.
+ */
+const val INTERNAL_HEADER_NAME = "Expo-AppMetrics-Skip"
+
+/**
+ * Marker tag attached to requests that have already entered our application interceptor. Used by
+ * the double-instrumentation guard: if an app installs `NetworkRequestInterceptor.instance` on a
+ * client that's *also* getting injected by the RN factory hook, the second pass short-circuits
+ * to `chain.proceed(request)` without re-observing.
+ */
+private object AlreadyObservedMarker
+
+/**
+ * OkHttp `Interceptor` that records every HTTP request that traverses an `OkHttpClient` it's
+ * installed on. Sees the original outgoing request (URL the caller fetched) and the final
+ * response after OkHttp follows redirects — emits one `requestStarted` and one `requestCompleted`
+ * per logical fetch.
+ *
+ * Phase timings (`dnsStart`, `connectStart`, etc.) and body byte counts are captured by
+ * `NetworkRequestEventListener` on the network layer (below `BridgeInterceptor` and
+ * `GzipSource`) so they reflect real on-the-wire bytes rather than the gunzipped, app-level
+ * view our interceptor sees. The interceptor reads (and removes) the per-call timings entry
+ * when finalizing the snapshot.
+ *
+ * Response-body completion is signaled via a thin `BodyCloseSignal` wrapper so finalization
+ * waits for the caller to drain the response — by the time the wrapper fires, the listener's
+ * `responseBodyEnd` byte count is stable.
+ */
+class NetworkRequestInterceptor private constructor(
+  private val monitor: NetworkRequestMonitor
+) : Interceptor {
+  override fun intercept(chain: Interceptor.Chain): Response {
+    val originalRequest = chain.request()
+
+    // Recursion guard: telemetry uploads carry this header so they aren't observed in turn. We
+    // don't record these, but the per-call event listener still fires for them — its orphaned
+    // timings entry is reclaimed by the weak-keyed `inFlightTimings` map (see there).
+    if (originalRequest.header(INTERNAL_HEADER_NAME) != null) {
+      val stripped = originalRequest.newBuilder().removeHeader(INTERNAL_HEADER_NAME).build()
+      return chain.proceed(stripped)
+    }
+
+    // Double-instrumentation guard: a downstream interceptor in the same chain may already be us.
+    if (originalRequest.tag(AlreadyObservedMarker::class.java) != null) {
+      return chain.proceed(originalRequest)
+    }
+
+    val observationId = UUID.randomUUID()
+    val startedAt = Date()
+    val startNanos = System.nanoTime()
+
+    val request = originalRequest.newBuilder()
+      .tag(AlreadyObservedMarker::class.java, AlreadyObservedMarker)
+      .build()
+
+    monitor.recordStart(NetworkRequestStarted(observationId, originalRequest.url.toString(), originalRequest.method, startedAt))
+
+    var response: Response? = null
+    var error: IOException? = null
+    var bodySignalingWrapper: BodyCloseSignal? = null
+    try {
+      val raw = chain.proceed(request)
+      // Wrap the response body purely for completion signaling — the wrapper doesn't count
+      // bytes (those come from `EventListener.responseBodyEnd`, which fires below `GzipSource`
+      // on the real network layer). It just lets us defer `finalizeAndRecord` until the caller
+      // drains the body, so the snapshot's byte counts are populated by the time we read them.
+      val wrapped = raw.body?.let { rawBody ->
+        BodyCloseSignal(rawBody) {
+          finalizeAndRecord(
+            observationId = observationId,
+            originalRequest = originalRequest,
+            response = raw,
+            call = chain.call(),
+            startedAt = startedAt,
+            startNanos = startNanos,
+            error = null
+          )
+        }
+      }
+      response = if (wrapped != null) {
+        raw.newBuilder().body(wrapped).build()
+      } else {
+        raw
+      }
+      bodySignalingWrapper = wrapped
+    } catch (e: IOException) {
+      error = e
+    }
+
+    // Two paths land here without a streaming body to wait on: an error before headers, and a
+    // response with no body (HEAD, 204, 304, ...). Both finalize the snapshot inline.
+    if (error != null || bodySignalingWrapper == null) {
+      finalizeAndRecord(
+        observationId = observationId,
+        originalRequest = originalRequest,
+        response = response,
+        call = chain.call(),
+        startedAt = startedAt,
+        startNanos = startNanos,
+        error = error
+      )
+    }
+
+    if (error != null) {
+      throw error
+    }
+    return response!!
+  }
+
+  private fun finalizeAndRecord(
+    observationId: UUID,
+    originalRequest: Request,
+    response: Response?,
+    call: Call,
+    startedAt: Date,
+    startNanos: Long,
+    error: IOException?
+  ) {
+    val endNanos = System.nanoTime()
+    val totalDuration = (endNanos - startNanos) / 1_000_000_000.0
+    val endDate = Date(startedAt.time + ((endNanos - startNanos) / 1_000_000L))
+
+    val phases = NetworkRequestEventListener.takeTimings(call)
+
+    val snapshot = buildSnapshot(
+      id = observationId,
+      originalRequest = originalRequest,
+      response = response,
+      phases = phases,
+      fallbackStart = startedAt,
+      fallbackEnd = endDate,
+      totalDuration = totalDuration,
+      error = error
+    )
+    monitor.record(snapshot)
+  }
+
+  companion object {
+    /** Shared interceptor backed by `NetworkRequestMonitor.shared`. App code adds this to its own
+     `OkHttpClient.Builder` if it wants those requests observed. */
+    val instance: NetworkRequestInterceptor by lazy {
+      NetworkRequestInterceptor(NetworkRequestMonitor.shared)
+    }
+
+    /** Test-only constructor that lets tests drive a dedicated monitor. */
+    internal fun forTesting(monitor: NetworkRequestMonitor): NetworkRequestInterceptor =
+      NetworkRequestInterceptor(monitor)
+  }
+}
+
+/**
+ * Builds a `NetworkRequest` snapshot from interceptor outputs. Pulled out so tests can exercise
+ * the field-population logic without spinning up a full OkHttp chain.
+ *
+ * Byte counts come from `EventListener.requestBodyEnd` / `responseBodyEnd` (carried on
+ * `phases.requestBodyBytes` / `responseBodyBytes`) — those fire on the network layer and
+ * report on-the-wire bytes (including chunked framing and gzip compression). The app-layer
+ * `originalRequest.body.contentLength()` and `response.body.contentLength()` are only used as
+ * a fallback when the listener didn't fire (no request body, response not consumed, errors
+ * before headers). Header bytes are an HTTP/1.1 framing estimate — see
+ * `requestHeaderByteCount` / `responseHeaderByteCount` for the caveats.
+ */
+internal fun buildSnapshot(
+  id: UUID,
+  originalRequest: Request,
+  response: Response?,
+  phases: NetworkRequestEventListener.PhaseTimings?,
+  fallbackStart: Date,
+  fallbackEnd: Date,
+  totalDuration: Double,
+  error: IOException?
+): NetworkRequest {
+  val redirects = response?.let { buildRedirectChain(it) } ?: emptyList()
+
+  val requestHeaderBytes = requestHeaderByteCount(originalRequest)
+  val responseHeaderBytes = response?.let { responseHeaderByteCount(it) } ?: 0L
+  // Prefer the on-the-wire body count reported by `EventListener.{request,response}BodyEnd` —
+  // those callbacks fire on the network layer (below `BridgeInterceptor` and `GzipSource`) so
+  // they're the truth. Fall back to declared `contentLength()` for callers that never streamed
+  // the body and zero otherwise. The `takeIf { it > 0 }` guards `contentLength()`'s sentinel
+  // `-1` for unknown sizes.
+  val requestBytesSent: Long? = if (response != null || error != null) {
+    val body = phases?.requestBodyBytes?.takeIf { it > 0 }
+      ?: originalRequest.body?.contentLength()?.takeIf { it > 0 }
+      ?: 0L
+    requestHeaderBytes + body
+  } else null
+  val responseBytesReceived: Long? = response?.let {
+    val body = phases?.responseBodyBytes?.takeIf { it > 0 }
+      ?: it.body?.contentLength()?.takeIf { it > 0 }
+      ?: 0L
+    responseHeaderBytes + body
+  }
+
+  val timings = NetworkRequest.Timings(
+    fetchStart = phases?.fetchStart ?: fallbackStart,
+    domainLookupStart = phases?.dnsStart,
+    domainLookupEnd = phases?.dnsEnd,
+    connectStart = phases?.connectStart,
+    connectEnd = phases?.connectEnd,
+    secureConnectionStart = phases?.secureConnectStart,
+    secureConnectionEnd = phases?.secureConnectEnd,
+    requestStart = phases?.requestHeadersStart ?: phases?.requestBodyStart,
+    requestEnd = phases?.requestBodyEnd ?: phases?.requestHeadersEnd,
+    responseStart = phases?.responseHeadersStart,
+    responseEnd = phases?.responseBodyEnd ?: phases?.responseHeadersEnd ?: fallbackEnd,
+    totalDuration = totalDuration
+  )
+
+  return NetworkRequest(
+    id = id,
+    url = originalRequest.url.toString(),
+    method = originalRequest.method,
+    statusCode = response?.code,
+    networkProtocol = response?.protocol?.toString(),
+    requestBytesSent = requestBytesSent,
+    responseBytesReceived = responseBytesReceived,
+    timings = timings,
+    errorDescription = error?.localizedMessage ?: error?.message,
+    redirects = redirects
+  )
+}
+
+/**
+ * Walks `Response.priorResponse()` chronologically and emits one `Redirect` per hop. The chain
+ * is naturally redirect-only — OkHttp doesn't surface intermediate protocol upgrades through
+ * `priorResponse` the way iOS exposes Alt-Svc upgrades through `transactionMetrics`, so no
+ * status-code filter is required.
+ */
+internal fun buildRedirectChain(final: Response): List<NetworkRequest.Redirect> {
+  // Collect tuples (priorResponse, nextResponseInChain) walking backwards, then reverse.
+  val reversed = mutableListOf<NetworkRequest.Redirect>()
+  var next: Response = final
+  var prior: Response? = final.priorResponse
+  while (prior != null) {
+    reversed.add(
+      NetworkRequest.Redirect(
+        fromUrl = prior.request.url.toString(),
+        toUrl = next.request.url.toString(),
+        statusCode = prior.code
+      )
+    )
+    next = prior
+    prior = prior.priorResponse
+  }
+  return reversed.reversed()
+}
+
+/**
+ * OkHttp `EventListener` that captures per-phase timestamps and stashes them in a process-wide
+ * map keyed by `Call`. `NetworkRequestInterceptor` reads (and removes) the entry when finalizing
+ * the snapshot.
+ *
+ * Use the factory rather than the bare class so each `Call` gets its own builder; OkHttp shares a
+ * single `EventListener` instance across calls otherwise and concurrent writes would race.
+ */
+class NetworkRequestEventListener : EventListener() {
+  private val builder = MutablePhaseTimings()
+
+  override fun callStart(call: Call) {
+    builder.fetchStart = Date()
+  }
+
+  override fun dnsStart(call: Call, domainName: String) {
+    builder.dnsStart = Date()
+  }
+
+  override fun dnsEnd(call: Call, domainName: String, inetAddressList: List<InetAddress>) {
+    builder.dnsEnd = Date()
+  }
+
+  override fun connectStart(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy) {
+    builder.connectStart = Date()
+  }
+
+  override fun secureConnectStart(call: Call) {
+    builder.secureConnectStart = Date()
+  }
+
+  override fun secureConnectEnd(call: Call, handshake: Handshake?) {
+    builder.secureConnectEnd = Date()
+  }
+
+  override fun connectEnd(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy, protocol: Protocol?) {
+    builder.connectEnd = Date()
+  }
+
+  override fun requestHeadersStart(call: Call) {
+    builder.requestHeadersStart = Date()
+  }
+
+  override fun requestHeadersEnd(call: Call, request: Request) {
+    builder.requestHeadersEnd = Date()
+  }
+
+  override fun requestBodyStart(call: Call) {
+    builder.requestBodyStart = Date()
+  }
+
+  override fun requestBodyEnd(call: Call, byteCount: Long) {
+    builder.requestBodyEnd = Date()
+    builder.requestBodyBytes = byteCount
+  }
+
+  override fun responseHeadersStart(call: Call) {
+    builder.responseHeadersStart = Date()
+  }
+
+  override fun responseHeadersEnd(call: Call, response: Response) {
+    builder.responseHeadersEnd = Date()
+  }
+
+  override fun responseBodyEnd(call: Call, byteCount: Long) {
+    builder.responseBodyEnd = Date()
+    builder.responseBodyBytes = byteCount
+  }
+
+  override fun callEnd(call: Call) {
+    publish(call)
+  }
+
+  override fun callFailed(call: Call, ioe: IOException) {
+    publish(call)
+  }
+
+  override fun canceled(call: Call) {
+    publish(call)
+  }
+
+  private fun publish(call: Call) {
+    synchronized(inFlightTimings) {
+      inFlightTimings[call] = builder.snapshot()
+    }
+  }
+
+  /**
+   * Mutable per-phase scratch space the listener writes into as the call progresses. A separate
+   * type from `PhaseTimings` so the published value (read by the interceptor) is immutable.
+   */
+  internal class MutablePhaseTimings(
+    @Volatile var fetchStart: Date? = null,
+    @Volatile var dnsStart: Date? = null,
+    @Volatile var dnsEnd: Date? = null,
+    @Volatile var connectStart: Date? = null,
+    @Volatile var connectEnd: Date? = null,
+    @Volatile var secureConnectStart: Date? = null,
+    @Volatile var secureConnectEnd: Date? = null,
+    @Volatile var requestHeadersStart: Date? = null,
+    @Volatile var requestHeadersEnd: Date? = null,
+    @Volatile var requestBodyStart: Date? = null,
+    @Volatile var requestBodyEnd: Date? = null,
+    @Volatile var responseHeadersStart: Date? = null,
+    @Volatile var responseHeadersEnd: Date? = null,
+    @Volatile var responseBodyEnd: Date? = null,
+    @Volatile var requestBodyBytes: Long? = null,
+    @Volatile var responseBodyBytes: Long? = null
+  ) {
+    fun snapshot() = PhaseTimings(
+      fetchStart, dnsStart, dnsEnd,
+      connectStart, connectEnd,
+      secureConnectStart, secureConnectEnd,
+      requestHeadersStart, requestHeadersEnd,
+      requestBodyStart, requestBodyEnd,
+      responseHeadersStart, responseHeadersEnd,
+      responseBodyEnd,
+      requestBodyBytes, responseBodyBytes
+    )
+  }
+
+  /**
+   * Per-phase wire timestamps captured from OkHttp's `EventListener` callbacks. The interceptor
+   * folds these into the broader `NetworkRequest.Timings` at finalize time; the latter is the
+   * iOS-mirrored snapshot shape and the only one JS ever sees.
+   *
+   * `requestBodyBytes` and `responseBodyBytes` come from `EventListener.requestBodyEnd` /
+   * `responseBodyEnd`, which fire on the *network* layer — below `BridgeInterceptor` and
+   * `GzipSource`. They report the bytes actually on the wire, not the (gunzipped, app-layer)
+   * view that the interceptor sees. `null` means the corresponding body-end callback never
+   * fired (no request body / response not fully consumed / error before headers).
+   */
+  data class PhaseTimings(
+    val fetchStart: Date?,
+    val dnsStart: Date?,
+    val dnsEnd: Date?,
+    val connectStart: Date?,
+    val connectEnd: Date?,
+    val secureConnectStart: Date?,
+    val secureConnectEnd: Date?,
+    val requestHeadersStart: Date?,
+    val requestHeadersEnd: Date?,
+    val requestBodyStart: Date?,
+    val requestBodyEnd: Date?,
+    val responseHeadersStart: Date?,
+    val responseHeadersEnd: Date?,
+    val responseBodyEnd: Date?,
+    val requestBodyBytes: Long?,
+    val responseBodyBytes: Long?
+  )
+
+  companion object {
+    /**
+     * Process-wide map of in-flight call timings. Lifecycle: the listener writes one entry per
+     * call when the call ends, the interceptor reads + removes when it builds the snapshot.
+     *
+     * Keyed weakly on `Call` so any entry the interceptor never takes is reclaimed once the `Call`
+     * is collected, rather than pinned forever. That covers the paths where `finalizeAndRecord`
+     * doesn't run for a call the listener still reported on: the recursion / double-instrumentation
+     * guards that short-circuit to `chain.proceed(...)` without recording, and responses whose body
+     * the caller never drains or closes. `Call` doesn't override `equals`/`hashCode`, so the map
+     * keys on identity as intended.
+     *
+     * `WeakHashMap` isn't thread-safe and OkHttp drives the listener from a pool of dispatcher
+     * threads, so every access goes through `synchronized`.
+     */
+    private val inFlightTimings = WeakHashMap<Call, PhaseTimings>()
+
+    /** Removes and returns the timings for `call`, or `null` if none were recorded. */
+    internal fun takeTimings(call: Call): PhaseTimings? = synchronized(inFlightTimings) {
+      inFlightTimings.remove(call)
+    }
+
+    /** Factory that installs a fresh listener per call. Wire to `OkHttpClient.Builder.eventListenerFactory(...)`. */
+    val factory: EventListener.Factory = EventListener.Factory { NetworkRequestEventListener() }
+  }
+}
+
+/**
+ * Wraps the response body to signal when the caller finishes draining it. Doesn't count bytes
+ * — those come from `EventListener.responseBodyEnd` (the network layer, below `GzipSource`),
+ * which fires before the caller's close/EOF on the app layer. This wrapper exists purely so
+ * the interceptor can defer `finalizeAndRecord` until the byte counters on `PhaseTimings` are
+ * stable.
+ */
+private class BodyCloseSignal(
+  private val delegate: ResponseBody,
+  private val onComplete: () -> Unit
+) : ResponseBody() {
+  @Volatile
+  private var completed: Boolean = false
+
+  // OkHttp's contract returns the same `BufferedSource` on repeated `source()` calls, so we
+  // cache ours too — wrapping twice would fire the completion callback twice.
+  private val signalingSource: BufferedSource by lazy {
+    object : ForwardingSource(delegate.source()) {
+      override fun read(sink: Buffer, byteCount: Long): Long {
+        val read = super.read(sink, byteCount)
+        if (read == -1L) {
+          // Body fully drained — fire the completion callback exactly once. Callers that close
+          // the stream without reaching EOF still trigger completion via the `close()` override.
+          fireCompleteOnce()
+        }
+        return read
+      }
+
+      override fun close() {
+        fireCompleteOnce()
+        super.close()
+      }
+    }.buffer()
+  }
+
+  override fun contentType(): MediaType? = delegate.contentType()
+  override fun contentLength(): Long = delegate.contentLength()
+  override fun source(): BufferedSource = signalingSource
+
+  private fun fireCompleteOnce() {
+    if (completed) {
+      return
+    }
+    completed = true
+    onComplete()
+  }
+}
+
+/**
+ * Approximates the number of bytes the request headers occupy on the wire - the HTTP/1.1 request
+ * line (`METHOD path HTTP/1.1\r\n`) plus the serialized header block (`Name: Value\r\n` per
+ * header and the trailing CRLF that terminates the block).
+ *
+ * iOS gets exact numbers from `URLSessionTaskTransactionMetrics.countOfRequestHeaderBytesSent`.
+ * Android has no equivalent — `EventListener.requestHeadersEnd` carries a `Request` object, but
+ * it's the application-layer view (the one our interceptor receives), not the post-
+ * `BridgeInterceptor` request that's actually sent. Headers OkHttp adds below us
+ * (`Host`, `Accept-Encoding`, `User-Agent`, `Connection`, `Content-Length`) are missing from
+ * this count, so we undercount by roughly 80–150 bytes per request on HTTP/1.1.
+ *
+ * HTTP/2 and HTTP/3 use HPACK/QPACK header compression and a binary framing layer; on those
+ * protocols the comparison to "wire bytes" is fundamentally fuzzy regardless. We accept the
+ * imprecision rather than reach into OkHttp internals.
+ */
+private fun requestHeaderByteCount(request: Request): Long {
+  // "METHOD " + encodedPathQuery + " HTTP/1.1\r\n"
+  val pathLength = request.url.encodedPath.length +
+    (request.url.encodedQuery?.let { it.length + 1 } ?: 0)
+  val requestLine = request.method.length + 1 + pathLength + 1 + "HTTP/1.1".length + 2
+  return requestLine + serializedHeaderBytes(request.headers)
+}
+
+/**
+ * Same approximation as `requestHeaderByteCount` but for the response side: the status line
+ * (`HTTP/1.1 STATUSCODE REASON\r\n`) plus the serialized header block.
+ */
+private fun responseHeaderByteCount(response: Response): Long {
+  val statusLine = response.protocol.toString().length + 1 +
+    response.code.toString().length + 1 +
+    response.message.length + 2
+  return statusLine + serializedHeaderBytes(response.headers)
+}
+
+/**
+ * Serialized size of an HTTP/1.1 header block: `Name: Value\r\n` per header plus the trailing
+ * `\r\n` that terminates the block. OkHttp 4.10+ ships `Headers.byteCount()` natively; we
+ * implement it ourselves because we're pinned to 4.9.2 (matches RN's pin).
+ */
+private fun serializedHeaderBytes(headers: Headers): Long {
+  var total = 2L // trailing CRLF terminating the header block
+  for (i in 0 until headers.size) {
+    total += headers.name(i).length + 2 + headers.value(i).length + 2
+  }
+  return total
+}
+
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestMonitor.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestMonitor.kt
new file mode 100644
index 00000000000000..750357eb2f3f1b
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestMonitor.kt
@@ -0,0 +1,105 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+package expo.modules.appmetrics.networkrequests
+
+import java.lang.ref.WeakReference
+import java.util.Date
+
+/**
+ * Receives notifications about HTTP requests observed by `NetworkRequestInterceptor`. Both
+ * methods default to no-ops so delegates can opt into either start- or complete-time
+ * notifications without implementing the other.
+ */
+interface NetworkRequestObserverDelegate {
+  fun onNetworkRequestStarted(request: NetworkRequestStarted) {}
+  fun onNetworkRequestCompleted(request: NetworkRequest) {}
+}
+
+/**
+ * Aggregates `NetworkRequest` snapshots delivered by the OkHttp interceptor and fans them out to
+ * registered delegates. Mirrors the iOS `NetworkRequestMonitor`.
+ *
+ * The interceptor runs on OkHttp's dispatcher threads; delegates may be added/removed from any
+ * thread (JS-facing observers come from the React thread, the singleton is reachable from app
+ * code). All shared state is guarded by a single intrinsic lock - the work inside is small and
+ * synchronous, so contention is negligible.
+ */
+class NetworkRequestMonitor internal constructor() {
+  /** Maximum number of completed requests retained for debug surfaces. */
+  private val recentCapacity = 200
+
+  private val lock = Any()
+  private val recentRequests = ArrayDeque<NetworkRequest>()
+  private val delegates = mutableListOf<WeakReference<NetworkRequestObserverDelegate>>()
+
+  /**
+   * Most recently observed completed requests, oldest first. Bounded by `recentCapacity`.
+   * Intended for debug surfaces and the TTI summary; not for the dispatch path.
+   */
+  val recent: List<NetworkRequest>
+    get() = synchronized(lock) { recentRequests.toList() }
+
+  /**
+   * Folds the requests whose `timings.fetchStart` falls within `[start, end]` into a summary.
+   * Used by the TTI metric to attach a per-launch network rollup. Bounded by the ring buffer:
+   * under heavy network load the earliest requests in the window may have been evicted, in which
+   * case the summary undercounts - acceptable for a TTI-attached signal.
+   */
+  fun summarize(start: Date, end: Date): NetworkRequestSummary {
+    val inWindow = synchronized(lock) {
+      recentRequests.filter { request ->
+        val fetchStart = request.timings.fetchStart ?: return@filter false
+        !fetchStart.before(start) && !fetchStart.after(end)
+      }
+    }
+    return NetworkRequestSummary.from(inWindow)
+  }
+
+  /** Adds a delegate. Held weakly - drop the reference to unsubscribe. */
+  fun addDelegate(delegate: NetworkRequestObserverDelegate) = synchronized(lock) {
+    delegates.removeAll { it.get() == null }
+    delegates.add(WeakReference(delegate))
+  }
+
+  fun removeDelegate(delegate: NetworkRequestObserverDelegate) = synchronized(lock) {
+    delegates.removeAll {
+      val strongRef = it.get()
+      strongRef === delegate || strongRef == null
+    }
+  }
+
+  /** Records a completed request: appends to the ring buffer and fans out. */
+  fun record(request: NetworkRequest) {
+    val snapshot = synchronized(lock) {
+      recentRequests.addLast(request)
+      while (recentRequests.size > recentCapacity) {
+        recentRequests.removeFirst()
+      }
+      delegates.removeAll { it.get() == null }
+      delegates.mapNotNull { it.get() }
+    }
+    for (delegate in snapshot) {
+      delegate.onNetworkRequestCompleted(request)
+    }
+  }
+
+  /**
+   * Records that a request has begun. No ring-buffer entry - the started snapshot is purely a
+   * notification used to surface in-flight state to subscribers. The corresponding completion
+   * event will arrive later with a matching `id`.
+   */
+  fun recordStart(request: NetworkRequestStarted) {
+    val snapshot = synchronized(lock) {
+      delegates.removeAll { it.get() == null }
+      delegates.mapNotNull { it.get() }
+    }
+    for (delegate in snapshot) {
+      delegate.onNetworkRequestStarted(request)
+    }
+  }
+
+  companion object {
+    /** Process-wide singleton mirroring `NetworkRequestMonitor.shared` on iOS. */
+    val shared: NetworkRequestMonitor = NetworkRequestMonitor()
+  }
+}
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestObserver.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestObserver.kt
new file mode 100644
index 00000000000000..c0391aa0dc704b
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestObserver.kt
@@ -0,0 +1,77 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+package expo.modules.appmetrics.networkrequests
+
+import expo.modules.appmetrics.utils.TimeUtils
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.sharedobjects.SharedObject
+
+/** Event names emitted by `NetworkRequestObserver`, matching the keys in the JS `NetworkRequestObserverEvents` type. */
+internal const val REQUEST_STARTED_EVENT = "requestStarted"
+internal const val REQUEST_COMPLETED_EVENT = "requestCompleted"
+
+/**
+ * JS-facing `SharedObject` that bridges per-instance JS subscriptions to the singleton
+ * `NetworkRequestMonitor`. Each JS `new NetworkRequestObserver()` allocates one of these and
+ * registers it as a delegate; the native instance is released when JS drops the reference, at
+ * which point `sharedObjectDidRelease` removes the delegate registration.
+ *
+ * The class only forwards events — it doesn't store request history. Use
+ * `NetworkRequestMonitor.shared.recent` for that.
+ */
+class NetworkRequestObserver(appContext: AppContext) :
+  SharedObject(appContext),
+  NetworkRequestObserverDelegate {
+
+  init {
+    NetworkRequestMonitor.shared.addDelegate(this)
+  }
+
+  override fun sharedObjectDidRelease() {
+    NetworkRequestMonitor.shared.removeDelegate(this)
+    super.sharedObjectDidRelease()
+  }
+
+  override fun onNetworkRequestStarted(request: NetworkRequestStarted) {
+    emit(REQUEST_STARTED_EVENT, startedPayload(request))
+  }
+
+  override fun onNetworkRequestCompleted(request: NetworkRequest) {
+    emit(REQUEST_COMPLETED_EVENT, completedPayload(request))
+  }
+
+  companion object {
+    /**
+     * Internal so tests can assert the payload shape without going through `emit`, which needs a
+     * live JS runtime. The keys here are part of the public JS contract — additions are safe but
+     * renames are breaking.
+     */
+    internal fun startedPayload(request: NetworkRequestStarted): Map<String, Any?> = mapOf(
+      "id" to request.id.toString(),
+      "url" to request.url,
+      "method" to request.method,
+      "startedAt" to TimeUtils.dateToIsoUtcSeconds(request.startedAt)
+    )
+
+    internal fun completedPayload(request: NetworkRequest): Map<String, Any?> = mapOf(
+      "id" to request.id.toString(),
+      "url" to request.url,
+      "method" to request.method,
+      "statusCode" to request.statusCode,
+      "networkProtocol" to request.networkProtocol,
+      "requestBytesSent" to request.requestBytesSent,
+      "responseBytesReceived" to request.responseBytesReceived,
+      "errorDescription" to request.errorDescription,
+      "startedAt" to request.timings.fetchStart?.let { TimeUtils.dateToIsoUtcSeconds(it) },
+      "completedAt" to request.timings.responseEnd?.let { TimeUtils.dateToIsoUtcSeconds(it) },
+      "totalDuration" to request.timings.totalDuration,
+      "redirects" to request.redirects.map { redirect ->
+        mapOf(
+          "fromUrl" to redirect.fromUrl,
+          "toUrl" to redirect.toUrl,
+          "statusCode" to redirect.statusCode
+        )
+      }
+    )
+  }
+}
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestSummary.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestSummary.kt
new file mode 100644
index 00000000000000..42f0249b1df146
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/NetworkRequestSummary.kt
@@ -0,0 +1,104 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+package expo.modules.appmetrics.networkrequests
+
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+
+/**
+ * Aggregate over a set of `NetworkRequest` snapshots. Designed to be flattened into a metric's
+ * `params` map, so all fields are simple value types.
+ *
+ * The summary is intentionally small. Anything that would explode cardinality (per-URL p95s, full
+ * request lists) belongs in a separate metric/table once we ship one - not on the TTI envelope.
+ */
+data class NetworkRequestSummary(
+  /** Number of requests in the window. */
+  val count: Int,
+
+  /** Requests that errored or returned a non-2xx status. */
+  val failed: Int,
+
+  /** Sum of `responseBytesReceived` across all requests. */
+  val bytesReceived: Long,
+
+  /** Sum of `requestBytesSent` across all requests. */
+  val bytesSent: Long,
+
+  /** Sum of `timings.totalDuration` across all requests, in seconds. Can exceed wall-clock when requests overlap. */
+  val totalDuration: Double,
+
+  /** Longest single request duration in seconds, or `null` if `count == 0`. */
+  val slowestDuration: Double?,
+
+  /** Host of the slowest request, or `null` if the URL had no resolvable host. */
+  val slowestHost: String?
+) {
+  val isEmpty: Boolean
+    get() = count == 0
+
+  companion object {
+    val empty = NetworkRequestSummary(
+      count = 0,
+      failed = 0,
+      bytesReceived = 0,
+      bytesSent = 0,
+      totalDuration = 0.0,
+      slowestDuration = null,
+      slowestHost = null
+    )
+
+    /**
+     * Folds a list of `NetworkRequest` into a summary. The caller is responsible for filtering
+     * the list to the desired window.
+     */
+    fun from(requests: List<NetworkRequest>): NetworkRequestSummary {
+      if (requests.isEmpty()) {
+        return empty
+      }
+      var failed = 0
+      var bytesReceived = 0L
+      var bytesSent = 0L
+      var totalDuration = 0.0
+      var slowest: NetworkRequest? = null
+
+      for (request in requests) {
+        if (request.isFailed) {
+          failed += 1
+        }
+        bytesReceived += request.responseBytesReceived ?: 0
+        bytesSent += request.requestBytesSent ?: 0
+        totalDuration += request.timings.totalDuration
+        val current = slowest
+        if (current == null || request.timings.totalDuration > current.timings.totalDuration) {
+          slowest = request
+        }
+      }
+
+      return NetworkRequestSummary(
+        count = requests.size,
+        failed = failed,
+        bytesReceived = bytesReceived,
+        bytesSent = bytesSent,
+        totalDuration = totalDuration,
+        slowestDuration = slowest?.timings?.totalDuration,
+        slowestHost = slowest?.url?.toHttpUrlOrNull()?.host
+      )
+    }
+  }
+}
+
+/**
+ * A request is treated as failed if it errored, or returned a 4xx (client error) or 5xx (server
+ * error) status. 1xx (informational), 2xx (success), and 3xx (redirection — usually followed
+ * transparently by OkHttp, but the unfollowed case is still a successful response from the
+ * origin's perspective) are not failures. A missing status code (the request failed before
+ * headers arrived) counts as failed.
+ */
+internal val NetworkRequest.isFailed: Boolean
+  get() {
+    if (errorDescription != null) {
+      return true
+    }
+    val code = statusCode ?: return true
+    return code >= 400
+  }
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/OkHttpClientProviderHook.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/OkHttpClientProviderHook.kt
new file mode 100644
index 00000000000000..9c9640c177ea92
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/networkrequests/OkHttpClientProviderHook.kt
@@ -0,0 +1,64 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+package expo.modules.appmetrics.networkrequests
+
+import android.util.Log
+import com.facebook.react.modules.network.OkHttpClientFactory
+import com.facebook.react.modules.network.OkHttpClientProvider
+import expo.modules.appmetrics.TAG
+
+/**
+ * Installs `NetworkRequestInterceptor` into React Native's networking client so RN's `fetch` and
+ * `XMLHttpRequest` flow through it automatically. App-owned `OkHttpClient` instances need a
+ * one-line manual `addInterceptor(NetworkRequestInterceptor.instance)` to opt in.
+ *
+ * **Install timing.** `OkHttpClientProvider.getOkHttpClient()` lazily caches its client on first
+ * use. The factory we set here is only consulted on that first creation; if RN's networking layer
+ * (or another package) already triggered creation before this hook runs, we miss everything that
+ * client touches. We can't fix that without bytecode rewriting - Datadog hit the same constraint
+ * in production (DataDog/dd-sdk-android#513). We log a warning if we detect we landed too late
+ * so engineers see it in logcat; the workaround is to install another hook earlier.
+ */
+object OkHttpClientProviderHook {
+  @Volatile
+  private var installed = false
+
+  fun installIfNeeded() {
+    if (installed) {
+      return
+    }
+    installed = true
+
+    if (isClientAlreadyCached()) {
+      Log.w(
+        TAG,
+        "OkHttpClientProvider.client was already created before expo-app-metrics could install its" +
+          " factory. Network requests that went through the existing client won't be observed." +
+          " Either move expo-app-metrics earlier in your initialization or add" +
+          " NetworkRequestInterceptor.instance to your custom OkHttp client manually."
+      )
+    }
+
+    OkHttpClientProvider.setOkHttpClientFactory(object : OkHttpClientFactory {
+      override fun createNewNetworkModuleClient() =
+        OkHttpClientProvider.createClientBuilder()
+          .addInterceptor(NetworkRequestInterceptor.instance)
+          .eventListenerFactory(NetworkRequestEventListener.factory)
+          .build()
+    })
+  }
+
+  /**
+   * `OkHttpClientProvider.client` is `internal`, so we reach it via reflection. Failures are
+   * benign - if the field is no longer present or the access is denied, we assume the client
+   * hasn't been cached and skip the warning. Worst case the warning is silent in a future RN
+   * version; the factory installation itself is unaffected.
+   */
+  private fun isClientAlreadyCached(): Boolean = try {
+    val providerClass = OkHttpClientProvider::class.java
+    val field = providerClass.getDeclaredField("client").apply { isAccessible = true }
+    field.get(OkHttpClientProvider) != null
+  } catch (_: Throwable) {
+    false
+  }
+}
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/MetricsDatabase.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/MetricsDatabase.kt
index dfefda8b558151..4ce81dc26d4b12 100644
--- a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/MetricsDatabase.kt
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/MetricsDatabase.kt
@@ -230,8 +230,8 @@ interface SessionDao {
   suspend fun deleteAll()
 
   @Transaction
-  @Query("SELECT * FROM sessions")
-  suspend fun getAll(): List<SessionWithMetrics>
+  @Query("SELECT * FROM sessions WHERE isActive = 0 ORDER BY startTimestamp DESC")
+  suspend fun getInactive(): List<SessionWithMetrics>
 
   @Transaction
   @Query("SELECT * FROM sessions WHERE id = :id")
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/SessionManager.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/SessionManager.kt
index 7fad1cf46f0682..c02b0c40cd2b83 100644
--- a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/SessionManager.kt
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/storage/SessionManager.kt
@@ -113,7 +113,7 @@ class SessionManager(
     }
   }
 
-  suspend fun getAllSessions(): List<SessionWithMetrics> = database.sessionDao().getAll()
+  suspend fun getInactiveSessions(): List<SessionWithMetrics> = database.sessionDao().getInactive()
 
   suspend fun getSessionById(id: String): SessionWithMetrics? = database.sessionDao().getSessionWithMetricsBySessionId(id)
 
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/MetricParamsBuilder.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/MetricParamsBuilder.kt
index 014447a4b86f31..f0dfdec57d65e0 100644
--- a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/MetricParamsBuilder.kt
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/MetricParamsBuilder.kt
@@ -1,6 +1,7 @@
 package expo.modules.appmetrics.utils
 
 import expo.modules.appmetrics.frames.FrameMetricsRecord
+import expo.modules.appmetrics.networkrequests.NetworkRequestSummary
 
 /**
  * Single source of truth for the `expo.*` keys we attach to metrics. Takes
@@ -16,7 +17,8 @@ object MetricParamsBuilder {
     userParams: Map<String, Any>? = null,
     frameMetrics: FrameMetricsRecord? = null,
     deviceState: DeviceState? = null,
-    networkState: NetworkState? = null
+    networkState: NetworkState? = null,
+    networkRequests: NetworkRequestSummary? = null
   ): Map<String, Any> {
     val params = mutableMapOf<String, Any>()
     userParams?.let { params.putAll(it) }
@@ -35,6 +37,15 @@ object MetricParamsBuilder {
       params["expo.network.connected"] = networkState.connected
       params["expo.network.type"] = networkTransportString(networkState.transport)
     }
+    if (networkRequests != null && !networkRequests.isEmpty) {
+      params["expo.network.requests.count"] = networkRequests.count
+      params["expo.network.requests.failed"] = networkRequests.failed
+      params["expo.network.requests.bytesReceived"] = networkRequests.bytesReceived
+      params["expo.network.requests.bytesSent"] = networkRequests.bytesSent
+      params["expo.network.requests.totalDuration"] = networkRequests.totalDuration
+      networkRequests.slowestDuration?.let { params["expo.network.requests.slowestDuration"] = it }
+      networkRequests.slowestHost?.let { params["expo.network.requests.slowestHost"] = it }
+    }
     return params
   }
 
diff --git a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/TimeUtils.kt b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/TimeUtils.kt
index 7369ca8807dc81..d94c9b95eaebb2 100644
--- a/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/TimeUtils.kt
+++ b/packages/expo-app-metrics/android/src/main/java/expo/modules/appmetrics/utils/TimeUtils.kt
@@ -43,4 +43,21 @@ object TimeUtils {
   private fun dateToTimestamp(date: Date): String {
     return sdf().format(date)
   }
+
+  /**
+   * Formats `date` as `yyyy-MM-ddTHH:mm:ssZ` in UTC — whole-second precision, matching iOS's
+   * `Date.ISO8601Format()` with the default `internetDateTime` options. Used by callers that
+   * need the JS wire format to read identically on both platforms; the millisecond-precision
+   * `dateToTimestamp` is reserved for internal telemetry timestamps where sub-second matters.
+   */
+  fun dateToIsoUtcSeconds(date: Date): String = secondsFormatter.get()!!.format(date)
+
+  // `SimpleDateFormat` isn't thread-safe; we stash one per thread. `java.time.DateTimeFormatter`
+  // would be cleaner but requires API 26+ without core-library desugaring (we avoid both, see
+  // `sdf()` below for the matching choice).
+  private val secondsFormatter = ThreadLocal.withInitial {
+    SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US).apply {
+      timeZone = TimeZone.getTimeZone("UTC")
+    }
+  }
 }
diff --git a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestInterceptorTest.kt b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestInterceptorTest.kt
new file mode 100644
index 00000000000000..2faefbc3562008
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestInterceptorTest.kt
@@ -0,0 +1,234 @@
+package expo.modules.appmetrics.networkrequests
+
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import java.io.IOException
+
+/**
+ * End-to-end interceptor tests driven through OkHttp's `MockWebServer`. Each test installs a
+ * dedicated `NetworkRequestMonitor` (via `NetworkRequestInterceptor.forTesting`) so assertions
+ * aren't polluted by the process-wide singleton.
+ */
+class NetworkRequestInterceptorTest {
+  private lateinit var server: MockWebServer
+  private lateinit var monitor: NetworkRequestMonitor
+  private lateinit var client: OkHttpClient
+
+  @Before
+  fun setUp() {
+    server = MockWebServer().apply { start() }
+    monitor = NetworkRequestMonitor()
+    client = OkHttpClient.Builder()
+      .addInterceptor(NetworkRequestInterceptor.forTesting(monitor))
+      .eventListenerFactory(NetworkRequestEventListener.factory)
+      .build()
+  }
+
+  @After
+  fun tearDown() {
+    server.shutdown()
+  }
+
+  @Test
+  fun `records a successful response`() {
+    server.enqueue(MockResponse().setResponseCode(200).setBody("hello"))
+
+    val response = client.newCall(Request.Builder().url(server.url("/hello")).build()).execute()
+    val body = response.body!!.string()
+    response.close()
+
+    assertEquals("hello", body)
+    assertEquals(1, monitor.recent.size)
+    val snapshot = monitor.recent.first()
+    assertEquals(200, snapshot.statusCode)
+    assertEquals("GET", snapshot.method)
+    assertNull(snapshot.errorDescription)
+    assertTrue(snapshot.redirects.isEmpty())
+  }
+
+  @Test
+  fun `records a non-2xx response without throwing`() {
+    server.enqueue(MockResponse().setResponseCode(500).setBody("oops"))
+
+    val response = client.newCall(Request.Builder().url(server.url("/fail")).build()).execute()
+    response.close()
+
+    assertEquals(1, monitor.recent.size)
+    assertEquals(500, monitor.recent.first().statusCode)
+    // The summary's isFailed predicate flips for non-2xx so the TTI rollup counts it.
+    assertEquals(1, NetworkRequestSummary.from(monitor.recent).failed)
+  }
+
+  @Test
+  fun `records an error description when the request throws`() {
+    // Shut the server down before issuing the request to provoke an IOException at connect time.
+    val deadUrl = server.url("/dead")
+    server.shutdown()
+
+    var thrown = false
+    try {
+      client.newCall(Request.Builder().url(deadUrl).build()).execute()
+    } catch (_: IOException) {
+      thrown = true
+    }
+    assertTrue("the network call should throw", thrown)
+    assertEquals(1, monitor.recent.size)
+    val snapshot = monitor.recent.first()
+    assertNull(snapshot.statusCode)
+    assertNotNull(snapshot.errorDescription)
+
+    // Re-create the server so the @After teardown's shutdown call doesn't trip on a closed socket.
+    server = MockWebServer().apply { start() }
+  }
+
+  @Test
+  fun `reconstructs a redirect chain in chronological order`() {
+    server.enqueue(MockResponse().setResponseCode(302).setHeader("Location", "/b"))
+    server.enqueue(MockResponse().setResponseCode(301).setHeader("Location", "/c"))
+    server.enqueue(MockResponse().setResponseCode(200).setBody("final"))
+
+    val response = client.newCall(Request.Builder().url(server.url("/a")).build()).execute()
+    response.close()
+
+    assertEquals(1, monitor.recent.size)
+    val redirects = monitor.recent.first().redirects
+    assertEquals(2, redirects.size)
+    // First hop: /a returned 302 pointing at /b.
+    assertTrue(redirects[0].fromUrl.endsWith("/a"))
+    assertTrue(redirects[0].toUrl.endsWith("/b"))
+    assertEquals(302, redirects[0].statusCode)
+    // Second hop: /b returned 301 pointing at /c.
+    assertTrue(redirects[1].fromUrl.endsWith("/b"))
+    assertTrue(redirects[1].toUrl.endsWith("/c"))
+    assertEquals(301, redirects[1].statusCode)
+  }
+
+  @Test
+  fun `records request bytes that include the body payload`() {
+    server.enqueue(MockResponse().setResponseCode(200))
+
+    val payload = "{\"hello\":\"world\"}"
+    val request = Request.Builder()
+      .url(server.url("/echo"))
+      .post(payload.toRequestBody())
+      .build()
+    val response = client.newCall(request).execute()
+    response.close()
+
+    val snapshot = monitor.recent.first()
+    // Wire bytes sent = headers + body. Headers vary by OkHttp version, so assert via the
+    // weaker invariant: it's at least the body length plus *some* header overhead.
+    val sent = snapshot.requestBytesSent!!
+    assertTrue("expected at least payload bytes, got $sent", sent >= payload.length)
+  }
+
+  @Test
+  fun `records response bytes that include the body length`() {
+    val body = "x".repeat(1024)
+    server.enqueue(MockResponse().setResponseCode(200).setBody(body))
+
+    val response = client.newCall(Request.Builder().url(server.url("/big")).build()).execute()
+    response.body!!.string()
+    response.close()
+
+    val snapshot = monitor.recent.first()
+    val received = snapshot.responseBytesReceived!!
+    assertTrue("expected at least body length, got $received", received >= body.length)
+  }
+
+  @Test
+  fun `internal opt-out header skips observation and is stripped from the outgoing request`() {
+    server.enqueue(MockResponse().setResponseCode(200))
+
+    val request = Request.Builder()
+      .url(server.url("/internal"))
+      .addHeader(INTERNAL_HEADER_NAME, "1")
+      .build()
+    client.newCall(request).execute().close()
+
+    assertTrue("internal requests must not land in the monitor", monitor.recent.isEmpty())
+    // The server should have received the request *without* our internal header.
+    val recorded = server.takeRequest()
+    assertNull(recorded.getHeader(INTERNAL_HEADER_NAME))
+  }
+
+  @Test
+  fun `does not re-observe when chain already carries the marker`() {
+    server.enqueue(MockResponse().setResponseCode(200))
+    server.enqueue(MockResponse().setResponseCode(200))
+
+    // Install two interceptors on the same monitor, simulating an app that adds our public
+    // interceptor on top of a client we already factory-injected. The second pass must
+    // short-circuit.
+    val doubleClient = OkHttpClient.Builder()
+      .addInterceptor(NetworkRequestInterceptor.forTesting(monitor))
+      .addInterceptor(NetworkRequestInterceptor.forTesting(monitor))
+      .build()
+
+    doubleClient.newCall(Request.Builder().url(server.url("/once")).build()).execute().close()
+    assertEquals(1, monitor.recent.size)
+  }
+
+  @Test
+  fun `delegate receives both started and completed events with matching ids`() {
+    server.enqueue(MockResponse().setResponseCode(200).setBody("ok"))
+
+    val collector = CollectingDelegate()
+    monitor.addDelegate(collector)
+
+    val response = client.newCall(Request.Builder().url(server.url("/end-to-end")).build()).execute()
+    response.body!!.string()
+    response.close()
+
+    // Started fires from the interceptor before the network call; completed fires after the
+    // response body closes. Both should reach the delegate.
+    assertEquals(1, collector.started.size)
+    assertEquals(1, collector.completed.size)
+    // The ids match — that's the contract JS code uses to correlate the two events.
+    assertEquals(collector.started.first().id, collector.completed.first().id)
+    assertEquals("GET", collector.started.first().method)
+    assertEquals(200, collector.completed.first().statusCode)
+  }
+
+  @Test
+  fun `body must be closed before the completed event fires`() {
+    server.enqueue(MockResponse().setResponseCode(200).setBody("hello"))
+
+    val collector = CollectingDelegate()
+    monitor.addDelegate(collector)
+
+    val response = client.newCall(Request.Builder().url(server.url("/lazy")).build()).execute()
+    // The started event has fired, but the completed event must wait for the response body to be
+    // drained or closed — until then the byte counters on the counting wrapper are still moving.
+    assertEquals(1, collector.started.size)
+    assertEquals(0, collector.completed.size)
+
+    response.body!!.string()
+    response.close()
+
+    assertEquals(1, collector.completed.size)
+  }
+
+  private class CollectingDelegate : NetworkRequestObserverDelegate {
+    val completed = mutableListOf<NetworkRequest>()
+    val started = mutableListOf<NetworkRequestStarted>()
+
+    override fun onNetworkRequestStarted(request: NetworkRequestStarted) {
+      started.add(request)
+    }
+
+    override fun onNetworkRequestCompleted(request: NetworkRequest) {
+      completed.add(request)
+    }
+  }
+}
diff --git a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestMonitorTest.kt b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestMonitorTest.kt
new file mode 100644
index 00000000000000..4d783144f8801f
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestMonitorTest.kt
@@ -0,0 +1,112 @@
+package expo.modules.appmetrics.networkrequests
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.util.Date
+import java.util.UUID
+
+class NetworkRequestMonitorTest {
+  @Test
+  fun `records snapshots and fans out to delegates`() {
+    val monitor = NetworkRequestMonitor()
+    val collector = CollectingDelegate()
+    monitor.addDelegate(collector)
+
+    val snapshot = makeRequest()
+    monitor.record(snapshot)
+
+    assertEquals(1, monitor.recent.size)
+    assertEquals(snapshot.id, monitor.recent.first().id)
+    assertEquals(1, collector.completed.size)
+  }
+
+  @Test
+  fun `recordStart fans out without touching the ring buffer`() {
+    val monitor = NetworkRequestMonitor()
+    val collector = CollectingDelegate()
+    monitor.addDelegate(collector)
+
+    val started = NetworkRequestStarted(UUID.randomUUID(), "https://expo.dev/x", "GET", Date())
+    monitor.recordStart(started)
+
+    assertEquals(1, collector.started.size)
+    assertEquals(started.id, collector.started.first().id)
+    assertTrue("ring buffer holds completed snapshots only", monitor.recent.isEmpty())
+  }
+
+  @Test
+  fun `bounds the ring buffer to 200 entries`() {
+    val monitor = NetworkRequestMonitor()
+    for (i in 0 until 250) {
+      monitor.record(makeRequest(url = "https://expo.dev/$i"))
+    }
+    assertEquals(200, monitor.recent.size)
+    assertEquals("https://expo.dev/50", monitor.recent.first().url)
+    assertEquals("https://expo.dev/249", monitor.recent.last().url)
+  }
+
+  @Test
+  fun `summarize filters by fetchStart inclusive on both ends`() {
+    val monitor = NetworkRequestMonitor()
+    monitor.record(makeRequest(fetchStart = Date(0)))
+    monitor.record(makeRequest(fetchStart = Date(50)))
+    monitor.record(makeRequest(fetchStart = Date(100)))
+
+    val summary = monitor.summarize(start = Date(10), end = Date(90))
+    assertEquals(1, summary.count)
+  }
+
+  @Test
+  fun `removeDelegate stops further fan-out`() {
+    val monitor = NetworkRequestMonitor()
+    val collector = CollectingDelegate()
+    monitor.addDelegate(collector)
+    monitor.removeDelegate(collector)
+
+    monitor.record(makeRequest())
+    assertEquals(0, collector.completed.size)
+  }
+
+  private fun makeRequest(
+    url: String = "https://expo.dev/x",
+    fetchStart: Date = Date()
+  ): NetworkRequest = NetworkRequest(
+    id = UUID.randomUUID(),
+    url = url,
+    method = "GET",
+    statusCode = 200,
+    networkProtocol = null,
+    requestBytesSent = 0,
+    responseBytesReceived = 0,
+    timings = NetworkRequest.Timings(
+      fetchStart = fetchStart,
+      domainLookupStart = null,
+      domainLookupEnd = null,
+      connectStart = null,
+      connectEnd = null,
+      secureConnectionStart = null,
+      secureConnectionEnd = null,
+      requestStart = null,
+      requestEnd = null,
+      responseStart = null,
+      responseEnd = null,
+      totalDuration = 0.1
+    ),
+    errorDescription = null,
+    redirects = emptyList()
+  )
+
+  private class CollectingDelegate : NetworkRequestObserverDelegate {
+    val completed = mutableListOf<NetworkRequest>()
+    val started = mutableListOf<NetworkRequestStarted>()
+
+    override fun onNetworkRequestStarted(request: NetworkRequestStarted) {
+      started.add(request)
+    }
+
+    override fun onNetworkRequestCompleted(request: NetworkRequest) {
+      completed.add(request)
+    }
+  }
+}
diff --git a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestObserverTest.kt b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestObserverTest.kt
new file mode 100644
index 00000000000000..7574316e8a8776
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestObserverTest.kt
@@ -0,0 +1,139 @@
+package expo.modules.appmetrics.networkrequests
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.util.Date
+import java.util.UUID
+
+/**
+ * The JS-facing observer mostly forwards to `NetworkRequestMonitor`. What's specific to the
+ * observer is the payload shape — the map it hands to `emit()` is the wire format JS consumers
+ * see. These tests pin that shape down so renames require a deliberate change.
+ */
+class NetworkRequestObserverTest {
+  @Test
+  fun `startedPayload contains the started-event keys`() {
+    val id = UUID.randomUUID()
+    val startedAt = Date(1_700_000_000_000L)
+    val payload = NetworkRequestObserver.startedPayload(
+      NetworkRequestStarted(id, "https://expo.dev/start", "POST", startedAt)
+    )
+
+    assertEquals(id.toString(), payload["id"])
+    assertEquals("https://expo.dev/start", payload["url"])
+    assertEquals("POST", payload["method"])
+    assertNotNull("startedAt should be populated", payload["startedAt"])
+    // Only the four documented keys — anything extra means the JS contract grew unintentionally.
+    assertEquals(setOf("id", "url", "method", "startedAt"), payload.keys)
+  }
+
+  @Test
+  fun `completedPayload normalizes timings and redirects`() {
+    val id = UUID.randomUUID()
+    val fetchStart = Date(2_000_000L)
+    val responseEnd = Date(2_500_000L)
+    val request = NetworkRequest(
+      id = id,
+      url = "https://expo.dev/end",
+      method = "GET",
+      statusCode = 200,
+      networkProtocol = "h2",
+      requestBytesSent = 123,
+      responseBytesReceived = 4567,
+      timings = NetworkRequest.Timings(
+        fetchStart = fetchStart,
+        domainLookupStart = null,
+        domainLookupEnd = null,
+        connectStart = null,
+        connectEnd = null,
+        secureConnectionStart = null,
+        secureConnectionEnd = null,
+        requestStart = null,
+        requestEnd = null,
+        responseStart = null,
+        responseEnd = responseEnd,
+        totalDuration = 0.5
+      ),
+      errorDescription = null,
+      redirects = listOf(
+        NetworkRequest.Redirect(
+          fromUrl = "https://expo.dev/a",
+          toUrl = "https://expo.dev/b",
+          statusCode = 301
+        )
+      )
+    )
+
+    val payload = NetworkRequestObserver.completedPayload(request)
+
+    assertEquals(id.toString(), payload["id"])
+    assertEquals("https://expo.dev/end", payload["url"])
+    assertEquals("GET", payload["method"])
+    assertEquals(200, payload["statusCode"])
+    assertEquals("h2", payload["networkProtocol"])
+    assertEquals(123L, payload["requestBytesSent"])
+    assertEquals(4567L, payload["responseBytesReceived"])
+    assertEquals(0.5, payload["totalDuration"])
+    assertNotNull(payload["startedAt"])
+    assertNotNull(payload["completedAt"])
+
+    @Suppress("UNCHECKED_CAST")
+    val redirects = payload["redirects"] as List<Map<String, Any?>>
+    assertEquals(1, redirects.size)
+    assertEquals("https://expo.dev/a", redirects[0]["fromUrl"])
+    assertEquals("https://expo.dev/b", redirects[0]["toUrl"])
+    assertEquals(301, redirects[0]["statusCode"])
+  }
+
+  @Test
+  fun `completedPayload preserves nulls and empty redirects`() {
+    val id = UUID.randomUUID()
+    val request = NetworkRequest(
+      id = id,
+      url = "https://expo.dev/error",
+      method = "GET",
+      statusCode = null,
+      networkProtocol = null,
+      requestBytesSent = null,
+      responseBytesReceived = null,
+      timings = NetworkRequest.Timings(
+        fetchStart = Date(3_000_000L),
+        domainLookupStart = null,
+        domainLookupEnd = null,
+        connectStart = null,
+        connectEnd = null,
+        secureConnectionStart = null,
+        secureConnectionEnd = null,
+        requestStart = null,
+        requestEnd = null,
+        responseStart = null,
+        responseEnd = null,
+        totalDuration = 0.1
+      ),
+      errorDescription = "timed out",
+      redirects = emptyList()
+    )
+
+    val payload = NetworkRequestObserver.completedPayload(request)
+
+    // Every nullable key must be present in the map so JS callers can read them without crashing.
+    assertTrue(payload.containsKey("statusCode"))
+    assertNull(payload["statusCode"])
+    assertTrue(payload.containsKey("networkProtocol"))
+    assertNull(payload["networkProtocol"])
+    assertTrue(payload.containsKey("requestBytesSent"))
+    assertNull(payload["requestBytesSent"])
+    assertTrue(payload.containsKey("completedAt"))
+    assertNull(payload["completedAt"])
+    assertEquals("timed out", payload["errorDescription"])
+
+    // `redirects` is always present as an empty list, never null — JS callers `.map` over it
+    // without a null-guard.
+    @Suppress("UNCHECKED_CAST")
+    val redirects = payload["redirects"] as List<Map<String, Any?>>
+    assertTrue(redirects.isEmpty())
+  }
+}
diff --git a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestSummaryTest.kt b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestSummaryTest.kt
new file mode 100644
index 00000000000000..5f55f9aa2f49a0
--- /dev/null
+++ b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/networkrequests/NetworkRequestSummaryTest.kt
@@ -0,0 +1,94 @@
+package expo.modules.appmetrics.networkrequests
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import java.util.Date
+import java.util.UUID
+
+class NetworkRequestSummaryTest {
+  @Test
+  fun `empty list yields empty summary`() {
+    val summary = NetworkRequestSummary.from(emptyList())
+    assertEquals(0, summary.count)
+    assertEquals(0, summary.failed)
+    assertEquals(0L, summary.bytesReceived)
+    assertEquals(0L, summary.bytesSent)
+    assertEquals(0.0, summary.totalDuration, 0.0001)
+    assertNull(summary.slowestDuration)
+    assertNull(summary.slowestHost)
+    assertEquals(true, summary.isEmpty)
+  }
+
+  @Test
+  fun `counts failed entries by error, 4xx, and 5xx status`() {
+    val requests = listOf(
+      makeRequest(statusCode = 200, totalDuration = 0.1),
+      // 304 is a successful conditional-GET cache hit — must not count as failed.
+      makeRequest(statusCode = 304, totalDuration = 0.1),
+      makeRequest(statusCode = 404, totalDuration = 0.2),
+      makeRequest(statusCode = 503, totalDuration = 0.2),
+      makeRequest(statusCode = null, errorDescription = "timed out", totalDuration = 0.3)
+    )
+    val summary = NetworkRequestSummary.from(requests)
+    assertEquals(5, summary.count)
+    assertEquals(3, summary.failed)
+  }
+
+  @Test
+  fun `slowest by totalDuration with host resolved from URL`() {
+    val requests = listOf(
+      makeRequest(url = "https://fast.example/x", totalDuration = 0.1),
+      makeRequest(url = "https://slow.example/y", totalDuration = 0.5),
+      makeRequest(url = "https://mid.example/z", totalDuration = 0.3)
+    )
+    val summary = NetworkRequestSummary.from(requests)
+    assertEquals(0.5, summary.slowestDuration!!, 0.0001)
+    assertEquals("slow.example", summary.slowestHost)
+  }
+
+  @Test
+  fun `aggregates byte counts treating null as zero`() {
+    val requests = listOf(
+      makeRequest(requestBytesSent = 100, responseBytesReceived = 200),
+      makeRequest(requestBytesSent = null, responseBytesReceived = 50),
+      makeRequest(requestBytesSent = 30, responseBytesReceived = null)
+    )
+    val summary = NetworkRequestSummary.from(requests)
+    assertEquals(130L, summary.bytesSent)
+    assertEquals(250L, summary.bytesReceived)
+  }
+
+  private fun makeRequest(
+    url: String = "https://expo.dev/x",
+    statusCode: Int? = 200,
+    errorDescription: String? = null,
+    requestBytesSent: Long? = 0,
+    responseBytesReceived: Long? = 0,
+    totalDuration: Double = 0.1
+  ): NetworkRequest = NetworkRequest(
+    id = UUID.randomUUID(),
+    url = url,
+    method = "GET",
+    statusCode = statusCode,
+    networkProtocol = null,
+    requestBytesSent = requestBytesSent,
+    responseBytesReceived = responseBytesReceived,
+    timings = NetworkRequest.Timings(
+      fetchStart = Date(0),
+      domainLookupStart = null,
+      domainLookupEnd = null,
+      connectStart = null,
+      connectEnd = null,
+      secureConnectionStart = null,
+      secureConnectionEnd = null,
+      requestStart = null,
+      requestEnd = null,
+      responseStart = null,
+      responseEnd = null,
+      totalDuration = totalDuration
+    ),
+    errorDescription = errorDescription,
+    redirects = emptyList()
+  )
+}
diff --git a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/storage/SessionManagerTest.kt b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/storage/SessionManagerTest.kt
index 92f59b244abe4a..e77689ab55ea42 100644
--- a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/storage/SessionManagerTest.kt
+++ b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/storage/SessionManagerTest.kt
@@ -36,38 +36,6 @@ class SessionManagerTest {
     database.close()
   }
 
-  // region Session Uniqueness Tests
-
-  @Test
-  fun `getAllSessions returns each session exactly once`() =
-    runTest {
-      // Arrange
-      val session1Id = "session-1"
-      val session2Id = "session-2"
-      sessionManager.startSessionWithIdAt(session1Id, "2025-01-01T00:00:00.000Z")
-      sessionManager.startSessionWithIdAt(session2Id, "2025-01-01T01:00:00.000Z")
-
-      // Add multiple metrics to session 1
-      val metrics = listOf(
-        createMetric("metric-1", session1Id),
-        createMetric("metric-2", session1Id),
-        createMetric("metric-3", session1Id)
-      )
-      database.metricDao().insertAll(metrics)
-
-      // Act
-      val result = sessionManager.getAllSessions()
-
-      // Assert
-      assertEquals(2, result.size)
-      val sessionIds = result.map { it.session.id }
-      assertEquals(sessionIds.distinct().size, sessionIds.size)
-      assertTrue(sessionIds.contains(session1Id))
-      assertTrue(sessionIds.contains(session2Id))
-    }
-
-  // endregion
-
   // region Session Lifecycle Tests
 
   @Test
@@ -100,10 +68,7 @@ class SessionManagerTest {
       sessionManager.startSessionWithIdAt(sessionId, timestamp, metadata, environment = "production")
 
       // Assert
-      val sessions = sessionManager.getAllSessions()
-      assertEquals(1, sessions.size)
-
-      val session = sessions[0].session
+      val session = database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!.session
       assertEquals(sessionId, session.id)
       assertEquals(timestamp, session.startTimestamp)
       assertTrue(session.isActive)
@@ -134,8 +99,8 @@ class SessionManagerTest {
       sessionManager.startSessionWithIdAt(sessionId, "2025-01-01T00:00:00.000Z", metadata, environment = "production")
 
       // Assert
-      val sessions = sessionManager.getAllSessions()
-      assertEquals("production", sessions[0].session.environment)
+      val session = database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!.session
+      assertEquals("production", session.environment)
     }
 
   @Test
@@ -148,8 +113,8 @@ class SessionManagerTest {
       sessionManager.startSessionWithIdAt(sessionId, "2025-01-01T00:00:00.000Z")
 
       // Assert
-      val sessions = sessionManager.getAllSessions()
-      assertEquals(expected, sessions[0].session.environment)
+      val session = database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!.session
+      assertEquals(expected, session.environment)
     }
 
   @Test
@@ -160,19 +125,13 @@ class SessionManagerTest {
       sessionManager.startSessionWithIdAt(sessionId, "2025-01-01T00:00:00.000Z")
 
       // Verify it starts as active
-      var sessions = sessionManager.getAllSessions().filter { it.session.isActive }
-      assertEquals(1, sessions.size)
+      assertTrue(database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!.session.isActive)
 
       // Act
       sessionManager.stopSession(sessionId)
 
       // Assert
-      sessions = sessionManager.getAllSessions().filter { it.session.isActive }
-      assertEquals(0, sessions.size)
-
-      val allSessions = sessionManager.getAllSessions()
-      assertEquals(1, allSessions.size)
-      assertFalse(allSessions[0].session.isActive)
+      assertFalse(database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!.session.isActive)
     }
 
   @Test
@@ -186,7 +145,7 @@ class SessionManagerTest {
       sessionManager.stopSession(sessionId)
 
       // Assert
-      val stopped = sessionManager.getAllSessions().single()
+      val stopped = database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!
       assertNotNull("endTimestamp should be set after stopSession", stopped.session.endTimestamp)
     }
 
@@ -203,9 +162,8 @@ class SessionManagerTest {
       sessionManager.deactivateAllSessionsBefore("2025-01-10T00:00:00.000Z")
 
       // Assert
-      val activeSessions = sessionManager.getAllSessions().filter { it.session.isActive }
-      assertEquals(1, activeSessions.size)
-      assertEquals(newSession, activeSessions[0].session.id)
+      assertFalse(database.sessionDao().getSessionWithMetricsBySessionId(oldSession)!!.session.isActive)
+      assertTrue(database.sessionDao().getSessionWithMetricsBySessionId(newSession)!!.session.isActive)
     }
 
   @Test
@@ -222,7 +180,7 @@ class SessionManagerTest {
       sessionManager.deactivateAllSessionsBefore(cutoff)
 
       // Assert
-      val deactivated = sessionManager.getAllSessions().single { it.session.id == orphan }
+      val deactivated = database.sessionDao().getSessionWithMetricsBySessionId(orphan)!!
       assertFalse(deactivated.session.isActive)
       assertEquals(cutoff, deactivated.session.endTimestamp)
     }
@@ -235,8 +193,7 @@ class SessionManagerTest {
       val cleanlyStopped = "clean-session"
       sessionManager.startSessionWithIdAt(cleanlyStopped, "2025-01-01T00:00:00.000Z")
       sessionManager.stopSession(cleanlyStopped)
-      val originalEnd = sessionManager.getAllSessions()
-        .single { it.session.id == cleanlyStopped }
+      val originalEnd = database.sessionDao().getSessionWithMetricsBySessionId(cleanlyStopped)!!
         .session.endTimestamp
       assertNotNull("precondition: stopSession should have stamped endTimestamp", originalEnd)
 
@@ -244,7 +201,7 @@ class SessionManagerTest {
       sessionManager.deactivateAllSessionsBefore("2025-01-10T00:00:00.000Z")
 
       // Assert — the cleanly-stopped session keeps its original end time.
-      val preserved = sessionManager.getAllSessions().single { it.session.id == cleanlyStopped }
+      val preserved = database.sessionDao().getSessionWithMetricsBySessionId(cleanlyStopped)!!
       assertEquals(originalEnd, preserved.session.endTimestamp)
     }
 
@@ -262,9 +219,8 @@ class SessionManagerTest {
       sessionManager.updateEnvironmentForActiveSessions("production")
 
       // Assert
-      val allSessions = sessionManager.getAllSessions()
-      val active = allSessions.find { it.session.id == activeSession }
-      val inactive = allSessions.find { it.session.id == inactiveSession }
+      val active = database.sessionDao().getSessionWithMetricsBySessionId(activeSession)
+      val inactive = database.sessionDao().getSessionWithMetricsBySessionId(inactiveSession)
 
       assertEquals("production", active?.session?.environment)
       assertEquals("staging", inactive?.session?.environment)
@@ -296,9 +252,8 @@ class SessionManagerTest {
       sessionManager.addMetrics(metricsForSession2, session2Id)
 
       // Assert
-      val sessions = sessionManager.getAllSessions()
-      val s1 = sessions.find { it.session.id == session1Id }
-      val s2 = sessions.find { it.session.id == session2Id }
+      val s1 = database.sessionDao().getSessionWithMetricsBySessionId(session1Id)
+      val s2 = database.sessionDao().getSessionWithMetricsBySessionId(session2Id)
 
       assertEquals(2, s1?.metrics?.size)
       assertTrue(s1?.metrics?.all { it.sessionId == session1Id } ?: false)
@@ -587,13 +542,15 @@ class SessionManagerTest {
       )
 
       // Verify data exists
-      assertEquals(2, sessionManager.getAllSessions().size)
+      assertNotNull(database.sessionDao().getSessionWithMetricsBySessionId(session1Id))
+      assertNotNull(database.sessionDao().getSessionWithMetricsBySessionId(session2Id))
 
       // Act
       sessionManager.clearAllData()
 
       // Assert
-      assertEquals(0, sessionManager.getAllSessions().size)
+      assertNull(database.sessionDao().getSessionWithMetricsBySessionId(session1Id))
+      assertNull(database.sessionDao().getSessionWithMetricsBySessionId(session2Id))
     }
 
   @Test
@@ -629,14 +586,22 @@ class SessionManagerTest {
       // Assert — only the stopped, stale session is gone. The active stale
       // session is preserved (we don't pull a session out from under a
       // long-running process), and the fresh stopped session is preserved.
-      val remaining = sessionManager.getAllSessions().map { it.session.id }.toSet()
-      assertFalse("stale stopped session should be cleaned up", remaining.contains(staleStoppedId))
-      assertTrue("stale but active session should be preserved", remaining.contains(staleActiveId))
-      assertTrue("fresh stopped session should be preserved", remaining.contains(freshStoppedId))
+      assertNull(
+        "stale stopped session should be cleaned up",
+        database.sessionDao().getSessionWithMetricsBySessionId(staleStoppedId)
+      )
+      assertNotNull(
+        "stale but active session should be preserved",
+        database.sessionDao().getSessionWithMetricsBySessionId(staleActiveId)
+      )
+      assertNotNull(
+        "fresh stopped session should be preserved",
+        database.sessionDao().getSessionWithMetricsBySessionId(freshStoppedId)
+      )
     }
 
   @Test
-  fun `getAllSessions populates the logs relation alongside metrics`() =
+  fun `getSessionWithMetricsBySessionId populates the logs relation alongside metrics`() =
     runTest {
       // Arrange — exercises the Room `@Relation` for `LogRecord` end-to-end.
       // Unit-level mapper tests construct `SessionWithMetrics` directly and
@@ -659,17 +624,16 @@ class SessionManagerTest {
       )
 
       // Act
-      val sessions = sessionManager.getAllSessions()
+      val session = database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!
 
       // Assert
-      val session = sessions.single { it.session.id == sessionId }
       assertEquals(2, session.metrics.size)
       assertEquals(3, session.logs.size)
       assertEquals(setOf("log-a", "log-b", "log-c"), session.logs.map { it.logId }.toSet())
     }
 
   @Test
-  fun `getAllSessions yields an empty logs list when no logs exist for the session`() =
+  fun `getSessionWithMetricsBySessionId yields an empty logs list when no logs exist for the session`() =
     runTest {
       // Arrange — a session with metrics but no logs. The relation should
       // populate as an empty list, not null.
@@ -678,10 +642,9 @@ class SessionManagerTest {
       database.metricDao().insertAll(listOf(createMetric("metric-1", sessionId)))
 
       // Act
-      val sessions = sessionManager.getAllSessions()
+      val session = database.sessionDao().getSessionWithMetricsBySessionId(sessionId)!!
 
       // Assert
-      val session = sessions.single { it.session.id == sessionId }
       assertEquals(emptyList<LogRecord>(), session.logs)
     }
 
diff --git a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/utils/MetricParamsBuilderTest.kt b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/utils/MetricParamsBuilderTest.kt
index cf0a0e4b6ce1ae..2744bb38d58801 100644
--- a/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/utils/MetricParamsBuilderTest.kt
+++ b/packages/expo-app-metrics/android/src/test/java/expo/modules/appmetrics/utils/MetricParamsBuilderTest.kt
@@ -1,6 +1,7 @@
 package expo.modules.appmetrics.utils
 
 import expo.modules.appmetrics.frames.FrameMetricsRecord
+import expo.modules.appmetrics.networkrequests.NetworkRequestSummary
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Test
@@ -119,4 +120,54 @@ class MetricParamsBuilderTest {
     assertEquals("other", typeFor(NetworkTransport.OTHER))
     assertEquals("none", typeFor(NetworkTransport.NONE))
   }
+
+  @Test
+  fun `omits network-requests keys when the summary is empty`() {
+    val params = MetricParamsBuilder.build(networkRequests = NetworkRequestSummary.empty)
+    assertNull(params["expo.network.requests.count"])
+    assertNull(params["expo.network.requests.failed"])
+    assertNull(params["expo.network.requests.bytesSent"])
+    assertNull(params["expo.network.requests.bytesReceived"])
+    assertNull(params["expo.network.requests.totalDuration"])
+    assertNull(params["expo.network.requests.slowestDuration"])
+    assertNull(params["expo.network.requests.slowestHost"])
+  }
+
+  @Test
+  fun `emits the seven network-requests keys when the summary has work`() {
+    val summary = NetworkRequestSummary(
+      count = 5,
+      failed = 1,
+      bytesReceived = 1234,
+      bytesSent = 567,
+      totalDuration = 1.5,
+      slowestDuration = 0.7,
+      slowestHost = "expo.dev"
+    )
+    val params = MetricParamsBuilder.build(networkRequests = summary)
+    assertEquals(5, params["expo.network.requests.count"])
+    assertEquals(1, params["expo.network.requests.failed"])
+    assertEquals(1234L, params["expo.network.requests.bytesReceived"])
+    assertEquals(567L, params["expo.network.requests.bytesSent"])
+    assertEquals(1.5, params["expo.network.requests.totalDuration"])
+    assertEquals(0.7, params["expo.network.requests.slowestDuration"])
+    assertEquals("expo.dev", params["expo.network.requests.slowestHost"])
+  }
+
+  @Test
+  fun `omits slowest keys when the summary has counts but missing slowest fields`() {
+    val summary = NetworkRequestSummary(
+      count = 1,
+      failed = 0,
+      bytesReceived = 0,
+      bytesSent = 0,
+      totalDuration = 0.1,
+      slowestDuration = null,
+      slowestHost = null
+    )
+    val params = MetricParamsBuilder.build(networkRequests = summary)
+    assertEquals(1, params["expo.network.requests.count"])
+    assertNull(params["expo.network.requests.slowestDuration"])
+    assertNull(params["expo.network.requests.slowestHost"])
+  }
 }
diff --git a/packages/expo-app-metrics/build/index.d.ts b/packages/expo-app-metrics/build/index.d.ts
index 98ce7456217473..890521e72c2670 100644
--- a/packages/expo-app-metrics/build/index.d.ts
+++ b/packages/expo-app-metrics/build/index.d.ts
@@ -1,4 +1,5 @@
 export { default } from './module';
 export { AppMetricsRoot } from './AppMetricsRoot';
 export * from './types';
+export * from './useNetworkRequestObserver';
 //# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/packages/expo-app-metrics/build/index.d.ts.map b/packages/expo-app-metrics/build/index.d.ts.map
index a2c0deb5be0300..e2e0de39c21446 100644
--- a/packages/expo-app-metrics/build/index.d.ts.map
+++ b/packages/expo-app-metrics/build/index.d.ts.map
@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,cAAc,SAAS,CAAC"}
\ No newline at end of file
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,cAAc,SAAS,CAAC;AACxB,cAAc,6BAA6B,CAAC"}
\ No newline at end of file
diff --git a/packages/expo-app-metrics/build/module.web.d.ts b/packages/expo-app-metrics/build/module.web.d.ts
index bdb25bda8759b9..bb7c0b670d0ef6 100644
--- a/packages/expo-app-metrics/build/module.web.d.ts
+++ b/packages/expo-app-metrics/build/module.web.d.ts
@@ -2,13 +2,14 @@ import { NativeModule } from 'expo';
 import type { ExpoAppMetricsModuleType, LogAttributeValue, LogEventOptions, Metric, MetricAttributes } from './types';
 export * from './types';
 declare class ExpoAppMetricsModule extends NativeModule implements ExpoAppMetricsModuleType {
+    NetworkRequestObserver: ExpoAppMetricsModuleType["NetworkRequestObserver"];
     addCustomMetricToSession(metric: Metric): Promise<void>;
     markFirstRender(): Promise<void>;
     markInteractive(attributes?: MetricAttributes): Promise<void>;
     logEvent(name: string, options?: LogEventOptions): void;
     setGlobalAttributes(attributes?: Record<string, LogAttributeValue> | null): void;
     clearStoredEntries(): Promise<void>;
-    getAllSessions(): Promise<never[]>;
+    getInactiveSessions(): Promise<never[]>;
     simulateCrashReport(): void;
     triggerCrash(): void;
     getMainSession(): Promise<null>;
diff --git a/packages/expo-app-metrics/build/module.web.d.ts.map b/packages/expo-app-metrics/build/module.web.d.ts.map
index e2bfc4296e9437..e8b595d3dc22ba 100644
--- a/packages/expo-app-metrics/build/module.web.d.ts.map
+++ b/packages/expo-app-metrics/build/module.web.d.ts.map
@@ -1 +1 @@
-{"version":3,"file":"module.web.d.ts","sourceRoot":"","sources":["../src/module.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAqB,MAAM,MAAM,CAAC;AAEvD,OAAO,KAAK,EACV,wBAAwB,EACxB,iBAAiB,EACjB,eAAe,EACf,MAAM,EACN,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB,cAAc,SAAS,CAAC;AAExB,cAAM,oBAAqB,SAAQ,YAAa,YAAW,wBAAwB;IACjF,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAGjD,eAAe;IACf,eAAe,CAAC,UAAU,CAAC,EAAE,gBAAgB;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe;IAChD,mBAAmB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI;IACnE,kBAAkB;IAClB,cAAc;IAGpB,mBAAmB;IACnB,YAAY;IACN,cAAc;CAGrB;;AAED,wBAAyE"}
\ No newline at end of file
+{"version":3,"file":"module.web.d.ts","sourceRoot":"","sources":["../src/module.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAmC,MAAM,MAAM,CAAC;AAErE,OAAO,KAAK,EACV,wBAAwB,EACxB,iBAAiB,EACjB,eAAe,EACf,MAAM,EACN,gBAAgB,EAEjB,MAAM,SAAS,CAAC;AAEjB,cAAc,SAAS,CAAC;AAOxB,cAAM,oBAAqB,SAAQ,YAAa,YAAW,wBAAwB;IACjF,sBAAsB,EACoB,wBAAwB,CAAC,wBAAwB,CAAC,CAAC;IAE7F,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAGjD,eAAe;IACf,eAAe,CAAC,UAAU,CAAC,EAAE,gBAAgB;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe;IAChD,mBAAmB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI;IACnE,kBAAkB;IAClB,mBAAmB;IAGzB,mBAAmB;IACnB,YAAY;IACN,cAAc;CAGrB;;AAED,wBAAyE"}
\ No newline at end of file
diff --git a/packages/expo-app-metrics/build/types.d.ts b/packages/expo-app-metrics/build/types.d.ts
index 3662d533055643..9f038ccb90d6a5 100644
--- a/packages/expo-app-metrics/build/types.d.ts
+++ b/packages/expo-app-metrics/build/types.d.ts
@@ -1,3 +1,4 @@
+import type { SharedObject } from 'expo';
 export type AppStartupTimes = {
     /**
      * Time from when the user taps the app to the moment the app starts executing the main code.
@@ -237,6 +238,106 @@ export type CrashReport = {
     timestampEnd: string;
     ingestedAt: string;
 };
+/**
+ * Snapshot emitted at the moment a request begins. Carries enough information to render the
+ * request in an "in-flight" debug UI; the matching completion event arrives later with the
+ * same `id`.
+ */
+export type NetworkRequestStartedEvent = {
+    /** Stable identifier shared with the corresponding `requestCompleted` event. */
+    id: string;
+    /** Request URL as supplied to the native networking layer. May include query parameters and fragments. */
+    url: string;
+    /** HTTP method (`GET`, `POST`, …). */
+    method: string;
+    /** ISO 8601 timestamp of when the request started. Truncated to whole seconds. */
+    startedAt: string;
+};
+/**
+ * One hop in a redirect chain. `fromUrl` issued the 3xx response, `toUrl` is where it pointed.
+ * For a complete chain the first entry's `fromUrl` matches the parent
+ * `NetworkRequestCompletedEvent.url`, and the last entry's `toUrl` is where the request
+ * actually landed.
+ */
+export type NetworkRequestRedirect = {
+    /** The URL that returned the redirect. */
+    fromUrl: string;
+    /** The URL the request was redirected to. */
+    toUrl: string;
+    /** The 3xx status code (301, 302, 307, 308, …) returned by `fromUrl`. */
+    statusCode: number;
+};
+/**
+ * Snapshot emitted when a request completes (successfully or otherwise). Shares its `id` with
+ * the corresponding `requestStarted` event so consumers can correlate the two.
+ */
+export type NetworkRequestCompletedEvent = {
+    /** Stable identifier shared with the corresponding `requestStarted` event. */
+    id: string;
+    /** Request URL as supplied to the native networking layer. May include query parameters and fragments. */
+    url: string;
+    /** HTTP method (`GET`, `POST`, …). */
+    method: string;
+    /** Response status code, or `null` if the request failed before headers were received. */
+    statusCode: number | null;
+    /**
+     * Negotiated wire protocol (`http/1.1`, `h2`, `h3`), or `null` when the OS didn't report one.
+     */
+    networkProtocol: string | null;
+    /** Total request bytes on the wire (headers + body), or `null` if unavailable. */
+    requestBytesSent: number | null;
+    /** Total response bytes on the wire (headers + body), or `null` if unavailable. */
+    responseBytesReceived: number | null;
+    /** Short, human-readable error description if the request failed. */
+    errorDescription: string | null;
+    /**
+     * ISO 8601 timestamp of when the request started (matches `requestStarted.startedAt`).
+     * Truncated to whole seconds — use `totalDuration` for sub-second timing.
+     */
+    startedAt: string | null;
+    /**
+     * ISO 8601 timestamp of when the response finished arriving. Truncated to whole seconds — use
+     * `totalDuration` for sub-second timing.
+     */
+    completedAt: string | null;
+    /** Total wall-clock duration of the request in seconds. */
+    totalDuration: number;
+    /**
+     * Ordered list of redirect hops that preceded the final response. Empty when the request
+     * completed without any 3xx redirects.
+     */
+    redirects: NetworkRequestRedirect[];
+};
+/**
+ * Map of events emitted by `NetworkRequestObserver`. Used by the underlying `SharedObject`
+ * event-emitter to type listener callbacks.
+ */
+export type NetworkRequestObserverEvents = {
+    requestStarted(event: NetworkRequestStartedEvent): void;
+    requestCompleted(event: NetworkRequestCompletedEvent): void;
+};
+/**
+ * Per-instance handle to the network-request stream. Each `new NetworkRequestObserver()` allocates
+ * its own SharedObject and registers as a delegate on the native singleton; when JS releases the
+ * instance the delegate slot is automatically reclaimed.
+ *
+ * Subscribe to events via `addListener`/`removeListener` (inherited from the SharedObject base).
+ *
+ * @example
+ * ```ts
+ * import AppMetrics from 'expo-app-metrics';
+ *
+ * const observer = new AppMetrics.NetworkRequestObserver();
+ * const sub = observer.addListener('requestCompleted', event => {
+ *   console.log(event.url, event.totalDuration);
+ * });
+ * // later
+ * sub.remove();
+ * ```
+ */
+export declare class NetworkRequestObserver extends SharedObject<NetworkRequestObserverEvents> {
+    constructor();
+}
 export interface ExpoAppMetricsModuleType {
     markFirstRender(): void;
     markInteractive(attributes?: MetricAttributes): void;
@@ -267,13 +368,16 @@ export interface ExpoAppMetricsModuleType {
     setGlobalAttributes(attributes?: Record<string, LogAttributeValue> | null): void;
     clearStoredEntries(): Promise<void>;
     /**
-     * Returns all sessions across the current and historical entries,
-     * ordered with the current launch first.
+     * Returns the recorded sessions as plain `Session` records, ordered with
+     * the most recent first. Each record eagerly includes its metrics, logs, and
+     * crash report.
+     *
+     * Debug-only: intended for inspecting on-device history (e.g. the
+     * ObserveTester app), not for production use.
      *
      * @private This API is unstable and may change without notice.
-     * @platform ios
      */
-    getAllSessions(): Promise<Session[]>;
+    getInactiveSessions(): Promise<Session[]>;
     /**
      * Simulates a crash report, attributing it to the current main session.
      * Intended for development and debugging only.
@@ -300,6 +404,12 @@ export interface ExpoAppMetricsModuleType {
      * @private This API is unstable and may change without notice.
      */
     getMainSession(): Promise<MainSession | null>;
+    /**
+     * Class for subscribing to HTTP requests observed by the native networking interceptor.
+     * Construct an instance to begin receiving `requestStarted`/`requestCompleted` events;
+     * release the instance (drop all references) to stop.
+     */
+    NetworkRequestObserver: typeof NetworkRequestObserver;
 }
 export {};
 //# sourceMappingURL=types.d.ts.map
\ No newline at end of file
diff --git a/packages/expo-app-metrics/build/types.d.ts.map b/packages/expo-app-metrics/build/types.d.ts.map
index b690d684709781..21a721ef8dc4e3 100644
--- a/packages/expo-app-metrics/build/types.d.ts.map
+++ b/packages/expo-app-metrics/build/types.d.ts.map
@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,WAAW,MAAM;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAElF;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GACzB,MAAM,GACN,MAAM,GACN,OAAO,GACP,iBAAiB,EAAE,GACnB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAE,CAAC;AAEzC;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,CAAC;IACtD;;OAEG;IACH,QAAQ,EAAE,WAAW,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,CAAC;IACtD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElF,MAAM,MAAM,SAAS,GACjB,WAAW,GACX,YAAY,GACZ,cAAc,GACd,gBAAgB,GAChB,kBAAkB,GAClB,eAAe,GACf,eAAe,CAAC;AAEpB,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG;IACzC,IAAI,EAAE,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,cAAc,CAAC;AAEnD,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,2BAA2B,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,CAAC,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;IACpC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,gBAAgB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,mBAAmB,CAAC,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,uBAAuB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,eAAe,CAAC,EAAE;QAChB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,CAAC;KACvB,GAAG,IAAI,CAAC;IACT,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAC;IACX,0GAA0G;IAC1G,GAAG,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,8EAA8E;IAC9E,EAAE,EAAE,MAAM,CAAC;IACX,0GAA0G;IAC1G,GAAG,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,0FAA0F;IAC1F,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;OAEG;IACH,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,kFAAkF;IAClF,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,mFAAmF;IACnF,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,qEAAqE;IACrE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,2DAA2D;IAC3D,aAAa,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,SAAS,EAAE,sBAAsB,EAAE,CAAC;CACrC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,cAAc,CAAC,KAAK,EAAE,0BAA0B,GAAG,IAAI,CAAC;IACxD,gBAAgB,CAAC,KAAK,EAAE,4BAA4B,GAAG,IAAI,CAAC;CAC7D,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,YAAY,CAAC,4BAA4B,CAAC;;CAE7F;AAED,MAAM,WAAW,wBAAwB;IACvC,eAAe,IAAI,IAAI,CAAC;IACxB,eAAe,CAAC,UAAU,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACrD;;;;;;;;;OASG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IACxD;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;IACjF,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC;;;;;;;;;OASG;IACH,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAE1C;;;;;;OAMG;IACH,mBAAmB,IAAI,IAAI,CAAC;IAE5B;;;;;;OAMG;IACH,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAEpC;;OAEG;IACH,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD;;;;OAIG;IACH,cAAc,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAE9C;;;;OAIG;IACH,sBAAsB,EAAE,OAAO,sBAAsB,CAAC;CACvD"}
\ No newline at end of file
diff --git a/packages/expo-app-metrics/build/useNetworkRequestObserver.d.ts b/packages/expo-app-metrics/build/useNetworkRequestObserver.d.ts
new file mode 100644
index 00000000000000..2841ba2de4daab
--- /dev/null
+++ b/packages/expo-app-metrics/build/useNetworkRequestObserver.d.ts
@@ -0,0 +1,20 @@
+import type { NetworkRequestCompletedEvent, NetworkRequestObserver, NetworkRequestStartedEvent } from './types';
+export type UseNetworkRequestObserverOptions = {
+    /**
+     * Called when a request begins. Fired before any response or timing data exists; correlate
+     * with the matching `onCompleted` call via the shared `id`.
+     */
+    onStarted?: (event: NetworkRequestStartedEvent) => void;
+    /**
+     * Called when a request finishes (successfully or otherwise). Payload includes status,
+     * timings, byte counts, protocol, error, and the redirect chain.
+     */
+    onCompleted?: (event: NetworkRequestCompletedEvent) => void;
+};
+/**
+ * Subscribes to the native network-request observer for the lifetime of the component. Each
+ * mount allocates a `NetworkRequestObserver` SharedObject; unmount releases it and the native
+ * delegate slot is reclaimed.
+ */
+export declare function useNetworkRequestObserver(options?: UseNetworkRequestObserverOptions): NetworkRequestObserver;
+//# sourceMappingURL=useNetworkRequestObserver.d.ts.map
\ No newline at end of file
diff --git a/packages/expo-app-metrics/build/useNetworkRequestObserver.d.ts.map b/packages/expo-app-metrics/build/useNetworkRequestObserver.d.ts.map
new file mode 100644
index 00000000000000..dbb831c3b68cdb
--- /dev/null
+++ b/packages/expo-app-metrics/build/useNetworkRequestObserver.d.ts.map
@@ -0,0 +1 @@
+{"version":3,"file":"useNetworkRequestObserver.d.ts","sourceRoot":"","sources":["../src/useNetworkRequestObserver.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,4BAA4B,EAC5B,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,gCAAgC,GAAG;IAC7C;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,CAAC;IAExD;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,IAAI,CAAC;CAC7D,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,sBAAsB,CAOxB"}
\ No newline at end of file
diff --git a/packages/expo-app-metrics/ios/AppMetrics.swift b/packages/expo-app-metrics/ios/AppMetrics.swift
index a1fb1f7793fbf9..c3ffcbc5d0aea4 100644
--- a/packages/expo-app-metrics/ios/AppMetrics.swift
+++ b/packages/expo-app-metrics/ios/AppMetrics.swift
@@ -134,7 +134,7 @@ public struct AppMetrics {
   internal static func startNewForegroundSession() {
     AppMetricsActor.isolated {
       if let foregroundSession = Self.foregroundSession {
-        log.warn("[AppMetrics] New foreground session started while one was already active. Stopping the old session.")
+        logger.warn("[AppMetrics] New foreground session started while one was already active. Stopping the old session.")
         foregroundSession.stop()
       }
       foregroundSession = ForegroundSession()
diff --git a/packages/expo-app-metrics/ios/AppMetricsAppDelegateSubscriber.swift b/packages/expo-app-metrics/ios/AppMetricsAppDelegateSubscriber.swift
index edf3604e0376eb..bcdbd235e93bfa 100644
--- a/packages/expo-app-metrics/ios/AppMetricsAppDelegateSubscriber.swift
+++ b/packages/expo-app-metrics/ios/AppMetricsAppDelegateSubscriber.swift
@@ -3,8 +3,14 @@ import ExpoModulesCore
 public class AppMetricsAppDelegateSubscriber: ExpoAppDelegateSubscriber {
   public func appDelegateWillBeginInitialization() {
     AppMetrics.mainSession.appStartupMonitor.markMain()
+    // Install the URLSessionTask swizzles synchronously before any app code (RN included) issues
+    // its first network request. Doing this on the `AppMetricsActor` would defer it past that
+    // point, so it stays inline here. `install()` is idempotent — subsequent app-delegate calls
+    // are no-ops.
+    NetworkRequestTaskSwizzling.install()
     AppMetricsActor.isolated {
       NetworkPathMonitor.shared.start()
+      NetworkRequestMonitor.shared.start()
     }
   }
 
diff --git a/packages/expo-app-metrics/ios/AppMetricsModule.swift b/packages/expo-app-metrics/ios/AppMetricsModule.swift
index 6f2a00297cfb01..0ea63d40e7429b 100644
--- a/packages/expo-app-metrics/ios/AppMetricsModule.swift
+++ b/packages/expo-app-metrics/ios/AppMetricsModule.swift
@@ -75,10 +75,11 @@ public final class AppMetricsModule: Module, UpdatesStateChangeListener {
       // no-op
     }
 
-    AsyncFunction("getAllSessions") { () -> [StoredSession] in
+    // Debug-only: the inactive (ended) sessions
+    AsyncFunction("getInactiveSessions") { () -> [StoredSession] in
       return try await AppMetricsActor.isolated {
         return try AppMetrics.database?
-          .getAllSessionsWithChildren()
+          .getInactiveSessionsWithChildren()
           .map { StoredSession(from: $0) } ?? []
       }.value
     }
@@ -93,9 +94,7 @@ public final class AppMetricsModule: Module, UpdatesStateChangeListener {
     AsyncFunction("getMainSession") { () -> StoredSession? in
       return try await AppMetricsActor.isolated {
         let mainSessionId = AppMetrics.mainSession.id
-        guard let row = try AppMetrics.database?
-          .getAllSessionsWithChildren()
-          .first(where: { $0.session.id == mainSessionId }) else {
+        guard let row = try AppMetrics.database?.getSessionWithChildren(id: mainSessionId) else {
           return nil
         }
         return StoredSession(from: row)
@@ -117,6 +116,12 @@ public final class AppMetricsModule: Module, UpdatesStateChangeListener {
       case .stackOverflow: CrashTriggers.stackOverflow()
       }
     }
+
+    Class(NetworkRequestObserver.self) {
+      Constructor {
+        return NetworkRequestObserver()
+      }
+    }
   }
 
   public func updatesStateDidChange(_ event: [String : Any]) {
diff --git a/packages/expo-app-metrics/ios/AppStartup/AppStartupMarkers.swift b/packages/expo-app-metrics/ios/AppStartup/AppStartupMarkers.swift
index 35c16898298938..0f60d197f1b1d5 100644
--- a/packages/expo-app-metrics/ios/AppStartup/AppStartupMarkers.swift
+++ b/packages/expo-app-metrics/ios/AppStartup/AppStartupMarkers.swift
@@ -1,3 +1,5 @@
+import Foundation
+
 final class AppStartupMarkers: Sendable {
   let loadTime: TimeInterval = AppLoadTimeProvider.getLoadTime()
 
@@ -7,6 +9,14 @@ final class AppStartupMarkers: Sendable {
   @AppMetricsActor
   var finishedLaunching: TimeInterval?
 
+  /**
+   Wall-clock companion to `finishedLaunching`. `NetworkRequest.timings.fetchStart` uses `Date`
+   (not `CACurrentMediaTime`) so summarizing requests over the launch window needs an anchor in
+   the same domain.
+   */
+  @AppMetricsActor
+  var finishedLaunchingDate: Date?
+
   @AppMetricsActor
   var timeToFirstRender: TimeInterval?
 
diff --git a/packages/expo-app-metrics/ios/AppStartup/AppStartupMonitoring.swift b/packages/expo-app-metrics/ios/AppStartup/AppStartupMonitoring.swift
index a4aa47f4760891..121950af0346fa 100644
--- a/packages/expo-app-metrics/ios/AppStartup/AppStartupMonitoring.swift
+++ b/packages/expo-app-metrics/ios/AppStartup/AppStartupMonitoring.swift
@@ -42,12 +42,14 @@ final class AppStartupMonitoring: MetricReporter, @unchecked Sendable {
       return
     }
     let currentTime = CACurrentMediaTime()
+    let currentDate = Date()
 
     AppMetricsActor.isolated { [self] in
       if startupState != .launching {
         return
       }
       markers.finishedLaunching = currentTime
+      markers.finishedLaunchingDate = currentDate
 
       // Start tracking frame metrics from this point so the data
       // matches the TTI window (finishedLaunching → markInteractive).
@@ -105,11 +107,18 @@ final class AppStartupMonitoring: MetricReporter, @unchecked Sendable {
         let frameMetrics = frameMetricsRecorder.stop()
         let deviceState = await DeviceConditions.deviceState()
         let networkPath = await NetworkPathMonitor.shared.waitForFirstPath()
+        let networkRequests: NetworkRequestSummary? = {
+          guard let anchor = markers.finishedLaunchingDate else {
+            return nil
+          }
+          return NetworkRequestMonitor.shared.summarize(start: anchor, end: Date())
+        }()
         let mergedParams = MetricParamsBuilder.build(
           userParams: params,
           frameMetrics: frameMetrics,
           deviceState: deviceState,
-          networkPath: networkPath
+          networkPath: networkPath,
+          networkRequests: networkRequests
         )
         let metric = Metric(
           category: .appStartup,
diff --git a/packages/expo-app-metrics/ios/Database/MetricsDatabase.swift b/packages/expo-app-metrics/ios/Database/MetricsDatabase.swift
index 5cb1733c4aac9d..9ec79c388a7034 100644
--- a/packages/expo-app-metrics/ios/Database/MetricsDatabase.swift
+++ b/packages/expo-app-metrics/ios/Database/MetricsDatabase.swift
@@ -301,23 +301,46 @@ final class MetricsDatabase: Sendable {
     }
   }
 
+  /**
+   Returns the `main` sessions — newest first — for crash-report attribution. Crashes from past
+   launches (delivered by MetricKit on a later launch) are matched against these.
+   */
   @AppMetricsActor
-  func getAllSessions() throws -> [SessionRow] {
-    return try collectSessions(sql: "SELECT \(sessionColumns) FROM sessions ORDER BY startTimestamp DESC")
+  func getMainSessions() throws -> [SessionRow] {
+    return try collectSessions(
+      sql: "SELECT \(sessionColumns) FROM sessions WHERE type = 'main' ORDER BY startTimestamp DESC"
+    )
   }
 
   /**
-   Returns every session along with its metrics, logs, and crash report — newest first. Used by the
-   JS-facing read APIs and (filtered down) by the dispatch path.
+   Returns the inactive (ended) sessions along with their metrics, logs, and crash report — newest
+   first. Backs the debug-only `getInactiveSessions` JS API.
    */
   @AppMetricsActor
-  func getAllSessionsWithChildren() throws -> [SessionWithChildren] {
-    return try getAllSessions().map { session in
-      let metrics = try getMetrics(sessionId: session.id)
-      let logs = try getLogs(sessionId: session.id)
-      let crash = try getCrashReport(sessionId: session.id)
-      return SessionWithChildren(session: session, metrics: metrics, logs: logs, crashReportJSON: crash)
+  func getInactiveSessionsWithChildren() throws -> [SessionWithChildren] {
+    return try getInactiveSessions().compactMap { try getSessionWithChildren(id: $0.id) }
+  }
+
+  /**
+   Returns a single session along with its metrics, logs, and crash report, or `nil` if no session
+   with that id exists.
+   */
+  @AppMetricsActor
+  func getSessionWithChildren(id: String) throws -> SessionWithChildren? {
+    guard let session = try getSession(id: id) else {
+      return nil
     }
+    let metrics = try getMetrics(sessionId: session.id)
+    let logs = try getLogs(sessionId: session.id)
+    let crash = try getCrashReport(sessionId: session.id)
+    return SessionWithChildren(session: session, metrics: metrics, logs: logs, crashReportJSON: crash)
+  }
+
+  @AppMetricsActor
+  func getInactiveSessions() throws -> [SessionRow] {
+    return try collectSessions(
+      sql: "SELECT \(sessionColumns) FROM sessions WHERE isActive = 0 ORDER BY startTimestamp DESC"
+    )
   }
 
   /**
diff --git a/packages/expo-app-metrics/ios/MetricKitSubscriber.swift b/packages/expo-app-metrics/ios/MetricKitSubscriber.swift
index d30868e51ec588..cb97e31f2293bc 100644
--- a/packages/expo-app-metrics/ios/MetricKitSubscriber.swift
+++ b/packages/expo-app-metrics/ios/MetricKitSubscriber.swift
@@ -41,7 +41,7 @@ final class MetricKitSubscriber: NSObject, MXMetricManagerSubscriber, Sendable {
     AppMetricsActor.isolated {
       let mainSessions: [SessionRow]
       do {
-        mainSessions = try AppMetrics.database?.getAllSessions().filter { $0.type == Session.SessionType.main.rawValue } ?? []
+        mainSessions = try AppMetrics.database?.getMainSessions() ?? []
       } catch {
         logger.warn("[AppMetrics] Failed to load main sessions for crash attribution: \(error.localizedDescription)")
         return
diff --git a/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequest.swift b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequest.swift
new file mode 100644
index 00000000000000..d46837f2868729
--- /dev/null
+++ b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequest.swift
@@ -0,0 +1,224 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import Foundation
+
+/**
+ A `Sendable` snapshot of a single HTTP request observed by `NetworkRequestTaskSwizzling`.
+
+ The shape is intentionally close to `URLSessionTaskTransactionMetrics` so we can plumb individual
+ timing phases into telemetry later without redesigning the type. Until the metrics pipeline is
+ wired up, this is what gets handed to `NetworkRequestObserverDelegate` callers.
+
+ The URL is recorded verbatim — including the query string — because callers asked for it. Any
+ redaction (tokens in query parameters, auth headers, etc.) is the responsibility of whatever
+ downstream layer converts these snapshots into stored metrics.
+ */
+public struct NetworkRequest: Sendable, Equatable, Identifiable {
+  /** Stable identifier for this observation. Generated by the protocol class. */
+  public let id: UUID
+
+  /** Request URL as supplied to `URLSession`. May include query parameters and fragments. */
+  public let url: URL
+
+  /** HTTP method (`GET`, `POST`, …). Defaults to `GET` if `URLRequest.httpMethod` was nil. */
+  public let method: String
+
+  /** Response status code, or `nil` if the request failed before headers were received. */
+  public let statusCode: Int?
+
+  /**
+   Negotiated wire protocol — `http/1.1`, `h2`, `h3` — as reported by
+   `URLSessionTaskTransactionMetrics.networkProtocolName`. `nil` for cache hits or when the OS
+   didn't report one.
+   */
+  public let networkProtocol: String?
+
+  /** Number of bytes sent on the wire for the request (headers + body). */
+  public let requestBytesSent: Int64?
+
+  /** Number of bytes received on the wire for the response (headers + body). */
+  public let responseBytesReceived: Int64?
+
+  /** Phase-by-phase timings pulled from the most recent (post-redirect) transaction. */
+  public let timings: Timings
+
+  /**
+   Short human-readable error description if the task completed with an error. We keep this as a
+   string rather than carrying `NSError` so the type stays `Sendable` and serializable.
+   */
+  public let errorDescription: String?
+
+  /**
+   Ordered list of redirect hops that preceded the final response. Empty when the task returned
+   directly. Each entry describes one hop: `fromUrl` is the URL that returned the redirect,
+   `statusCode` is the 3xx code it returned, and `toUrl` is where the redirect pointed. For a
+   complete chain the first entry's `fromUrl` equals the parent event's `url`, and the last
+   entry's `toUrl` is where the request actually landed.
+   */
+  public let redirects: [Redirect]
+
+  public struct Redirect: Sendable, Equatable {
+    /** The URL that returned the redirect. */
+    public let fromUrl: URL
+    /** The URL the request was redirected to. */
+    public let toUrl: URL
+    /** The 3xx status code returned by `fromUrl` that caused this hop. */
+    public let statusCode: Int
+  }
+
+  public struct Timings: Sendable, Equatable {
+    /** When the task was started (`URLSessionTaskTransactionMetrics.fetchStartDate`). */
+    public let fetchStart: Date?
+
+    /** When DNS resolution began. `nil` if the host was resolved from cache or the connection was reused. */
+    public let domainLookupStart: Date?
+    public let domainLookupEnd: Date?
+
+    /** When the TCP connection began. `nil` if a connection was reused. */
+    public let connectStart: Date?
+    public let connectEnd: Date?
+
+    /** TLS handshake window. `nil` for cleartext or reused connections. */
+    public let secureConnectionStart: Date?
+    public let secureConnectionEnd: Date?
+
+    /** When the request line began being sent. */
+    public let requestStart: Date?
+    public let requestEnd: Date?
+
+    /** When the first byte of the response arrived (TTFB). */
+    public let responseStart: Date?
+    public let responseEnd: Date?
+
+    /**
+     Total wall-clock duration of the task. Convenience: callers don't have to subtract
+     `fetchStart` from `responseEnd` themselves, and we can populate this even when the
+     individual phases are `nil` (cache hits, errors before headers).
+     */
+    public let totalDuration: TimeInterval
+  }
+}
+
+/**
+ Lightweight snapshot emitted when a request begins, before any response or timing data exists.
+ Shares its `id` with the corresponding completion-time `NetworkRequest`, so JS subscribers can
+ correlate the two events.
+ */
+public struct NetworkRequestStarted: Sendable, Equatable, Identifiable {
+  public let id: UUID
+  public let url: URL
+  public let method: String
+  public let startedAt: Date
+}
+
+extension NetworkRequest {
+  /**
+   Builds a snapshot from the data we have at task completion. The metrics argument may be `nil`
+   for cache-only responses or in tests; in that case, callers fall back to wall-clock timestamps
+   on the request/response pair.
+
+   `taskBytesSent` / `taskBytesReceived` are the task's wall-clock byte counters
+   (`URLSessionTask.countOfBytesSent` / `countOfBytesReceived`). Pass `nil` when no task is
+   available (tests). They're used as a fallback when `metrics`'s per-transaction counters are
+   zero — see the body for the cache-hit / Simulator quirks that hit that case.
+   */
+  static func from(
+    id: UUID,
+    request: URLRequest,
+    response: HTTPURLResponse?,
+    taskBytesSent: Int64?,
+    taskBytesReceived: Int64?,
+    metrics: URLSessionTaskMetrics?,
+    fallbackStart: Date,
+    fallbackEnd: Date,
+    error: Error?
+  ) -> NetworkRequest {
+    let url = request.url ?? URL(string: "about:blank")!
+    let method = request.httpMethod ?? "GET"
+
+    // We use the last transaction so that redirects don't drop us back to the first hop. If a
+    // future need arises to surface per-hop timing, expose `metrics.transactionMetrics` here.
+    let transaction = metrics?.transactionMetrics.last
+
+    let timings = NetworkRequest.Timings(
+      fetchStart: transaction?.fetchStartDate ?? fallbackStart,
+      domainLookupStart: transaction?.domainLookupStartDate,
+      domainLookupEnd: transaction?.domainLookupEndDate,
+      connectStart: transaction?.connectStartDate,
+      connectEnd: transaction?.connectEndDate,
+      secureConnectionStart: transaction?.secureConnectionStartDate,
+      secureConnectionEnd: transaction?.secureConnectionEndDate,
+      requestStart: transaction?.requestStartDate,
+      requestEnd: transaction?.requestEndDate,
+      responseStart: transaction?.responseStartDate,
+      responseEnd: transaction?.responseEndDate ?? fallbackEnd,
+      totalDuration: metrics?.taskInterval.duration ?? fallbackEnd.timeIntervalSince(fallbackStart)
+    )
+
+    // Prefer the transaction's header+body split when it reports non-zero, fall back to the task's
+    // wall-clock counters otherwise. The transaction counters are 0 in two real cases:
+    // (1) cache hits — `resourceFetchType == .localCache`, no wire traffic occurred;
+    // (2) iOS Simulator — Apple's socket-level instrumentation isn't always wired up there, so
+    //     the counters return 0 even when the request actually moved bytes. `task.countOfBytesSent/
+    //     Received` is wall-clock accurate in both environments.
+    let requestBytesSent: Int64? = {
+      if let transaction {
+        let fromTransaction = transaction.countOfRequestHeaderBytesSent + transaction.countOfRequestBodyBytesSent
+        if fromTransaction > 0 {
+          return fromTransaction
+        }
+      }
+      return taskBytesSent
+    }()
+    let responseBytesReceived: Int64? = {
+      if let transaction {
+        let fromTransaction = transaction.countOfResponseHeaderBytesReceived + transaction.countOfResponseBodyBytesReceived
+        if fromTransaction > 0 {
+          return fromTransaction
+        }
+      }
+      return taskBytesReceived
+    }()
+
+    // Each redirect entry pairs the 3xx status from one transaction with the URLs on either side
+    // of the hop: `fromUrl` is the URL we requested that returned the redirect, `toUrl` is the
+    // URL the redirect pointed to (which is the next transaction's request URL).
+    //
+    // `transactionMetrics` can contain non-redirect transactions too (HTTP/2 → HTTP/3 Alt-Svc
+    // upgrades, connection retries, HTTP → HTTPS upgrades), so we filter explicitly on 3xx
+    // status codes rather than assuming "everything before the last is a redirect."
+    let redirects: [Redirect] = {
+      guard let transactions = metrics?.transactionMetrics, transactions.count > 1 else {
+        return []
+      }
+      var result: [Redirect] = []
+      for index in 0..<(transactions.count - 1) {
+        let current = transactions[index]
+        let next = transactions[index + 1]
+        guard
+          let response = current.response as? HTTPURLResponse,
+          (300..<400).contains(response.statusCode),
+          let fromUrl = current.request.url,
+          let toUrl = next.request.url
+        else {
+          continue
+        }
+        result.append(Redirect(fromUrl: fromUrl, toUrl: toUrl, statusCode: response.statusCode))
+      }
+      return result
+    }()
+
+    return NetworkRequest(
+      id: id,
+      url: url,
+      method: method,
+      statusCode: response?.statusCode,
+      networkProtocol: transaction?.networkProtocolName,
+      requestBytesSent: requestBytesSent,
+      responseBytesReceived: responseBytesReceived,
+      timings: timings,
+      errorDescription: error.map { ($0 as NSError).localizedDescription },
+      redirects: redirects
+    )
+  }
+}
diff --git a/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestMonitor.swift b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestMonitor.swift
new file mode 100644
index 00000000000000..d8c9279630e576
--- /dev/null
+++ b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestMonitor.swift
@@ -0,0 +1,130 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import Foundation
+
+/**
+ Receives notifications about HTTP requests observed by `NetworkRequestTaskSwizzling`. Both
+ methods have default no-op implementations so delegates can opt into either start- or
+ complete-time notifications without having to implement the other.
+ */
+public protocol NetworkRequestObserverDelegate: AnyObject, Sendable {
+  func onNetworkRequestStarted(_ request: NetworkRequestStarted)
+  func onNetworkRequestCompleted(_ request: NetworkRequest)
+}
+
+public extension NetworkRequestObserverDelegate {
+  func onNetworkRequestStarted(_ request: NetworkRequestStarted) {}
+  func onNetworkRequestCompleted(_ request: NetworkRequest) {}
+}
+
+/**
+ A singleton that aggregates `NetworkRequest` snapshots delivered by the URLSessionTask swizzles.
+
+ The monitor is the central seam between the swizzle layer (which observes individual tasks
+ complete) and whatever future layer routes those observations into telemetry. For now it keeps a
+ small in-memory ring buffer of recent requests (useful for debug surfaces and tests) and fans
+ each completion out to registered delegates.
+
+ Started eagerly at app launch (see `AppMetricsAppDelegateSubscriber.appDelegateWillBeginInitialization`)
+ so the swizzles run before React Native makes its first fetch.
+ */
+@AppMetricsActor
+public final class NetworkRequestMonitor: Sendable {
+  public static let shared = NetworkRequestMonitor()
+
+  /** Maximum number of recent requests retained for debug surfaces. */
+  private let recentCapacity = 200
+
+  private var recentRequests: [NetworkRequest] = []
+  private var delegates: [WeakDelegate] = []
+  private var started = false
+
+  /** Internal so tests can construct dedicated instances; production code uses `shared`. */
+  init() {}
+
+  /**
+   Confirms the URLSessionTask swizzles are installed. The app-delegate subscriber already
+   installs them synchronously at launch (before the first request); this re-asserts the install
+   for any path that reaches the monitor without going through the subscriber. Idempotent —
+   subsequent calls are no-ops.
+   */
+  func start() {
+    if started {
+      return
+    }
+    started = true
+    NetworkRequestTaskSwizzling.install()
+  }
+
+  /**
+   Most recently observed requests, oldest first. Bounded by `recentCapacity`. Intended for
+   debug surfaces; not for the dispatch path.
+   */
+  public var recent: [NetworkRequest] {
+    return recentRequests
+  }
+
+  /**
+   Folds the requests whose `timings.fetchStart` falls within `[start, end]` into a summary.
+   Used by the TTI metric to attach a per-launch network rollup. Bounded by the ring buffer:
+   under heavy network load the earliest requests in the window may have been evicted, in
+   which case the summary undercounts — acceptable for a TTI-attached signal.
+   */
+  func summarize(start: Date, end: Date) -> NetworkRequestSummary {
+    let inWindow = recentRequests.filter { request in
+      guard let fetchStart = request.timings.fetchStart else {
+        return false
+      }
+      return fetchStart >= start && fetchStart <= end
+    }
+    return NetworkRequestSummary.from(inWindow)
+  }
+
+  /**
+   Adds a delegate that will be notified for each completed request. Delegates are held weakly.
+   */
+  public func addDelegate(_ delegate: NetworkRequestObserverDelegate) {
+    pruneDelegates()
+    delegates.append(WeakDelegate(value: delegate))
+  }
+
+  public func removeDelegate(_ delegate: NetworkRequestObserverDelegate) {
+    delegates.removeAll { $0.value === delegate || $0.value == nil }
+  }
+
+  /**
+   Records a completed request: appends to the ring buffer and fans it out to delegates. Called
+   from `NetworkRequestTaskSwizzling.recordCompletion` (which fires from either the delegate proxy's
+   metrics callback or the `setState:` fallback) on the `AppMetricsActor`.
+   */
+  func record(_ request: NetworkRequest) {
+    recentRequests.append(request)
+    if recentRequests.count > recentCapacity {
+      recentRequests.removeFirst(recentRequests.count - recentCapacity)
+    }
+    pruneDelegates()
+    for entry in delegates {
+      entry.value?.onNetworkRequestCompleted(request)
+    }
+  }
+
+  /**
+   Records that a request has begun. No ring-buffer entry — the started snapshot is purely a
+   notification used to surface in-flight state to subscribers. The corresponding completion
+   event will arrive later with a matching `id`.
+   */
+  func recordStart(_ request: NetworkRequestStarted) {
+    pruneDelegates()
+    for entry in delegates {
+      entry.value?.onNetworkRequestStarted(request)
+    }
+  }
+
+  private func pruneDelegates() {
+    delegates.removeAll { $0.value == nil }
+  }
+
+  private struct WeakDelegate {
+    weak var value: NetworkRequestObserverDelegate?
+  }
+}
diff --git a/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestObserver.swift b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestObserver.swift
new file mode 100644
index 00000000000000..b95e2b341f2447
--- /dev/null
+++ b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestObserver.swift
@@ -0,0 +1,87 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import Foundation
+
+/** Event names emitted by `NetworkRequestObserver`, matching the keys in the JS
+ `NetworkRequestObserverEvents` type. */
+let REQUEST_STARTED_EVENT = "requestStarted"
+let REQUEST_COMPLETED_EVENT = "requestCompleted"
+
+/**
+ JS-facing `SharedObject` that bridges per-instance subscriptions to the singleton
+ `NetworkRequestMonitor`. Each JS `new NetworkRequestObserver()` allocates one of these and
+ registers it as a delegate; the native instance is released when JS drops the reference, at
+ which point `sharedObjectWillRelease` removes the delegate registration.
+
+ The class only forwards events — it doesn't store request history. Use `NetworkRequestMonitor`'s
+ in-process API for that.
+ */
+public final class NetworkRequestObserver: SharedObject, NetworkRequestObserverDelegate, @unchecked Sendable {
+  public override init() {
+    super.init()
+    AppMetricsActor.isolated { [weak self] in
+      guard let self else {
+        return
+      }
+      NetworkRequestMonitor.shared.addDelegate(self)
+    }
+  }
+
+  public override func sharedObjectWillRelease() {
+    // The monitor holds delegates weakly, but deregister explicitly so the slot doesn't linger
+    // until the next fan-out prunes it — matches the Android `sharedObjectDidRelease` cleanup.
+    AppMetricsActor.isolated { [weak self] in
+      guard let self else {
+        return
+      }
+      NetworkRequestMonitor.shared.removeDelegate(self)
+    }
+    super.sharedObjectWillRelease()
+  }
+
+  // MARK: - NetworkRequestObserverDelegate
+
+  public func onNetworkRequestStarted(_ request: NetworkRequestStarted) {
+    emit(event: REQUEST_STARTED_EVENT, payload: NetworkRequestObserver.startedPayload(for: request))
+  }
+
+  public func onNetworkRequestCompleted(_ request: NetworkRequest) {
+    emit(event: REQUEST_COMPLETED_EVENT, payload: NetworkRequestObserver.completedPayload(for: request))
+  }
+
+  /** Internal so tests can assert the payload shape without going through `emit`, which needs a
+   live JS runtime. The keys here are part of the public JS contract — additions are safe but
+   renames are breaking. */
+  static func startedPayload(for request: NetworkRequestStarted) -> [String: Any?] {
+    return [
+      "id": request.id.uuidString,
+      "url": request.url.absoluteString,
+      "method": request.method,
+      "startedAt": request.startedAt.ISO8601Format()
+    ]
+  }
+
+  static func completedPayload(for request: NetworkRequest) -> [String: Any?] {
+    return [
+      "id": request.id.uuidString,
+      "url": request.url.absoluteString,
+      "method": request.method,
+      "statusCode": request.statusCode,
+      "networkProtocol": request.networkProtocol,
+      "requestBytesSent": request.requestBytesSent,
+      "responseBytesReceived": request.responseBytesReceived,
+      "errorDescription": request.errorDescription,
+      "startedAt": request.timings.fetchStart?.ISO8601Format(),
+      "completedAt": request.timings.responseEnd?.ISO8601Format(),
+      "totalDuration": request.timings.totalDuration,
+      "redirects": request.redirects.map {
+        return [
+          "fromUrl": $0.fromUrl.absoluteString,
+          "toUrl": $0.toUrl.absoluteString,
+          "statusCode": $0.statusCode
+        ]
+      }
+    ]
+  }
+}
diff --git a/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestSummary.swift b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestSummary.swift
new file mode 100644
index 00000000000000..99f9423152de3c
--- /dev/null
+++ b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestSummary.swift
@@ -0,0 +1,108 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import Foundation
+
+/**
+ An aggregate over a set of `NetworkRequest` snapshots. Designed to be flattened into a metric's
+ `params` map, so all fields are simple value types and the type itself stays `Sendable`.
+
+ The summary is intentionally small. Anything that would explode cardinality (per-URL p95s, full
+ request lists) belongs in a separate metric/table once we ship one — not on the TTI envelope.
+ */
+public struct NetworkRequestSummary: Sendable, Equatable {
+  /** Number of requests in the window. */
+  public let count: Int
+
+  /** Requests that errored or returned a non-2xx status. */
+  public let failed: Int
+
+  /** Sum of `responseBytesReceived` across all requests in the window. */
+  public let bytesReceived: Int64
+
+  /** Sum of `requestBytesSent` across all requests in the window. */
+  public let bytesSent: Int64
+
+  /** Sum of `timings.totalDuration` across all requests. Can exceed wall-clock when requests overlap. */
+  public let totalDuration: TimeInterval
+
+  /** Longest single request duration in the window, or `nil` if `count == 0`. */
+  public let slowestDuration: TimeInterval?
+
+  /** Host of the slowest request, or `nil` if the request had no resolvable host. */
+  public let slowestHost: String?
+
+  /** Convenience: returns `nil` when the summary is empty so callers can skip emitting fields. */
+  public var isEmpty: Bool {
+    return count == 0
+  }
+
+  static let empty = NetworkRequestSummary(
+    count: 0,
+    failed: 0,
+    bytesReceived: 0,
+    bytesSent: 0,
+    totalDuration: 0,
+    slowestDuration: nil,
+    slowestHost: nil
+  )
+
+  /**
+   Folds a sequence of `NetworkRequest` into a summary. The caller is responsible for filtering
+   the sequence to the desired window.
+   */
+  static func from(_ requests: [NetworkRequest]) -> NetworkRequestSummary {
+    if requests.isEmpty {
+      return .empty
+    }
+    var failed = 0
+    var bytesReceived: Int64 = 0
+    var bytesSent: Int64 = 0
+    var totalDuration: TimeInterval = 0
+    var slowest: NetworkRequest?
+
+    for request in requests {
+      if request.isFailed {
+        failed += 1
+      }
+      bytesReceived += request.responseBytesReceived ?? 0
+      bytesSent += request.requestBytesSent ?? 0
+      totalDuration += request.timings.totalDuration
+      if let current = slowest {
+        if request.timings.totalDuration > current.timings.totalDuration {
+          slowest = request
+        }
+      } else {
+        slowest = request
+      }
+    }
+
+    return NetworkRequestSummary(
+      count: requests.count,
+      failed: failed,
+      bytesReceived: bytesReceived,
+      bytesSent: bytesSent,
+      totalDuration: totalDuration,
+      slowestDuration: slowest?.timings.totalDuration,
+      slowestHost: slowest?.url.host
+    )
+  }
+}
+
+extension NetworkRequest {
+  /**
+   A request is treated as failed if it errored, or returned a 4xx (client error) or 5xx (server
+   error) status. 1xx (informational), 2xx (success), and 3xx (redirection — usually followed
+   transparently by URLSession, but the unfollowed case is still a successful response from the
+   origin's perspective) are not failures. A missing status code (the request failed before
+   headers arrived) counts as failed.
+   */
+  var isFailed: Bool {
+    if errorDescription != nil {
+      return true
+    }
+    guard let statusCode else {
+      return true
+    }
+    return statusCode >= 400
+  }
+}
diff --git a/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestTaskSwizzling.swift b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestTaskSwizzling.swift
new file mode 100644
index 00000000000000..6ab19b5d8cb6ad
--- /dev/null
+++ b/packages/expo-app-metrics/ios/NetworkRequests/NetworkRequestTaskSwizzling.swift
@@ -0,0 +1,638 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import Foundation
+import ObjectiveC
+import ExpoModulesCore
+
+/**
+ Process-wide observation of every `URLSessionTask` that runs on any `URLSession` the app creates.
+
+ ## Why method swizzling instead of `URLProtocol`
+
+ An earlier draft of this module used a `URLProtocol` subclass plus configuration swizzling. That
+ has a fundamental flaw: a `URLProtocol` only sees the `URLRequest`, not the originating
+ `URLSession`. To actually run the request we replayed it through a singleton inner session,
+ which silently dropped per-session state — cookies, proxy, TLS settings, `httpAdditionalHeaders`,
+ cache policy — and broke the very isolation guarantees ephemeral sessions are picked for.
+
+ The established observability SDKs (Sentry, Datadog, Bugsnag, New Relic) all converged on method
+ swizzling at the `URLSessionTask` level. We do the same here.
+
+ ## What we swizzle
+
+ Two methods on `__NSCFLocalSessionTask`, the private concrete class that backs every public
+ `URLSessionTask` on iOS 12+. The class name has been stable across iOS versions; the same
+ approach is used in production by Datadog and Bugsnag.
+
+ 1. **`-resume`** — fires once per task at start time. We attach an `ObservationContext` to the
+    task via `objc_setAssociatedObject` so observation state travels with it across delegate
+    callbacks and threads, and emit `requestStarted`.
+
+ 2. **`-setState:`** — fires on every state transition. On `.completed` we read `task.error`,
+    `task.response`, and the task's wall-clock byte counters, build a `NetworkRequest`
+    snapshot, and emit `requestCompleted`.
+
+ The `setState:` hook is the universal completion seam: it fires for tasks created with a
+ completion handler (no public delegate path), tasks running on `URLSession.shared` (Apple's
+ private delegate), and tasks awaited via `async`/`await`. Delegate-based completion handlers
+ alone would miss all three.
+
+ ## Per-phase metrics via delegate proxy
+
+ `URLSessionTaskMetrics` (redirect chain, DNS/connect/TLS timestamps) is only available through
+ `urlSession(_:task:didFinishCollecting:)`, which requires a session delegate. We swizzle
+ `+sessionWithConfiguration:delegate:delegateQueue:` to wrap the caller's delegate in a
+ `DelegateProxy` that captures metrics into the task's `ObservationContext` while forwarding
+ every other selector to the caller's original delegate via Objective-C method forwarding.
+
+ Tasks without a delegate (the shared session, completion-handler tasks) still get observed via
+ the `setState:` hook — they just won't carry per-phase metric detail.
+
+ ## Recursion safety
+
+ expo-observe sets `Expo-AppMetrics-Skip: 1` on outgoing telemetry uploads. The `resume` swizzle
+ checks for this header on `task.originalRequest` and skips attaching observation state. The
+ header is forwarded to the server as-is — it lands on o.expo.dev, which we control.
+
+ ## What we don't catch
+
+ - **WebSocket tasks.** `URLSessionWebSocketTask` extends `URLSessionTask` so the swizzles fire,
+   but websockets don't produce meaningful HTTP metrics. We skip them inside the `resume` hook.
+
+ ## Dev-launcher interop
+
+ When expo-dev-launcher's network inspector is active (`EX_DEV_CLIENT_NETWORK_INSPECTOR` debug
+ flag), `ExpoRequestInterceptorProtocol` runs every user-facing fetch through a replay on its
+ own private `URLSession`. The user-facing fetch produces two `__NSCFLocalSessionTask` instances:
+
+ - an **outer** task on the caller's `URLSession`, which fires `resume` first but whose metrics
+   are degraded (the URLProtocol short-circuits the real network).
+ - an **inner** task on dev-launcher's `URLSession`, which carries the real
+   `URLSessionTaskMetrics` (redirect chain, per-phase timings, byte splits).
+
+ We pair them up by request URL: the outer's `resume` creates an `ObservationContext` and adds
+ it to `pendingReplays`; the inner's `resume` (microseconds later) claims it via
+ `takePendingReplay`, attaches the same context to the inner task, and flags the outer's
+ setState/metrics paths to short-circuit. Recording happens once, from the inner task's
+ `didFinishCollectingMetrics:` callback, carrying the inner task's real metrics and the outer's
+ `requestStarted` event id. See `pendingReplays` for the data structure.
+ */
+enum NetworkRequestTaskSwizzling {
+  /**
+   Header name any caller can set to opt a request out of observation. Outgoing telemetry uploads
+   in expo-observe set this so they don't recursively observe themselves.
+
+   The header is forwarded to the destination verbatim — once a `URLSessionTask` is created we
+   can't safely mutate `originalRequest`, so we read it but don't strip it. The intended use is
+   on requests to endpoints we control (o.expo.dev); setting it on a request to a third party
+   leaks `Expo-AppMetrics-Skip: 1` to that host.
+
+   No `X-` prefix per RFC 6648. Callers that can't import this constant (expo-observe must not
+   depend on app-metrics internals) hardcode the same literal — keep the two in sync if this
+   ever changes.
+   */
+  static let internalHeaderName = "Expo-AppMetrics-Skip"
+
+  /**
+   Property key that expo-dev-launcher's `ExpoRequestInterceptorProtocol` stamps on the inner
+   request it creates when replaying a request through its own `URLSession` (dev mode only, gated
+   on `EX_DEV_CLIENT_NETWORK_INSPECTOR`).
+
+   When the dev-launcher inspector is active, every user-facing fetch produces two tasks:
+   - an **outer** task created against the user's `URLSession`, with no property — fires `resume`
+     first but the network never goes through it (the URLProtocol intercepts).
+   - an **inner** task on dev-launcher's private `URLSession`, carrying this property — does the
+     actual network work and carries the real `URLSessionTaskMetrics` (redirects, per-phase
+     timings, byte splits).
+
+   We want one observation per logical fetch, with the inner task's metrics. The resume swizzle
+   moves the outer's `ObservationContext` to the inner via `pendingReplays` (URL-keyed) so the
+   inner records into the same id the user-facing `requestStarted` event used. The outer task's
+   setState/metrics callbacks then short-circuit on `context.replayedByDevLauncher`.
+
+   The literal must match `REQUEST_ID` in
+   `packages/expo-modules-core/ios/DevTools/ExpoRequestInterceptorProtocol.swift`. The value
+   is internal to that file (no public symbol); duplicating the string is the same trick the
+   expo-observe header constant uses. Keep them in sync.
+   */
+  fileprivate static let devLauncherRequestIdKey = "ExpoRequestInterceptorProtocol.requestId"
+
+  /// Installs the swizzles. Idempotent — guarded by `installed` so repeat calls are no-ops.
+  static func install() {
+    state.withLock { installed in
+      if installed {
+        return
+      }
+      installed = true
+
+      installResumeSwizzle()
+      installSetStateSwizzle()
+      installSessionInitSwizzle()
+    }
+  }
+
+  // MARK: - State
+
+  private static let state = Mutex<Bool>(false)
+
+  /// Marker key used by `objc_setAssociatedObject` to attach an `ObservationContext` to a task.
+  /// The value is never read - only the pointer's identity matters - so the "mutable global"
+  /// concurrency warning is a false positive. `nonisolated(unsafe)` opts out of the check.
+  /// File-scope so the `DelegateProxy` in this file can reach it through `&observationContextKey`.
+  nonisolated(unsafe) fileprivate static var observationContextKey: UInt8 = 0
+
+  /// Captured pointers to the original IMPs of the methods we swizzled, so the replacement blocks
+  /// can call through to Apple's implementation. `Mutex` because the blocks fire on whatever
+  /// thread `URLSessionTask` is operating on.
+  private static let originalResumeImp = Mutex<IMP?>(nil)
+  private static let originalSetStateImp = Mutex<IMP?>(nil)
+  private static let originalSessionInitImp = Mutex<IMP?>(nil)
+
+  /**
+   How long the `setState:` fallback waits before recording. Tasks observed via the delegate
+   proxy record from `didFinishCollectingMetrics:` first (with metrics) and flip `recorded=true`;
+   the fallback that fires after this delay sees the flag and skips. Delegate-less sessions
+   (`URLSession.shared`, completion-handler tasks) never get a metrics callback, so the fallback
+   wins and records without metrics — degraded but better than nothing.
+
+   200ms is comfortably above the observed inter-callback latency on real devices (typically a
+   few ms). The cost is a small latency before the `requestCompleted` event fires for delegate-
+   less traffic; acceptable for a passive observer.
+   */
+  private static let setStateFallbackDelay: TimeInterval = 0.2
+
+  /// Outer-task `ObservationContext`s waiting for the corresponding dev-launcher inner replay
+  /// task to fire `resume`. Keyed by request URL because that's the only identifier shared
+  /// across the outer/inner pair (the inner request is a mutable copy of the outer and carries
+  /// a different `ExpoRequestInterceptorProtocol.requestId` that isn't visible from the outer
+  /// task's `originalRequest`).
+  ///
+  /// FIFO list per URL handles concurrent fetches to the same URL: the inner task that fires
+  /// first picks up the oldest entry. Entries are removed when claimed; any entry whose
+  /// `expiresAt` has passed (request denied by another URLProtocol, dev-launcher disabled
+  /// mid-flight, etc.) is pruned on the next access so the dictionary doesn't grow unbounded.
+  private static let pendingReplays = Mutex<[URL: [(context: ObservationContext, expiresAt: Date)]]>([:])
+
+  /// Maximum time we'll keep an unclaimed outer context in `pendingReplays`. Outer/inner
+  /// `resume` calls are typically microseconds apart; 5 seconds is well above the worst case
+  /// while still keeping the dictionary bounded.
+  private static let pendingReplayTimeout: TimeInterval = 5
+
+  // MARK: - resume() swizzle
+
+  private static func installResumeSwizzle() {
+    guard let taskClass = NSClassFromString("__NSCFLocalSessionTask") else {
+      return
+    }
+    let selector = #selector(URLSessionTask.resume)
+    guard let method = class_getInstanceMethod(taskClass, selector) else {
+      return
+    }
+    let block: @convention(block) (URLSessionTask) -> Void = { task in
+      observeStart(task)
+      if let imp = originalResumeImp.withLock({ $0 }) {
+        let fn = unsafeBitCast(imp, to: (@convention(c) (AnyObject, Selector) -> Void).self)
+        fn(task, selector)
+      }
+    }
+    let newImp = imp_implementationWithBlock(block as Any)
+    let original = method_setImplementation(method, newImp)
+    originalResumeImp.withLock { $0 = original }
+  }
+
+  /// Called from the swizzled `resume`. Handles three cases:
+  ///
+  /// 1. **Dev-launcher inner replay task** (carries `devLauncherRequestIdKey` on its request):
+  ///    we already created an `ObservationContext` for the outer task. Pull it out of
+  ///    `pendingReplays` by URL, attach it to the inner task, and flag the original as
+  ///    `replayedByDevLauncher` so the outer's setState/metrics callbacks short-circuit. No new
+  ///    `requestStarted` is emitted — the outer already did that.
+  ///
+  /// 2. **Outer task under dev-launcher** (no property, but dev-launcher's protocol is
+  ///    installed): create the context, emit `requestStarted`, attach to the outer task as
+  ///    usual — and also add to `pendingReplays` so the inner replay task can pick it up when
+  ///    it `resume`s.
+  ///
+  /// 3. **Regular task** (no property, no dev-launcher): create context, attach, emit started.
+  ///
+  /// Plus the early-exit cases: websockets, internal opt-out header, non-HTTP schemes, and the
+  /// idempotency check against double-attaching on a re-resumed task.
+  private static func observeStart(_ task: URLSessionTask) {
+    if task is URLSessionWebSocketTask {
+      return
+    }
+    // `originalRequest` is the request as the caller submitted it. `URLProtocol`-style
+    // observers see `currentRequest` post-redirect; we deliberately log the caller's intent.
+    guard let request = task.originalRequest else {
+      return
+    }
+    guard let scheme = request.url?.scheme?.lowercased(), scheme == "http" || scheme == "https" else {
+      return
+    }
+    if request.value(forHTTPHeaderField: internalHeaderName) != nil {
+      return
+    }
+    // Idempotent: a second `resume` on the same task — including the internal re-resume that
+    // follows a 30x redirect — must not double-attach observation state.
+    if objc_getAssociatedObject(task, &observationContextKey) != nil {
+      return
+    }
+
+    // Dev-launcher inner replay task. Adopt the outer's context (so the snapshot keeps the same
+    // id as the user-facing `requestStarted` event) and let the inner drive recording from its
+    // `didFinishCollectingMetrics:` callback. The outer task's setState/metrics paths
+    // short-circuit on `context.replayedByDevLauncher`.
+    if URLProtocol.property(forKey: devLauncherRequestIdKey, in: request) != nil {
+      guard let url = request.url, let outerContext = takePendingReplay(for: url) else {
+        // No matching outer context (request opted out, fired before our swizzles installed,
+        // etc.). Don't observe — recording independently would still double-count.
+        return
+      }
+      outerContext.replayedByDevLauncher = true
+      objc_setAssociatedObject(task, &observationContextKey, outerContext, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+      return
+    }
+
+    let context = ObservationContext(
+      id: UUID(),
+      request: request,
+      startDate: Date(),
+      outerUrl: request.url
+    )
+    objc_setAssociatedObject(task, &observationContextKey, context, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+    // Always make the context discoverable by URL — if dev-launcher's interceptor protocol is
+    // in play, the inner replay task will claim it on its own `resume`. If not, the entry is
+    // removed when this request terminates (see `recordCompletion` → `removePendingReplay`).
+    // We considered gating this on a lazy `URLSessionConfiguration.default.protocolClasses`
+    // lookup but the lazy resolves on the first request, which may fire before dev-launcher
+    // registers its protocol — locking in the wrong answer for the lifetime of the process.
+    if let url = context.outerUrl {
+      addPendingReplay(context: context, for: url)
+    }
+
+    let started = NetworkRequestStarted(
+      id: context.id,
+      url: request.url ?? URL(string: "about:blank")!,
+      method: request.httpMethod ?? "GET",
+      startedAt: context.startDate
+    )
+    context.startNotification = AppMetricsActor.isolated {
+      NetworkRequestMonitor.shared.recordStart(started)
+    }
+  }
+
+  /// Adds an outer-task context to `pendingReplays` so the matching dev-launcher inner replay
+  /// task can pick it up. Prunes expired entries on the same URL key while we hold the lock.
+  private static func addPendingReplay(context: ObservationContext, for url: URL) {
+    let now = Date()
+    let expiresAt = now.addingTimeInterval(pendingReplayTimeout)
+    pendingReplays.withLock { pending in
+      var queue = pending[url] ?? []
+      queue.removeAll { $0.expiresAt < now }
+      queue.append((context, expiresAt))
+      pending[url] = queue
+    }
+  }
+
+  /// Removes and returns the oldest non-expired outer context for `url`, or `nil` if none.
+  /// Called from the inner replay task's `observeStart` to adopt the outer's context.
+  private static func takePendingReplay(for url: URL) -> ObservationContext? {
+    let now = Date()
+    return pendingReplays.withLock { pending in
+      guard var queue = pending[url] else {
+        return nil
+      }
+      queue.removeAll { $0.expiresAt < now }
+      guard !queue.isEmpty else {
+        pending[url] = nil
+        return nil
+      }
+      let head = queue.removeFirst()
+      pending[url] = queue.isEmpty ? nil : queue
+      return head.context
+    }
+  }
+
+  /// Removes `context` from `pendingReplays[url]` if it's still there. Called from
+  /// `recordCompletion` so production traffic (no dev-launcher inspector, no inner task ever
+  /// claims the entry) doesn't accumulate one parked `ObservationContext` per observed
+  /// request. No-op when the entry was already consumed by a `takePendingReplay`.
+  private static func removePendingReplay(context: ObservationContext, for url: URL) {
+    pendingReplays.withLock { pending in
+      guard var queue = pending[url] else {
+        return
+      }
+      queue.removeAll { $0.context === context }
+      pending[url] = queue.isEmpty ? nil : queue
+    }
+  }
+
+  // MARK: - setState: swizzle (fallback recording for delegate-less sessions)
+
+  /**
+   `__NSCFLocalSessionTask.setState:` fires on every state transition for every task in the
+   process. We use it as a fallback recorder for tasks whose session doesn't have our
+   `DelegateProxy` installed: `URLSession.shared`, sessions created via paths that bypassed our
+   session-init swizzle, and async/await consumers that go through Apple's internal delegate.
+
+   For delegate-based sessions the `DelegateProxy.urlSession(_:task:didFinishCollecting:)`
+   callback records first (with metrics) and flips `context.recorded`. This fallback fires later
+   and short-circuits on the flag. For delegate-less sessions metrics never arrive, the fallback
+   wins after `setStateFallbackDelay`, and the snapshot lands without per-phase metrics — same
+   degraded shape as a cache hit or an error before headers.
+   */
+  private static func installSetStateSwizzle() {
+    guard let taskClass = NSClassFromString("__NSCFLocalSessionTask") else {
+      return
+    }
+    let selector = NSSelectorFromString("setState:")
+    guard let method = class_getInstanceMethod(taskClass, selector) else {
+      return
+    }
+    // `URLSessionTask.State` is bridged to NSInteger. Apple uses 0=running, 1=suspended,
+    // 2=canceling, 3=completed.
+    let block: @convention(block) (URLSessionTask, Int) -> Void = { task, newState in
+      // Run the original first so URLSession's state machine progresses normally; our recording
+      // is deferred anyway so order here doesn't matter for correctness.
+      if let imp = originalSetStateImp.withLock({ $0 }) {
+        let fn = unsafeBitCast(
+          imp,
+          to: (@convention(c) (AnyObject, Selector, Int) -> Void).self
+        )
+        fn(task, selector, newState)
+      }
+      observeStateChange(task: task, newState: newState)
+    }
+    let newImp = imp_implementationWithBlock(block as Any)
+    let original = method_setImplementation(method, newImp)
+    originalSetStateImp.withLock { $0 = original }
+  }
+
+  private static let stateCompleted = URLSessionTask.State.completed.rawValue
+
+  private static func observeStateChange(task: URLSessionTask, newState: Int) {
+    // Only observe `.completed` — at `.canceling` time `task.error` is still `nil` (the
+    // `NSURLErrorCancelled` lands on `.completed`), so capturing the error here would race the
+    // metrics callback and snapshot a cancelled request as if it succeeded. Every task reaches
+    // `.completed` regardless, so this is strictly safer and carries the real error.
+    guard newState == stateCompleted else {
+      return
+    }
+    guard let context = objc_getAssociatedObject(task, &observationContextKey) as? ObservationContext else {
+      return
+    }
+    // Outer task under dev-launcher: the inner replay task will record from
+    // `didFinishCollectingMetrics:` with the real metrics chain. Skip the outer's fallback so we
+    // don't race the inner's recording. The inner task's setState fallback still runs (it has
+    // its own task identity); recordCompletion's `context.recorded` flag dedupes the two paths.
+    let isInnerReplayTask = task.originalRequest.flatMap {
+      URLProtocol.property(forKey: devLauncherRequestIdKey, in: $0)
+    } != nil
+    if context.replayedByDevLauncher && !isInnerReplayTask {
+      return
+    }
+    // Defer to let the delegate proxy's `didFinishCollectingMetrics:` win when present. The
+    // captured task and error are owned by the closure; if the task is deallocated before the
+    // closure fires, `task` would dangle — except `ObservationContext` is retained via the
+    // associated-object slot for the lifetime of the task, and the closure captures the task by
+    // strong reference. Both live until the closure runs.
+    let capturedError = task.error
+    DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + setStateFallbackDelay) {
+      recordCompletion(task: task, context: context, error: capturedError)
+    }
+  }
+
+  /// Records a completion snapshot. Called from two paths:
+  ///
+  /// - `DelegateProxy.urlSession(_:task:didFinishCollecting:)` (preferred) — fires on the
+  ///   session's delegate queue after the task is fully complete and metrics are populated.
+  ///   The snapshot carries the full `URLSessionTaskMetrics` chain.
+  /// - The `setState:` fallback (`observeStateChange`) — fires `setStateFallbackDelay` after
+  ///   the state transition to `.completed`, used only for tasks whose session doesn't have
+  ///   our delegate proxy. The snapshot has no metrics; `NetworkRequest.from(...)` falls back
+  ///   to wall-clock timings.
+  ///
+  /// The check-set on `context.recorded` happens on `AppMetricsActor` to serialize the two
+  /// paths — without the actor hop, the metrics callback (on the session's delegate queue) and
+  /// the setState fallback (on a global queue) race on a plain `var Bool` and can both pass
+  /// the check, double-recording the request. The actor also serializes `pendingReplays`
+  /// cleanup so a context can't be claimed by an inner task while we're removing it.
+  fileprivate static func recordCompletion(task: URLSessionTask, context: ObservationContext, error: Error?) {
+    // Snapshot all task state on the calling thread — `URLSessionTask` isn't `Sendable`, so we
+    // can't reach `task.response` / `task.countOfBytes*` after the actor hop.
+    let response = task.response as? HTTPURLResponse
+    let bytesSent = task.countOfBytesSent
+    let bytesReceived = task.countOfBytesReceived
+    let metrics = context.metrics
+    let outerUrl = context.outerUrl
+
+    AppMetricsActor.isolated {
+      if context.recorded {
+        return
+      }
+      context.recorded = true
+      // Drain the pending-replay entry now that this request is terminal — `pendingReplays`
+      // would otherwise leak one context per request when dev-launcher is off (no inner task
+      // ever claims them). Safe to call when no entry exists.
+      if let outerUrl {
+        removePendingReplay(context: context, for: outerUrl)
+      }
+
+      let snapshot = NetworkRequest.from(
+        id: context.id,
+        request: context.request,
+        response: response,
+        taskBytesSent: bytesSent,
+        taskBytesReceived: bytesReceived,
+        metrics: metrics,
+        fallbackStart: context.startDate,
+        fallbackEnd: Date(),
+        error: error
+      )
+      _ = try? await context.startNotification?.value
+      NetworkRequestMonitor.shared.record(snapshot)
+    }
+  }
+
+  // MARK: - Session initializer swizzle (for URLSessionTaskMetrics)
+
+  /**
+   Swizzles `+[URLSession sessionWithConfiguration:delegate:delegateQueue:]` so we can wrap the
+   caller's delegate in a `DelegateProxy`. The proxy captures `didFinishCollecting` metrics into
+   the task's `ObservationContext` while forwarding every other selector to the original.
+
+   Sessions created without a delegate (and `URLSession.shared`) skip this path entirely — they
+   still get observed by `resume`/`setState:`, just without per-phase metrics.
+   */
+  private static func installSessionInitSwizzle() {
+    let target: AnyClass = URLSession.self
+    let selector = NSSelectorFromString("sessionWithConfiguration:delegate:delegateQueue:")
+    guard let method = class_getClassMethod(target, selector) else {
+      return
+    }
+    let block: @convention(block) (
+      AnyObject,
+      URLSessionConfiguration,
+      URLSessionDelegate?,
+      OperationQueue?
+    ) -> URLSession? = { cls, config, delegate, queue in
+      // Wrap whatever the caller passed (including nil) so we always see the metrics callback.
+      // Apple's docs say a nil delegate puts the session in "completion handler" mode; in that
+      // mode the metrics callback never fires anyway, but wrapping nil is still safe — the
+      // proxy responds only to the two selectors it handles.
+      let wrapped = DelegateProxy(wrapping: delegate)
+      guard let imp = originalSessionInitImp.withLock({ $0 }) else {
+        return nil
+      }
+      // The delegate slot in the IMP signature is `AnyObject?` rather than `URLSessionDelegate?`
+      // because `DelegateProxy` deliberately doesn't declare Swift `URLSessionDelegate` conformance
+      // (see the class doc for why). At the Obj-C ABI level the slot is `id<NSURLSessionDelegate>?`,
+      // which accepts any `NSObject` — `URLSession` only checks selector responses at runtime.
+      let fn = unsafeBitCast(
+        imp,
+        to: (@convention(c) (AnyObject, Selector, URLSessionConfiguration, AnyObject?, OperationQueue?) -> URLSession?).self
+      )
+      return fn(cls, selector, config, wrapped, queue)
+    }
+    let newImp = imp_implementationWithBlock(block as Any)
+    let original = method_setImplementation(method, newImp)
+    originalSessionInitImp.withLock { $0 = original }
+  }
+}
+
+// MARK: - ObservationContext
+
+/**
+ Per-task observation state. Stored on the task via `objc_setAssociatedObject` so it travels with
+ the task across delegate callbacks, redirects, and threads without us maintaining a separate
+ task→state map. Released automatically when the task or our slot is cleared.
+
+ `@unchecked Sendable` because we cross isolation boundaries by passing the context to
+ `AppMetricsActor` from `recordCompletion`. The mutable fields (`recorded`, `metrics`,
+ `replayedByDevLauncher`, `startNotification`) are written from at most two places each, and
+ the writes that matter for correctness — flipping `recorded`, updating the pending-replays
+ dictionary, building the snapshot — all run on `AppMetricsActor`. The early
+ `replayedByDevLauncher = true` write in `observeStart` happens on the resume thread before
+ any actor work picks the context up, so there's no read-write race in practice.
+ */
+fileprivate final class ObservationContext: @unchecked Sendable {
+  let id: UUID
+  let request: URLRequest
+  let startDate: Date
+  /// URL used as the `pendingReplays` key when this context was first enqueued, or `nil` if the
+  /// outer request had no URL (shouldn't happen for HTTP tasks but defended against). Kept
+  /// explicit so `recordCompletion` can drain the matching `pendingReplays` entry without
+  /// guessing — covers the production case where dev-launcher's inspector is off and no inner
+  /// task ever consumes the entry. Without this cleanup the dictionary would accumulate one
+  /// `ObservationContext` per observed request forever.
+  let outerUrl: URL?
+  /// `Task` that fans the `requestStarted` notification out on `AppMetricsActor`. The `setState:`
+  /// hook awaits it before recording completion so the two events can't arrive out of order.
+  var startNotification: Task<Void, Error>?
+  /// Captured by `DelegateProxy.urlSession(_:task:didFinishCollecting:)` when a session delegate
+  /// is present. `nil` for delegate-less sessions (including `URLSession.shared`); the snapshot
+  /// builder falls back to wall-clock timings in that case.
+  var metrics: URLSessionTaskMetrics?
+  /// Set to `true` once `recordCompletion` has emitted the snapshot for this context. Guards
+  /// against double-recording when both the metrics callback (on the session's delegate queue)
+  /// and the `setState:` fallback (on a global queue) reach `recordCompletion` for the same
+  /// task. The check-and-set runs on `AppMetricsActor` to serialize the two paths.
+  var recorded: Bool = false
+  /// `true` once this context has been claimed by a dev-launcher inner replay task. The outer
+  /// task's setState fallback and metrics callback short-circuit when this flips — the inner
+  /// task will record the snapshot from `didFinishCollectingMetrics:` with the real metrics
+  /// chain.
+  var replayedByDevLauncher: Bool = false
+
+  init(id: UUID, request: URLRequest, startDate: Date, outerUrl: URL?) {
+    self.id = id
+    self.request = request
+    self.startDate = startDate
+    self.outerUrl = outerUrl
+  }
+}
+
+// MARK: - DelegateProxy
+
+/**
+ `NSObject` subclass that captures `didFinishCollectingMetrics` for our observation context while
+ transparently forwarding every other selector to the caller's original delegate.
+
+ **Why we don't declare `URLSessionTaskDelegate` conformance in Swift.** `URLSession` introspects
+ its delegate via `conformsToProtocol:(URLSessionDataDelegate)`, `conformsToProtocol:(URLSessionDownloadDelegate)`,
+ etc., to decide which optional callbacks it should emit. If we conformed to `URLSessionTaskDelegate`
+ in Swift, the Obj-C runtime would advertise that conformance for the proxy unconditionally — even
+ when the wrapped delegate is actually a `URLSessionDataDelegate`. That could change which callbacks
+ fire and break the caller. We instead reflect the wrapped delegate's `responds(to:)` results, plus
+ `true` for the metrics selector we intercept. This is the same pattern Bugsnag's
+ `BSGURLSessionPerformanceProxy` uses.
+
+ The metrics callback is implemented as an `@objc` method so the Obj-C runtime can dispatch it via
+ `responds(to:)` without us declaring formal protocol conformance.
+ */
+private final class DelegateProxy: NSObject {
+  fileprivate let wrapped: URLSessionDelegate?
+
+  init(wrapping wrapped: URLSessionDelegate?) {
+    self.wrapped = wrapped
+    super.init()
+  }
+
+  private static let metricsSelector = NSSelectorFromString("URLSession:task:didFinishCollectingMetrics:")
+
+  override func responds(to aSelector: Selector!) -> Bool {
+    if aSelector == Self.metricsSelector {
+      return true
+    }
+    return wrapped?.responds(to: aSelector) ?? false
+  }
+
+  override func forwardingTarget(for aSelector: Selector!) -> Any? {
+    if aSelector == Self.metricsSelector {
+      return nil
+    }
+    if let wrapped, wrapped.responds(to: aSelector) {
+      return wrapped
+    }
+    return nil
+  }
+
+  /**
+   Canonical recording site. `didFinishCollectingMetrics:` is Apple's "task is fully done" signal
+   — by the time it fires, the last byte has been transferred and `task.error` / `task.response`
+   are stable. We capture metrics, record the snapshot, then forward to the wrapped delegate.
+
+   The explicit `@objc` selector matches Apple's mangling exactly. Without it Swift would emit
+   `urlSession:task:didFinishCollecting:` (the argument-label form), but `URLSession` dispatches
+   `URLSession:task:didFinishCollectingMetrics:`. We can't inherit the right name from a protocol
+   because we deliberately don't conform to `URLSessionTaskDelegate` in Swift (see class comment).
+
+   This mirrors Bugsnag's `BSGURLSessionPerformanceDelegate` approach. Sentry takes a different
+   path (record from `setState:` without metrics) and explicitly trades away redirect-chain
+   detail; we keep the chain by recording here.
+   */
+  @objc(URLSession:task:didFinishCollectingMetrics:)
+  func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
+    if let context = objc_getAssociatedObject(task, &NetworkRequestTaskSwizzling.observationContextKey) as? ObservationContext {
+      // The outer task under dev-launcher gets a degraded metrics callback (the URLProtocol
+      // short-circuits the real network). The inner replay task's callback is where the real
+      // chain lands. Skip the outer's metrics callback when its context was claimed by an inner
+      // task; the inner's own callback will record. The two tasks are told apart by the
+      // property dev-launcher stamps on the inner's request.
+      let isInnerReplayTask = task.originalRequest.flatMap {
+        URLProtocol.property(forKey: NetworkRequestTaskSwizzling.devLauncherRequestIdKey, in: $0)
+      } != nil
+      let skipDueToReplay = context.replayedByDevLauncher && !isInnerReplayTask
+      if !skipDueToReplay {
+        context.metrics = metrics
+        NetworkRequestTaskSwizzling.recordCompletion(task: task, context: context, error: task.error)
+      }
+    }
+    // After stashing the metrics and recording, forward to the wrapped delegate so it sees the
+    // callback too.
+    if let wrapped = wrapped as? URLSessionTaskDelegate {
+      wrapped.urlSession?(session, task: task, didFinishCollecting: metrics)
+    }
+  }
+}
diff --git a/packages/expo-app-metrics/ios/Tests/MetricParamsBuilderTests.swift b/packages/expo-app-metrics/ios/Tests/MetricParamsBuilderTests.swift
index fb984cd1c31782..1cc38b77709e10 100644
--- a/packages/expo-app-metrics/ios/Tests/MetricParamsBuilderTests.swift
+++ b/packages/expo-app-metrics/ios/Tests/MetricParamsBuilderTests.swift
@@ -113,6 +113,40 @@ struct MetricParamsBuilderTests {
     #expect(params["expo.device.batteryCharging"] == nil)
   }
 
+  @Test
+  func `omits network request keys when summary is nil`() {
+    let params = MetricParamsBuilder.build(userParams: ["tenant": "acme"])
+    #expect(params["expo.network.requests.count"] == nil)
+    #expect(params["expo.network.requests.slowestHost"] == nil)
+  }
+
+  @Test
+  func `omits network request keys when summary is empty`() {
+    let params = MetricParamsBuilder.build(networkRequests: .empty)
+    #expect(params["expo.network.requests.count"] == nil)
+  }
+
+  @Test
+  func `emits all network request keys when summary has data`() {
+    let summary = NetworkRequestSummary(
+      count: 4,
+      failed: 1,
+      bytesReceived: 12_000,
+      bytesSent: 800,
+      totalDuration: 1.4,
+      slowestDuration: 0.6,
+      slowestHost: "api.expo.dev"
+    )
+    let params = MetricParamsBuilder.build(networkRequests: summary)
+    #expect(params["expo.network.requests.count"] as? Int == 4)
+    #expect(params["expo.network.requests.failed"] as? Int == 1)
+    #expect(params["expo.network.requests.bytesReceived"] as? Int64 == 12_000)
+    #expect(params["expo.network.requests.bytesSent"] as? Int64 == 800)
+    #expect(params["expo.network.requests.totalDuration"] as? TimeInterval == 1.4)
+    #expect(params["expo.network.requests.slowestDuration"] as? TimeInterval == 0.6)
+    #expect(params["expo.network.requests.slowestHost"] as? String == "api.expo.dev")
+  }
+
   @Test
   func `framework-emitted device keys override user-supplied ones on collision`() {
     let deviceState = DeviceState(
diff --git a/packages/expo-app-metrics/ios/Tests/MetricsDatabaseTests.swift b/packages/expo-app-metrics/ios/Tests/MetricsDatabaseTests.swift
index 3a5dab1c00df8d..c382e4ea8876e4 100644
--- a/packages/expo-app-metrics/ios/Tests/MetricsDatabaseTests.swift
+++ b/packages/expo-app-metrics/ios/Tests/MetricsDatabaseTests.swift
@@ -176,16 +176,30 @@ struct MetricsDatabaseTests {
   }
 
   @Test
-  func `getAllSessions returns rows ordered by start timestamp descending`() throws {
+  func `getInactiveSessions returns inactive rows ordered by start timestamp descending`() throws {
     try withTemporaryDatabase { database in
       try database.insert(session: makeSessionRow(id: "older", startTimestamp: "2026-05-01T00:00:00Z"))
       try database.insert(session: makeSessionRow(id: "newer", startTimestamp: "2026-05-07T00:00:00Z"))
+      try database.updateSessionActiveStatus(id: "older", isActive: false, endTimestamp: nil)
+      try database.updateSessionActiveStatus(id: "newer", isActive: false, endTimestamp: nil)
 
-      let rows = try database.getAllSessions()
+      let rows = try database.getInactiveSessions()
       #expect(rows.map(\.id) == ["newer", "older"])
     }
   }
 
+  @Test
+  func `getInactiveSessions excludes active sessions`() throws {
+    try withTemporaryDatabase { database in
+      try database.insert(session: makeSessionRow(id: "active"))
+      try database.insert(session: makeSessionRow(id: "ended"))
+      try database.updateSessionActiveStatus(id: "ended", isActive: false, endTimestamp: nil)
+
+      let rows = try database.getInactiveSessions()
+      #expect(rows.map(\.id) == ["ended"])
+    }
+  }
+
   @Test
   func `getAllActiveSessions filters out inactive sessions`() throws {
     try withTemporaryDatabase { database in
@@ -214,8 +228,8 @@ struct MetricsDatabaseTests {
       try database.insert(session: makeSessionRow(id: "a"))
       try database.insert(session: makeSessionRow(id: "b"))
       try database.deleteAllSessions()
-      let remaining = try database.getAllSessions()
-      #expect(remaining.isEmpty)
+      #expect(try database.getSession(id: "a") == nil)
+      #expect(try database.getSession(id: "b") == nil)
     }
   }
 
@@ -252,10 +266,11 @@ struct MetricsDatabaseTests {
       }
 
       let database = try MetricsDatabase(directoryUrl: directoryUrl)
-      let remaining = try await AppMetricsActor.isolated {
-        return try database.getAllSessions().map(\.id)
+      let (expired, fresh) = try await AppMetricsActor.isolated {
+        return (try database.getSession(id: "expired"), try database.getSession(id: "fresh"))
       }
-      #expect(remaining == ["fresh"])
+      #expect(expired == nil)
+      #expect(fresh != nil)
     }
   }
 
@@ -273,8 +288,10 @@ struct MetricsDatabaseTests {
 
       try database.cleanupSessions(olderThan: "2026-05-05T00:00:00Z")
 
-      let remaining = try database.getAllSessions().map(\.id).sorted()
-      #expect(remaining == ["new-active", "new-inactive"])
+      #expect(try database.getSession(id: "old-inactive") == nil)
+      #expect(try database.getSession(id: "old-active") == nil)
+      #expect(try database.getSession(id: "new-active") != nil)
+      #expect(try database.getSession(id: "new-inactive") != nil)
     }
   }
 
diff --git a/packages/expo-app-metrics/ios/Tests/NetworkRequestTests.swift b/packages/expo-app-metrics/ios/Tests/NetworkRequestTests.swift
new file mode 100644
index 00000000000000..65f15915b4e84b
--- /dev/null
+++ b/packages/expo-app-metrics/ios/Tests/NetworkRequestTests.swift
@@ -0,0 +1,749 @@
+import Foundation
+import Testing
+
+@testable import ExpoAppMetrics
+
+@Suite("NetworkRequest")
+struct NetworkRequestTests {
+  @Test
+  func `falls back to wall-clock duration when metrics are nil`() {
+    let request = URLRequest(url: URL(string: "https://expo.dev/health")!)
+    let response = HTTPURLResponse(
+      url: request.url!,
+      statusCode: 204,
+      httpVersion: "HTTP/1.1",
+      headerFields: nil
+    )!
+    let start = Date(timeIntervalSinceReferenceDate: 1000)
+    let end = Date(timeIntervalSinceReferenceDate: 1000.42)
+
+    let snapshot = NetworkRequest.from(
+      id: UUID(),
+      request: request,
+      response: response,
+      taskBytesSent: nil,
+      taskBytesReceived: nil,
+      metrics: nil,
+      fallbackStart: start,
+      fallbackEnd: end,
+      error: nil
+    )
+
+    #expect(snapshot.statusCode == 204)
+    #expect(snapshot.method == "GET")
+    #expect(snapshot.networkProtocol == nil)
+    #expect(snapshot.requestBytesSent == nil)
+    #expect(snapshot.responseBytesReceived == nil)
+    // `Date(timeIntervalSinceReferenceDate:)` math is base-2 floating point; allow a single-ulp
+    // tolerance so e.g. 0.4199999999999591 doesn't flake.
+    #expect(abs(snapshot.timings.totalDuration - 0.42) < 0.0001)
+    #expect(snapshot.timings.fetchStart == start)
+    #expect(snapshot.timings.responseEnd == end)
+    #expect(snapshot.errorDescription == nil)
+  }
+
+  @Test
+  func `captures method override and error description`() {
+    var request = URLRequest(url: URL(string: "https://expo.dev/api")!)
+    request.httpMethod = "POST"
+    let error = NSError(domain: NSURLErrorDomain, code: NSURLErrorTimedOut, userInfo: nil)
+    let now = Date()
+
+    let snapshot = NetworkRequest.from(
+      id: UUID(),
+      request: request,
+      response: nil,
+      taskBytesSent: nil,
+      taskBytesReceived: nil,
+      metrics: nil,
+      fallbackStart: now,
+      fallbackEnd: now,
+      error: error
+    )
+
+    #expect(snapshot.method == "POST")
+    #expect(snapshot.statusCode == nil)
+    #expect(snapshot.errorDescription != nil)
+  }
+}
+
+@AppMetricsActor
+@Suite("NetworkRequestMonitor")
+struct NetworkRequestMonitorTests {
+  @Test
+  func `records snapshots and fans out to delegates`() {
+    let monitor = NetworkRequestMonitor()
+    let collector = CollectingDelegate()
+    monitor.addDelegate(collector)
+
+    let snapshot = NetworkRequest.from(
+      id: UUID(),
+      request: URLRequest(url: URL(string: "https://expo.dev/x")!),
+      response: HTTPURLResponse(url: URL(string: "https://expo.dev/x")!, statusCode: 200, httpVersion: nil, headerFields: nil),
+      taskBytesSent: nil,
+      taskBytesReceived: nil,
+      metrics: nil,
+      fallbackStart: Date(),
+      fallbackEnd: Date(),
+      error: nil
+    )
+    monitor.record(snapshot)
+
+    #expect(monitor.recent.count == 1)
+    #expect(monitor.recent.first?.id == snapshot.id)
+    #expect(collector.received.count == 1)
+  }
+
+  @Test
+  func `recordStart fans out to delegates without touching the ring buffer`() {
+    let monitor = NetworkRequestMonitor()
+    let collector = CollectingDelegate()
+    monitor.addDelegate(collector)
+
+    let started = NetworkRequestStarted(
+      id: UUID(),
+      url: URL(string: "https://expo.dev/x")!,
+      method: "GET",
+      startedAt: Date()
+    )
+    monitor.recordStart(started)
+
+    #expect(collector.receivedStarts.count == 1)
+    #expect(collector.receivedStarts.first?.id == started.id)
+    // The ring buffer holds completed snapshots only.
+    #expect(monitor.recent.isEmpty)
+  }
+
+  @Test
+  func `bounds the ring buffer`() {
+    let monitor = NetworkRequestMonitor()
+    let url = URL(string: "https://expo.dev/x")!
+    for _ in 0..<250 {
+      let snapshot = NetworkRequest.from(
+        id: UUID(),
+        request: URLRequest(url: url),
+        response: nil,
+        taskBytesSent: nil,
+        taskBytesReceived: nil,
+        metrics: nil,
+        fallbackStart: Date(),
+        fallbackEnd: Date(),
+        error: nil
+      )
+      monitor.record(snapshot)
+    }
+    #expect(monitor.recent.count == 200)
+  }
+}
+
+@Suite("NetworkRequestSummary")
+struct NetworkRequestSummaryTests {
+  @Test
+  func `empty when no requests are passed in`() {
+    let summary = NetworkRequestSummary.from([])
+    #expect(summary.isEmpty)
+    #expect(summary.count == 0)
+    #expect(summary.slowestHost == nil)
+  }
+
+  @Test
+  func `aggregates count, failures, bytes, durations and slowest`() {
+    let now = Date()
+    let fast = makeRequest(
+      host: "api.expo.dev",
+      duration: 0.1,
+      status: 200,
+      bytesSent: 100,
+      bytesReceived: 200,
+      fetchStart: now
+    )
+    let slow = makeRequest(
+      host: "cdn.expo.dev",
+      duration: 0.8,
+      status: 200,
+      bytesSent: 50,
+      bytesReceived: 9000,
+      fetchStart: now
+    )
+    let failed = makeRequest(
+      host: "broken.expo.dev",
+      duration: 0.3,
+      status: 503,
+      bytesSent: 30,
+      bytesReceived: 40,
+      fetchStart: now
+    )
+
+    let summary = NetworkRequestSummary.from([fast, slow, failed])
+    #expect(summary.count == 3)
+    #expect(summary.failed == 1)
+    #expect(summary.bytesSent == 180)
+    #expect(summary.bytesReceived == 9240)
+    #expect(abs(summary.totalDuration - 1.2) < 0.0001)
+    #expect(summary.slowestDuration == 0.8)
+    #expect(summary.slowestHost == "cdn.expo.dev")
+  }
+
+  @Test
+  func `counts errored requests without a status as failed`() {
+    let request = makeRequest(
+      host: "expo.dev",
+      duration: 0.2,
+      status: nil,
+      bytesSent: 0,
+      bytesReceived: 0,
+      fetchStart: Date(),
+      error: "timed out"
+    )
+    let summary = NetworkRequestSummary.from([request])
+    #expect(summary.failed == 1)
+  }
+
+  @Test
+  func `treats 304 and other 3xx as non-failed`() {
+    // 304 is a successful conditional-GET cache hit; 301/302 are redirections URLSession
+    // typically follows but if one surfaces here it's still a successful response from the
+    // origin's perspective. Only 4xx/5xx (and explicit errors) belong in the failed count.
+    let cacheHit = makeRequest(host: "expo.dev", duration: 0.05, status: 304, bytesSent: 0, bytesReceived: 0, fetchStart: Date())
+    let redirect = makeRequest(host: "expo.dev", duration: 0.1, status: 301, bytesSent: 0, bytesReceived: 0, fetchStart: Date())
+    let clientError = makeRequest(host: "expo.dev", duration: 0.1, status: 404, bytesSent: 0, bytesReceived: 0, fetchStart: Date())
+    let serverError = makeRequest(host: "expo.dev", duration: 0.1, status: 500, bytesSent: 0, bytesReceived: 0, fetchStart: Date())
+
+    let summary = NetworkRequestSummary.from([cacheHit, redirect, clientError, serverError])
+    #expect(summary.count == 4)
+    #expect(summary.failed == 2)
+  }
+
+  private func makeRequest(
+    host: String,
+    duration: TimeInterval,
+    status: Int?,
+    bytesSent: Int64,
+    bytesReceived: Int64,
+    fetchStart: Date,
+    error: String? = nil
+  ) -> NetworkRequest {
+    return NetworkRequest(
+      id: UUID(),
+      url: URL(string: "https://\(host)/x")!,
+      method: "GET",
+      statusCode: status,
+      networkProtocol: nil,
+      requestBytesSent: bytesSent,
+      responseBytesReceived: bytesReceived,
+      timings: NetworkRequest.Timings(
+        fetchStart: fetchStart,
+        domainLookupStart: nil,
+        domainLookupEnd: nil,
+        connectStart: nil,
+        connectEnd: nil,
+        secureConnectionStart: nil,
+        secureConnectionEnd: nil,
+        requestStart: nil,
+        requestEnd: nil,
+        responseStart: nil,
+        responseEnd: nil,
+        totalDuration: duration
+      ),
+      errorDescription: error,
+      redirects: []
+    )
+  }
+}
+
+@AppMetricsActor
+@Suite("NetworkRequestMonitor windowing")
+struct NetworkRequestMonitorWindowingTests {
+  @Test
+  func `filters by fetchStart inclusive on both ends`() {
+    let monitor = NetworkRequestMonitor()
+    let early = makeSnapshot(fetchStart: Date(timeIntervalSinceReferenceDate: 0))
+    let inside = makeSnapshot(fetchStart: Date(timeIntervalSinceReferenceDate: 50))
+    let late = makeSnapshot(fetchStart: Date(timeIntervalSinceReferenceDate: 100))
+    monitor.record(early)
+    monitor.record(inside)
+    monitor.record(late)
+
+    let summary = monitor.summarize(
+      start: Date(timeIntervalSinceReferenceDate: 10),
+      end: Date(timeIntervalSinceReferenceDate: 90)
+    )
+    #expect(summary.count == 1)
+  }
+
+  private func makeSnapshot(fetchStart: Date) -> NetworkRequest {
+    return NetworkRequest(
+      id: UUID(),
+      url: URL(string: "https://expo.dev/x")!,
+      method: "GET",
+      statusCode: 200,
+      networkProtocol: nil,
+      requestBytesSent: 0,
+      responseBytesReceived: 0,
+      timings: NetworkRequest.Timings(
+        fetchStart: fetchStart,
+        domainLookupStart: nil,
+        domainLookupEnd: nil,
+        connectStart: nil,
+        connectEnd: nil,
+        secureConnectionStart: nil,
+        secureConnectionEnd: nil,
+        requestStart: nil,
+        requestEnd: nil,
+        responseStart: nil,
+        responseEnd: nil,
+        totalDuration: 0.1
+      ),
+      errorDescription: nil,
+      redirects: []
+    )
+  }
+}
+
+/**
+ End-to-end tests for `NetworkRequestTaskSwizzling`. We register a `FakeServerProtocol` inside the
+ test's URLSession so requests never escape the process; the swizzles still fire on the real
+ `__NSCFLocalSessionTask` Apple creates to drive the URLProtocol, so we observe the full lifecycle
+ just as we would in production.
+
+ Serialized because every test installs the same process-wide swizzles and shares the monitor's
+ ring buffer — concurrent runs would observe each other's traffic and the assertions filter by URL
+ to keep tests independent.
+ */
+@Suite("NetworkRequestTaskSwizzling", .serialized)
+struct NetworkRequestTaskSwizzlingTests {
+  init() {
+    NetworkRequestTaskSwizzling.install()
+  }
+
+  @Test
+  func `observes a request that completes via the fake server`() async throws {
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [FakeServerProtocol.self]
+    let session = URLSession(configuration: config)
+
+    let collector = CollectingDelegate()
+    try await AppMetricsActor.isolated {
+      NetworkRequestMonitor.shared.addDelegate(collector)
+    }.value
+
+    let url = URL(string: "https://fake.test/hello")!
+    let (data, response) = try await session.data(from: url)
+
+    #expect((response as? HTTPURLResponse)?.statusCode == 200)
+    #expect(String(data: data, encoding: .utf8) == "hi")
+
+    let recorded = await waitForRecorded(matching: url)
+    #expect(recorded != nil)
+    #expect(recorded?.statusCode == 200)
+
+    let startEvent = collector.receivedStarts.first { $0.url == url }
+    #expect(startEvent != nil)
+    #expect(startEvent?.method == "GET")
+    #expect(startEvent?.id == recorded?.id)
+  }
+
+  @Test
+  func `skips requests that carry the internal opt-out header`() async throws {
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [FakeServerProtocol.self]
+    let session = URLSession(configuration: config)
+
+    var request = URLRequest(url: URL(string: "https://fake.test/internal")!)
+    request.setValue("1", forHTTPHeaderField: NetworkRequestTaskSwizzling.internalHeaderName)
+    _ = try await session.data(for: request)
+
+    // Sleep briefly to let any stray recording attempt complete.
+    try await Task.sleep(nanoseconds: 50_000_000)
+    let recorded = try await AppMetricsActor.isolated {
+      return NetworkRequestMonitor.shared.recent.first(where: { $0.url.path == "/internal" })
+    }.value
+    #expect(recorded == nil)
+  }
+
+  /**
+   With task-resume swizzling the caller's session is never replaced — POST bodies reach the
+   server through the URL loading system's normal path. The fake echoes whatever it receives; a
+   matching echo proves the body wasn't dropped.
+   */
+  @Test
+  func `preserves request bodies for uploads`() async throws {
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [FakeServerProtocol.self]
+    let session = URLSession(configuration: config)
+
+    let payload = Data("{\"hello\":\"world\"}".utf8)
+    var request = URLRequest(url: URL(string: "https://fake.test/echo")!)
+    request.httpMethod = "POST"
+    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+    request.httpBody = payload
+
+    let (data, response) = try await session.data(for: request)
+
+    #expect((response as? HTTPURLResponse)?.statusCode == 200)
+    #expect(data == payload)
+  }
+
+  /**
+   With the swizzle approach the caller's `URLSession` configuration is preserved verbatim — no
+   inner session, no replay. Ephemeral sessions used to leak cookies into `HTTPCookieStorage.shared`
+   under the old URLProtocol-replay implementation; this test pins that the leak is gone.
+   `FakeServerProtocol` returns a `Set-Cookie` header for `/cookie-test`, so the assertion would
+   fail loudly if cookies started flowing into the shared jar again.
+   */
+  @Test
+  func `does not leak cookies from an ephemeral session into the shared storage`() async throws {
+    // Wipe any cookie a previous test or stray network state might have planted on `fake.test`.
+    if let stale = HTTPCookieStorage.shared.cookies(for: URL(string: "https://fake.test/")!) {
+      for cookie in stale {
+        HTTPCookieStorage.shared.deleteCookie(cookie)
+      }
+    }
+
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [FakeServerProtocol.self]
+    let session = URLSession(configuration: config)
+
+    let url = URL(string: "https://fake.test/cookie-test")!
+    _ = try await session.data(from: url)
+
+    let sharedAfter = HTTPCookieStorage.shared.cookies(for: URL(string: "https://fake.test/")!) ?? []
+    // The ephemeral session's cookie storage is in-memory and isolated; the global shared storage
+    // must not gain any cookies from a request issued on it.
+    #expect(sharedAfter.isEmpty)
+  }
+
+  /**
+   `URLSessionWebSocketTask` extends `URLSessionTask` so the swizzle's `resume` fires on it, but
+   websockets don't produce useful HTTP metrics and we deliberately skip them. We resume a
+   websocket task pointed at a URL that will never connect, then cancel it; the swizzle must not
+   have recorded a snapshot.
+   */
+  @Test
+  func `skips websocket tasks`() async throws {
+    let config = URLSessionConfiguration.ephemeral
+    let session = URLSession(configuration: config)
+    let url = URL(string: "wss://fake.invalid.test/never-connects")!
+    let task = session.webSocketTask(with: url)
+    task.resume()
+    task.cancel()
+
+    try await Task.sleep(nanoseconds: 50_000_000)
+    let recorded = try await AppMetricsActor.isolated {
+      return NetworkRequestMonitor.shared.recent.first(where: { $0.url == url })
+    }.value
+    #expect(recorded == nil)
+  }
+
+  /**
+   Requests marked with `ExpoRequestInterceptorProtocol.requestId` are dev-launcher inner replays —
+   the swizzle must skip them so we don't double-record every request in dev-client builds. Drive
+   the check through `URLProtocol.setProperty(_:forKey:in:)` directly; we don't need the
+   dev-launcher itself to repro the condition.
+   */
+  @Test
+  func `skips dev-launcher inner replay tasks`() async throws {
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [FakeServerProtocol.self]
+    let session = URLSession(configuration: config)
+
+    let url = URL(string: "https://fake.test/dev-launcher-replay")!
+    let mutable = (URLRequest(url: url) as NSURLRequest).mutableCopy() as! NSMutableURLRequest
+    URLProtocol.setProperty("test-request-id", forKey: "ExpoRequestInterceptorProtocol.requestId", in: mutable)
+    _ = try await session.data(for: mutable as URLRequest)
+
+    try await Task.sleep(nanoseconds: 50_000_000)
+    let recorded = try await AppMetricsActor.isolated {
+      return NetworkRequestMonitor.shared.recent.first(where: { $0.url == url })
+    }.value
+    #expect(recorded == nil)
+  }
+
+  /**
+   Sessions created without a delegate (and the global `URLSession.shared`-style completion-handler
+   path) skip our `DelegateProxy`, so `didFinishCollectingMetrics:` never fires. The `setState:`
+   fallback has to win after `setStateFallbackDelay` and still record the snapshot — degraded (no
+   per-phase metrics) but present.
+   */
+  @Test
+  func `records delegate-less sessions via the setState fallback`() async throws {
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [FakeServerProtocol.self]
+    // Explicitly pass `nil` delegate so our session-init swizzle doesn't get to wrap a real one.
+    // `URLSession(configuration:delegate:delegateQueue:)` with a nil delegate matches the
+    // completion-handler-only mode in Apple's docs.
+    let session = URLSession(configuration: config, delegate: nil, delegateQueue: nil)
+
+    let url = URL(string: "https://fake.test/delegate-less")!
+    let result: (Data, URLResponse?) = try await withCheckedThrowingContinuation { continuation in
+      let task = session.dataTask(with: url) { data, response, error in
+        if let error {
+          continuation.resume(throwing: error)
+          return
+        }
+        continuation.resume(returning: (data ?? Data(), response))
+      }
+      task.resume()
+    }
+    #expect((result.1 as? HTTPURLResponse)?.statusCode == 200)
+    #expect(String(data: result.0, encoding: .utf8) == "hi")
+
+    let recorded = await waitForRecorded(matching: url)
+    #expect(recorded != nil)
+    #expect(recorded?.statusCode == 200)
+  }
+
+  private func waitForRecorded(matching url: URL, attempts: Int = 50) async -> NetworkRequest? {
+    for _ in 0..<attempts {
+      let found = try? await AppMetricsActor.isolated {
+        return NetworkRequestMonitor.shared.recent.first(where: { $0.url == url })
+      }.value
+      if let found {
+        return found
+      }
+      try? await Task.sleep(nanoseconds: 20_000_000)
+    }
+    return nil
+  }
+}
+
+/**
+ The JS-facing observer mostly forwards to `NetworkRequestMonitor`, which is exercised by the
+ `NetworkRequestMonitor` suite. What's specific to the observer is the payload shape — the dict
+ it hands to `emit()` is the wire format JS consumers see. These tests pin that shape down so
+ renames (`fromUrl` → `from`, `responseEnd` → `endedAt`, etc.) require a deliberate change.
+ */
+@Suite("NetworkRequestObserver")
+struct NetworkRequestObserverTests {
+  @Test
+  func `startedPayload contains the started-event keys`() {
+    let id = UUID()
+    let startedAt = Date(timeIntervalSinceReferenceDate: 1000)
+    let request = NetworkRequestStarted(
+      id: id,
+      url: URL(string: "https://expo.dev/start")!,
+      method: "POST",
+      startedAt: startedAt
+    )
+
+    let payload = NetworkRequestObserver.startedPayload(for: request)
+
+    #expect(payload["id"] as? String == id.uuidString)
+    #expect(payload["url"] as? String == "https://expo.dev/start")
+    #expect(payload["method"] as? String == "POST")
+    #expect(payload["startedAt"] as? String == startedAt.ISO8601Format())
+    // Only the four documented keys — anything extra means the JS contract grew unintentionally.
+    #expect(Set(payload.keys) == ["id", "url", "method", "startedAt"])
+  }
+
+  @Test
+  func `completedPayload normalizes timings and redirects`() {
+    let id = UUID()
+    let fetchStart = Date(timeIntervalSinceReferenceDate: 2000)
+    let responseEnd = Date(timeIntervalSinceReferenceDate: 2000.5)
+    let request = NetworkRequest(
+      id: id,
+      url: URL(string: "https://expo.dev/end")!,
+      method: "GET",
+      statusCode: 200,
+      networkProtocol: "h2",
+      requestBytesSent: 123,
+      responseBytesReceived: 4567,
+      timings: NetworkRequest.Timings(
+        fetchStart: fetchStart,
+        domainLookupStart: nil,
+        domainLookupEnd: nil,
+        connectStart: nil,
+        connectEnd: nil,
+        secureConnectionStart: nil,
+        secureConnectionEnd: nil,
+        requestStart: nil,
+        requestEnd: nil,
+        responseStart: nil,
+        responseEnd: responseEnd,
+        totalDuration: 0.5
+      ),
+      errorDescription: nil,
+      redirects: [
+        NetworkRequest.Redirect(
+          fromUrl: URL(string: "https://expo.dev/a")!,
+          toUrl: URL(string: "https://expo.dev/b")!,
+          statusCode: 301
+        )
+      ]
+    )
+
+    let payload = NetworkRequestObserver.completedPayload(for: request)
+
+    #expect(payload["id"] as? String == id.uuidString)
+    #expect(payload["url"] as? String == "https://expo.dev/end")
+    #expect(payload["method"] as? String == "GET")
+    #expect(payload["statusCode"] as? Int == 200)
+    #expect(payload["networkProtocol"] as? String == "h2")
+    #expect(payload["requestBytesSent"] as? Int64 == 123)
+    #expect(payload["responseBytesReceived"] as? Int64 == 4567)
+    #expect(payload["startedAt"] as? String == fetchStart.ISO8601Format())
+    #expect(payload["completedAt"] as? String == responseEnd.ISO8601Format())
+    #expect(payload["totalDuration"] as? TimeInterval == 0.5)
+
+    let redirects = payload["redirects"] as? [[String: Any?]]
+    #expect(redirects?.count == 1)
+    #expect(redirects?.first?["fromUrl"] as? String == "https://expo.dev/a")
+    #expect(redirects?.first?["toUrl"] as? String == "https://expo.dev/b")
+    #expect(redirects?.first?["statusCode"] as? Int == 301)
+  }
+
+  @Test
+  func `completedPayload preserves nulls and empty redirects`() {
+    // Failed request before the response arrived: status, protocol, byte counts and end timestamps
+    // are all nil. The dict keys must still be present so JS code can read them without crashing.
+    let id = UUID()
+    let fetchStart = Date(timeIntervalSinceReferenceDate: 3000)
+    let request = NetworkRequest(
+      id: id,
+      url: URL(string: "https://expo.dev/error")!,
+      method: "GET",
+      statusCode: nil,
+      networkProtocol: nil,
+      requestBytesSent: nil,
+      responseBytesReceived: nil,
+      timings: NetworkRequest.Timings(
+        fetchStart: fetchStart,
+        domainLookupStart: nil,
+        domainLookupEnd: nil,
+        connectStart: nil,
+        connectEnd: nil,
+        secureConnectionStart: nil,
+        secureConnectionEnd: nil,
+        requestStart: nil,
+        requestEnd: nil,
+        responseStart: nil,
+        responseEnd: nil,
+        totalDuration: 0.1
+      ),
+      errorDescription: "timed out",
+      redirects: []
+    )
+
+    let payload = NetworkRequestObserver.completedPayload(for: request)
+
+    // `payload[key]` returns `Optional<Any?>` because the dict's value type is `Any?`. A missing
+    // key is the outer `.none`; a present-but-nil key is `.some(.none)`. The JS contract says
+    // every key is present, so assert on the outer `.some` and the inner nil separately.
+    #expect(payload.keys.contains("statusCode"))
+    #expect((payload["statusCode"] ?? "missing") as? Int == nil)
+    #expect(payload.keys.contains("networkProtocol"))
+    #expect((payload["networkProtocol"] ?? "missing") as? String == nil)
+    #expect(payload.keys.contains("requestBytesSent"))
+    #expect(payload.keys.contains("completedAt"))
+    #expect((payload["completedAt"] ?? "missing") as? String == nil)
+    #expect(payload["errorDescription"] as? String == "timed out")
+
+    // `redirects` is always present as an empty array, never `nil` — JS callers `.map` over it
+    // without a null-guard.
+    let redirects = payload["redirects"] as? [[String: Any?]]
+    #expect(redirects != nil)
+    #expect(redirects?.isEmpty == true)
+  }
+}
+
+// MARK: - Test helpers
+
+private final class CollectingDelegate: NetworkRequestObserverDelegate, @unchecked Sendable {
+  private let lock = NSLock()
+  private var completed: [NetworkRequest] = []
+  private var started: [NetworkRequestStarted] = []
+
+  var received: [NetworkRequest] {
+    lock.lock()
+    defer {
+      lock.unlock()
+    }
+    return completed
+  }
+
+  var receivedStarts: [NetworkRequestStarted] {
+    lock.lock()
+    defer {
+      lock.unlock()
+    }
+    return started
+  }
+
+  func onNetworkRequestStarted(_ request: NetworkRequestStarted) {
+    lock.lock()
+    defer {
+      lock.unlock()
+    }
+    started.append(request)
+  }
+
+  func onNetworkRequestCompleted(_ request: NetworkRequest) {
+    lock.lock()
+    defer {
+      lock.unlock()
+    }
+    completed.append(request)
+  }
+}
+
+/**
+ A trivial `URLProtocol` that pretends to be a server. Routes by URL path:
+ - `/cookie-test` returns a `Set-Cookie` header so the cookie-isolation test can detect a leak.
+ - any other path echoes the request body back when there is one (POST/PUT payload assertions) and
+   otherwise returns a `hi` body.
+
+ Sits at the tail of the protocol chain in the test's outer session.
+ */
+private final class FakeServerProtocol: URLProtocol {
+  override class func canInit(with request: URLRequest) -> Bool {
+    return request.url?.host == "fake.test"
+  }
+
+  override class func canonicalRequest(for request: URLRequest) -> URLRequest {
+    return request
+  }
+
+  override func startLoading() {
+    let url = request.url!
+    let headers: [String: String]? = url.path == "/cookie-test"
+      ? ["Set-Cookie": "fake=value; Path=/"]
+      : nil
+    let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1", headerFields: headers)!
+    client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+    let body = Self.readBody(from: request) ?? Data("hi".utf8)
+    client?.urlProtocol(self, didLoad: body)
+    client?.urlProtocolDidFinishLoading(self)
+  }
+
+  override func stopLoading() {}
+
+  /**
+   Reads the request body, preferring the in-memory `httpBody` and falling back to draining
+   `httpBodyStream` — by the time a request reaches a `URLProtocol`, Foundation has usually
+   converted the body to a stream, which is exactly the path we want to exercise.
+   */
+  private static func readBody(from request: URLRequest) -> Data? {
+    if let body = request.httpBody {
+      return body
+    }
+    guard let stream = request.httpBodyStream else {
+      return nil
+    }
+    stream.open()
+    defer {
+      stream.close()
+    }
+    var data = Data()
+    let bufferSize = 1024
+    var buffer = [UInt8](repeating: 0, count: bufferSize)
+    while stream.hasBytesAvailable {
+      let read = stream.read(&buffer, maxLength: bufferSize)
+      if read <= 0 {
+        break
+      }
+      data.append(buffer, count: read)
+    }
+    return data.isEmpty ? nil : data
+  }
+}
diff --git a/packages/expo-app-metrics/ios/Utils/AnyCodable.swift b/packages/expo-app-metrics/ios/Utils/AnyCodable.swift
index 83a99ab1708f15..19bcd8936569da 100644
--- a/packages/expo-app-metrics/ios/Utils/AnyCodable.swift
+++ b/packages/expo-app-metrics/ios/Utils/AnyCodable.swift
@@ -35,14 +35,25 @@ public struct AnyCodable: Codable, Sendable {
   public func encode(to encoder: Encoder) throws {
     var container = encoder.singleValueContainer()
 
+    // `Bool` must come before the integer cases — Swift bridges `Bool` and the numeric types
+    // bidirectionally for `as?`, and on Objective-C runtime values, `Bool` round-trips through
+    // `NSNumber` indistinguishably from an integer. Matching `Bool` first preserves type.
     switch value {
+    case let value as Bool:
+      try container.encode(value)
     case let value as Int:
       try container.encode(value)
+    case let value as Int32:
+      try container.encode(value)
+    case let value as Int64:
+      try container.encode(value)
     case let value as UInt:
       try container.encode(value)
-    case let value as Double:
+    case let value as UInt32:
       try container.encode(value)
-    case let value as Bool:
+    case let value as UInt64:
+      try container.encode(value)
+    case let value as Double:
       try container.encode(value)
     case let value as String:
       try container.encode(value)
diff --git a/packages/expo-app-metrics/ios/Utils/MetricParamsBuilder.swift b/packages/expo-app-metrics/ios/Utils/MetricParamsBuilder.swift
index 6d9dc04b683f45..21bf6b1e0c2ca8 100644
--- a/packages/expo-app-metrics/ios/Utils/MetricParamsBuilder.swift
+++ b/packages/expo-app-metrics/ios/Utils/MetricParamsBuilder.swift
@@ -20,7 +20,8 @@ enum MetricParamsBuilder {
     userParams: [String: Any] = [:],
     frameMetrics: FrameRateMetrics? = nil,
     deviceState: DeviceState? = nil,
-    networkPath: NetworkPath? = nil
+    networkPath: NetworkPath? = nil,
+    networkRequests: NetworkRequestSummary? = nil
   ) -> [String: Any] {
     var params: [String: Any] = userParams
     if let frameMetrics, frameMetrics.expectedFrames > 0 {
@@ -48,6 +49,19 @@ enum MetricParamsBuilder {
       params["expo.network.connected"] = networkPath.status == .satisfied
       params["expo.network.type"] = networkTypeString(networkPath)
     }
+    if let networkRequests, !networkRequests.isEmpty {
+      params["expo.network.requests.count"] = networkRequests.count
+      params["expo.network.requests.failed"] = networkRequests.failed
+      params["expo.network.requests.bytesReceived"] = networkRequests.bytesReceived
+      params["expo.network.requests.bytesSent"] = networkRequests.bytesSent
+      params["expo.network.requests.totalDuration"] = networkRequests.totalDuration
+      if let slowestDuration = networkRequests.slowestDuration {
+        params["expo.network.requests.slowestDuration"] = slowestDuration
+      }
+      if let slowestHost = networkRequests.slowestHost {
+        params["expo.network.requests.slowestHost"] = slowestHost
+      }
+    }
     return params
   }
 
diff --git a/packages/expo-app-metrics/src/index.ts b/packages/expo-app-metrics/src/index.ts
index a622c5d5886080..98257c5b036eba 100644
--- a/packages/expo-app-metrics/src/index.ts
+++ b/packages/expo-app-metrics/src/index.ts
@@ -1,3 +1,4 @@
 export { default } from './module';
 export { AppMetricsRoot } from './AppMetricsRoot';
 export * from './types';
+export * from './useNetworkRequestObserver';
diff --git a/packages/expo-app-metrics/src/module.web.ts b/packages/expo-app-metrics/src/module.web.ts
index 80e0968b44e585..e3493640047258 100644
--- a/packages/expo-app-metrics/src/module.web.ts
+++ b/packages/expo-app-metrics/src/module.web.ts
@@ -1,4 +1,4 @@
-import { NativeModule, registerWebModule } from 'expo';
+import { NativeModule, registerWebModule, SharedObject } from 'expo';
 
 import type {
   ExpoAppMetricsModuleType,
@@ -6,11 +6,20 @@ import type {
   LogEventOptions,
   Metric,
   MetricAttributes,
+  NetworkRequestObserverEvents,
 } from './types';
 
 export * from './types';
 
+class NetworkRequestObserverWeb extends SharedObject<NetworkRequestObserverEvents> {
+  // Web has no native interceptor, so this never emits. Kept as a no-op so cross-platform code
+  // can construct it without guarding on Platform.OS.
+}
+
 class ExpoAppMetricsModule extends NativeModule implements ExpoAppMetricsModuleType {
+  NetworkRequestObserver =
+    NetworkRequestObserverWeb as unknown as ExpoAppMetricsModuleType['NetworkRequestObserver'];
+
   addCustomMetricToSession(metric: Metric): Promise<void> {
     throw new Error('Method not implemented.');
   }
@@ -19,7 +28,7 @@ class ExpoAppMetricsModule extends NativeModule implements ExpoAppMetricsModuleT
   logEvent(name: string, options?: LogEventOptions) {}
   setGlobalAttributes(attributes?: Record<string, LogAttributeValue> | null) {}
   async clearStoredEntries() {}
-  async getAllSessions() {
+  async getInactiveSessions() {
     return [];
   }
   simulateCrashReport() {}
diff --git a/packages/expo-app-metrics/src/types.ts b/packages/expo-app-metrics/src/types.ts
index 64a1b7c479097b..893bc5d112dbac 100644
--- a/packages/expo-app-metrics/src/types.ts
+++ b/packages/expo-app-metrics/src/types.ts
@@ -1,3 +1,5 @@
+import type { SharedObject } from 'expo';
+
 export type AppStartupTimes = {
   /**
    * Time from when the user taps the app to the moment the app starts executing the main code.
@@ -266,6 +268,111 @@ export type CrashReport = {
   ingestedAt: string;
 };
 
+/**
+ * Snapshot emitted at the moment a request begins. Carries enough information to render the
+ * request in an "in-flight" debug UI; the matching completion event arrives later with the
+ * same `id`.
+ */
+export type NetworkRequestStartedEvent = {
+  /** Stable identifier shared with the corresponding `requestCompleted` event. */
+  id: string;
+  /** Request URL as supplied to the native networking layer. May include query parameters and fragments. */
+  url: string;
+  /** HTTP method (`GET`, `POST`, …). */
+  method: string;
+  /** ISO 8601 timestamp of when the request started. Truncated to whole seconds. */
+  startedAt: string;
+};
+
+/**
+ * One hop in a redirect chain. `fromUrl` issued the 3xx response, `toUrl` is where it pointed.
+ * For a complete chain the first entry's `fromUrl` matches the parent
+ * `NetworkRequestCompletedEvent.url`, and the last entry's `toUrl` is where the request
+ * actually landed.
+ */
+export type NetworkRequestRedirect = {
+  /** The URL that returned the redirect. */
+  fromUrl: string;
+  /** The URL the request was redirected to. */
+  toUrl: string;
+  /** The 3xx status code (301, 302, 307, 308, …) returned by `fromUrl`. */
+  statusCode: number;
+};
+
+/**
+ * Snapshot emitted when a request completes (successfully or otherwise). Shares its `id` with
+ * the corresponding `requestStarted` event so consumers can correlate the two.
+ */
+export type NetworkRequestCompletedEvent = {
+  /** Stable identifier shared with the corresponding `requestStarted` event. */
+  id: string;
+  /** Request URL as supplied to the native networking layer. May include query parameters and fragments. */
+  url: string;
+  /** HTTP method (`GET`, `POST`, …). */
+  method: string;
+  /** Response status code, or `null` if the request failed before headers were received. */
+  statusCode: number | null;
+  /**
+   * Negotiated wire protocol (`http/1.1`, `h2`, `h3`), or `null` when the OS didn't report one.
+   */
+  networkProtocol: string | null;
+  /** Total request bytes on the wire (headers + body), or `null` if unavailable. */
+  requestBytesSent: number | null;
+  /** Total response bytes on the wire (headers + body), or `null` if unavailable. */
+  responseBytesReceived: number | null;
+  /** Short, human-readable error description if the request failed. */
+  errorDescription: string | null;
+  /**
+   * ISO 8601 timestamp of when the request started (matches `requestStarted.startedAt`).
+   * Truncated to whole seconds — use `totalDuration` for sub-second timing.
+   */
+  startedAt: string | null;
+  /**
+   * ISO 8601 timestamp of when the response finished arriving. Truncated to whole seconds — use
+   * `totalDuration` for sub-second timing.
+   */
+  completedAt: string | null;
+  /** Total wall-clock duration of the request in seconds. */
+  totalDuration: number;
+  /**
+   * Ordered list of redirect hops that preceded the final response. Empty when the request
+   * completed without any 3xx redirects.
+   */
+  redirects: NetworkRequestRedirect[];
+};
+
+/**
+ * Map of events emitted by `NetworkRequestObserver`. Used by the underlying `SharedObject`
+ * event-emitter to type listener callbacks.
+ */
+export type NetworkRequestObserverEvents = {
+  requestStarted(event: NetworkRequestStartedEvent): void;
+  requestCompleted(event: NetworkRequestCompletedEvent): void;
+};
+
+/**
+ * Per-instance handle to the network-request stream. Each `new NetworkRequestObserver()` allocates
+ * its own SharedObject and registers as a delegate on the native singleton; when JS releases the
+ * instance the delegate slot is automatically reclaimed.
+ *
+ * Subscribe to events via `addListener`/`removeListener` (inherited from the SharedObject base).
+ *
+ * @example
+ * ```ts
+ * import AppMetrics from 'expo-app-metrics';
+ *
+ * const observer = new AppMetrics.NetworkRequestObserver();
+ * const sub = observer.addListener('requestCompleted', event => {
+ *   console.log(event.url, event.totalDuration);
+ * });
+ * // later
+ * sub.remove();
+ * ```
+ */
+export declare class NetworkRequestObserver extends SharedObject<NetworkRequestObserverEvents> {
+  constructor();
+}
+
 export interface ExpoAppMetricsModuleType {
   markFirstRender(): void;
   markInteractive(attributes?: MetricAttributes): void;
@@ -296,13 +403,16 @@ export interface ExpoAppMetricsModuleType {
   setGlobalAttributes(attributes?: Record<string, LogAttributeValue> | null): void;
   clearStoredEntries(): Promise<void>;
   /**
-   * Returns all sessions across the current and historical entries,
-   * ordered with the current launch first.
+   * Returns the recorded sessions as plain `Session` records, ordered with
+   * the most recent first. Each record eagerly includes its metrics, logs, and
+   * crash report.
+   *
+   * Debug-only: intended for inspecting on-device history (e.g. the
+   * ObserveTester app), not for production use.
    *
    * @private This API is unstable and may change without notice.
-   * @platform ios
    */
-  getAllSessions(): Promise<Session[]>;
+  getInactiveSessions(): Promise<Session[]>;
 
   /**
    * Simulates a crash report, attributing it to the current main session.
@@ -332,4 +442,11 @@ export interface ExpoAppMetricsModuleType {
    * @private This API is unstable and may change without notice.
    */
   getMainSession(): Promise<MainSession | null>;
+
+  /**
+   * Class for subscribing to HTTP requests observed by the native networking interceptor.
+   * Construct an instance to begin receiving `requestStarted`/`requestCompleted` events;
+   * release the instance (drop all references) to stop.
+   */
+  NetworkRequestObserver: typeof NetworkRequestObserver;
 }
diff --git a/packages/expo-app-metrics/src/useNetworkRequestObserver.ts b/packages/expo-app-metrics/src/useNetworkRequestObserver.ts
new file mode 100644
index 00000000000000..28ac83457da25a
--- /dev/null
+++ b/packages/expo-app-metrics/src/useNetworkRequestObserver.ts
@@ -0,0 +1,39 @@
+import { useEventListener } from 'expo';
+import { useReleasingSharedObject } from 'expo-modules-core';
+
+import AppMetrics from './module';
+import type {
+  NetworkRequestCompletedEvent,
+  NetworkRequestObserver,
+  NetworkRequestStartedEvent,
+} from './types';
+
+export type UseNetworkRequestObserverOptions = {
+  /**
+   * Called when a request begins. Fired before any response or timing data exists; correlate
+   * with the matching `onCompleted` call via the shared `id`.
+   */
+  onStarted?: (event: NetworkRequestStartedEvent) => void;
+
+  /**
+   * Called when a request finishes (successfully or otherwise). Payload includes status,
+   * timings, byte counts, protocol, error, and the redirect chain.
+   */
+  onCompleted?: (event: NetworkRequestCompletedEvent) => void;
+};
+
+/**
+ * Subscribes to the native network-request observer for the lifetime of the component. Each
+ * mount allocates a `NetworkRequestObserver` SharedObject; unmount releases it and the native
+ * delegate slot is reclaimed.
+ */
+export function useNetworkRequestObserver(
+  options: UseNetworkRequestObserverOptions = {}
+): NetworkRequestObserver {
+  const observer = useReleasingSharedObject(() => new AppMetrics.NetworkRequestObserver(), []);
+
+  useEventListener(observer, 'requestStarted', (event) => options.onStarted?.(event));
+  useEventListener(observer, 'requestCompleted', (event) => options.onCompleted?.(event));
+
+  return observer;
+}
diff --git a/packages/expo-observe/CHANGELOG.md b/packages/expo-observe/CHANGELOG.md
new file mode 100644
index 00000000000000..a2ba70da60600e
--- /dev/null
+++ b/packages/expo-observe/CHANGELOG.md
@@ -0,0 +1,11 @@
+# Changelog
+
+## Unpublished
+
+### 🛠 Breaking changes
+
+### 🎉 New features
+
+### 🐛 Bug fixes
+
+### 💡 Others
diff --git a/packages/expo-observe/android/src/main/java/expo/modules/observe/EventDispatcher.kt b/packages/expo-observe/android/src/main/java/expo/modules/observe/EventDispatcher.kt
index 3d9751ce25629d..fa41074be28e59 100644
--- a/packages/expo-observe/android/src/main/java/expo/modules/observe/EventDispatcher.kt
+++ b/packages/expo-observe/android/src/main/java/expo/modules/observe/EventDispatcher.kt
@@ -103,6 +103,13 @@ class EventDispatcher(
     val request = Request
       .Builder()
       .url(endpointUrl)
+      // Tells the expo-app-metrics network observer to skip this request so our own telemetry
+      // uploads don't get logged back into the network-request stream. The interceptor strips
+      // the header before forwarding so the server never sees it. The name is duplicated here
+      // rather than imported: expo-observe must not depend on expo-app-metrics internals. Keep
+      // it in sync with `INTERNAL_HEADER_NAME` in
+      // `expo-app-metrics/android/.../networkrequests/NetworkRequestInterceptor.kt`.
+      .addHeader("Expo-AppMetrics-Skip", "1")
       .post(body.toRequestBody("application/json".toMediaType()))
       .build()
 
diff --git a/packages/expo-observe/ios/Observability.swift b/packages/expo-observe/ios/Observability.swift
index 1a5b5ffb39940c..012d4d4658015f 100644
--- a/packages/expo-observe/ios/Observability.swift
+++ b/packages/expo-observe/ios/Observability.swift
@@ -151,7 +151,15 @@ internal struct ObservabilityManager {
   private static func sendRequest(to endpointUrl: URL, body: any Encodable) async throws -> Bool {
     var request = URLRequest(url: endpointUrl)
     request.httpMethod = "POST"
-    request.allHTTPHeaderFields = ["Content-Type": "application/json"]
+    request.allHTTPHeaderFields = [
+      "Content-Type": "application/json",
+      // Tells `NetworkRequestURLProtocol` to skip observation so our own telemetry uploads don't
+      // get logged back into the network-request stream. The header reaches o.expo.dev unchanged
+      // (we control that endpoint, so the harmless overhead is fine). The name is duplicated here
+      // rather than imported: expo-observe must not depend on expo-app-metrics internals. Keep it
+      // in sync with `NetworkRequestURLProtocol.internalHeaderName` in expo-app-metrics.
+      "Expo-AppMetrics-Skip": "1"
+    ]
     request.httpBody = try body.toJSONData([])
 
     #if DEBUG
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1d72fd301531a7..02dabea11765bc 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1616,6 +1616,9 @@ importers:
       expo:
         specifier: workspace:*
         version: link:../../packages/expo
+      expo-app-metrics:
+        specifier: workspace:*
+        version: link:../../packages/expo-app-metrics
       expo-application:
         specifier: workspace:*
         version: link:../../packages/expo-application
diff --git a/tools/src/publish-packages/tasks/bundleIOSPrebuilds.ts b/tools/src/publish-packages/tasks/bundleIOSPrebuilds.ts
index e2aa45ef66b84a..be2bbfa8f8a1bf 100644
--- a/tools/src/publish-packages/tasks/bundleIOSPrebuilds.ts
+++ b/tools/src/publish-packages/tasks/bundleIOSPrebuilds.ts
@@ -111,7 +111,6 @@ const IOS_PREBUILD_PACKAGES = [
   'expo-media-library',
   'expo-modules-core',
   'expo-print',
-  'expo-sensors',
   'expo-ui',
   'expo-video',
 ];