@symbiote-native/app-metrics 0.0.0-stage → 0.1.0

package/build/core/types.d.ts

@@ -0,0 +1,168 @@
+export type IAppStartupTimes = {
+    /** @platform ios */
+    loadTime?: number;
+    coldLaunchTime?: number;
+    warmLaunchTime?: number;
+    bundleLoadTime?: number;
+    timeToFirstRender?: number;
+    timeToInteractive?: number;
+};
+export type IMemoryUsageSnapshot = {
+    /** @platform ios */
+    allocated?: number;
+    physical: number;
+    available: number;
+    /** @platform android */
+    javaHeap?: number;
+};
+export type IFrameRateMetrics = {
+    renderedFrames: number;
+    expectedFrames: number;
+    droppedFrames: number;
+    /** Takes at least 700ms to render */
+    frozenFrames: number;
+    /** Takes at least 17ms to render */
+    slowFrames: number;
+    freezeTime: number;
+    sessionDuration: number;
+};
+export type IMetric = {
+    timestamp: string;
+    category: string;
+    name: string;
+    value: number;
+    sessionId: string;
+    routeName?: string | null;
+    params?: Record<string, unknown>;
+};
+export type IMetricAttributes = {
+    routeName?: string | null;
+    params?: Record<string, unknown>;
+};
+/** Ordered from least to most severe */
+export type ILogSeverity = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export type ILogAttributeValue = string | number | boolean | ILogAttributeValue[] | {
+    [key: string]: ILogAttributeValue;
+};
+export type ILogRecord = {
+    timestamp: string;
+    name: string;
+    body?: string | null;
+    attributes?: Record<string, ILogAttributeValue> | null;
+    severity: ILogSeverity;
+};
+export type ILogEventOptions = {
+    displayName?: string | null;
+    body?: string | null;
+    attributes?: Record<string, ILogAttributeValue> | null;
+    /** @default 'info' */
+    severity?: ILogSeverity | null;
+};
+export type ISessionType = 'main' | 'foreground' | 'screen' | 'custom' | 'unknown';
+/** Every `IMetric` field except `sessionId`, implied by the owning session */
+export type IMetricInput = Omit<IMetric, 'sessionId'>;
+export type ICallStackFrame = {
+    /** @platform ios */
+    binaryName?: string | null;
+    /** @platform ios */
+    binaryUUID?: string | null;
+    /** @platform ios */
+    address?: number | null;
+    /** @platform ios */
+    offsetIntoBinaryTextSegment?: number | null;
+    /** @platform ios */
+    sampleCount?: number | null;
+    subFrames?: ICallStackFrame[] | null;
+    /** ios: on-device `dladdr` symbolication. android: the JVM stack-trace frame string */
+    symbol?: string | null;
+};
+export type ICallStack = {
+    threadAttributed?: boolean | null;
+    callStackRootFrames?: ICallStackFrame[] | null;
+};
+export type ICallStackTree = {
+    callStacks?: ICallStack[] | null;
+};
+/** ios (MetricKit) reports the numeric fields; android reports `exceptionReason` as a string */
+export type ICrashReport = {
+    /** @platform ios */
+    exceptionType?: number | null;
+    /** @platform ios */
+    exceptionCode?: number | null;
+    /** Unix signal number, e.g. SIGSEGV = 11 */
+    signal?: number | null;
+    terminationReason?: string | null;
+    /** @platform ios */
+    virtualMemoryRegionInfo?: string | null;
+    /** ios: a structured MetricKit reason object. android: a plain composed string */
+    exceptionReason?: {
+        composedMessage: string;
+        formatString: string;
+        arguments: string[];
+        exceptionType: string;
+        className: string;
+        exceptionName: string;
+    } | string | null;
+    callStackTree?: ICallStackTree | null;
+    /** `null` for an orphan crash with no attributable session. @platform android */
+    sessionId?: string | null;
+    appVersion: string;
+    timestampBegin: string;
+    /** @platform ios */
+    timestampEnd?: string;
+    ingestedAt: string;
+};
+export type INetworkRequestStartedEvent = {
+    id: string;
+    url: string;
+    method: string;
+    startedAt: string;
+};
+export type INetworkRequestRedirect = {
+    fromUrl: string;
+    toUrl: string;
+    statusCode: number;
+};
+export type INetworkRequestCompletedEvent = {
+    id: string;
+    url: string;
+    method: string;
+    statusCode: number | null;
+    networkProtocol: string | null;
+    requestBytesSent: number | null;
+    responseBytesReceived: number | null;
+    errorDescription: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    totalDuration: number;
+    redirects: INetworkRequestRedirect[];
+};
+/** An unset field places no constraint; fields AND together, entries within one OR together */
+export type INetworkRequestFilter = {
+    hosts?: string[] | null;
+    methods?: string[] | null;
+};
+export type INetworkRequestObserverEvents = {
+    requestStarted(event: INetworkRequestStartedEvent): void;
+    requestCompleted(event: INetworkRequestCompletedEvent): void;
+};
+/** Debug-only, from `getInactiveSessions()` as a plain eager record, not a shared object */
+export type IDebugSession = {
+    id: string;
+    type: ISessionType;
+    startDate: string;
+    endDate?: string | null;
+    metrics: IMetric[];
+    logs: ILogRecord[];
+    crashReport?: ICrashReport | null;
+};
+/** Recorded natively as an OpenTelemetry-shaped `js.exception` log event */
+export type IReportErrorInput = {
+    source: 'global' | 'errorBoundary' | 'reportedByUser';
+    type?: string;
+    message: string;
+    stacktrace?: string;
+    /** The React component stack, error-boundary captures only */
+    componentStack?: string;
+    isFatal: boolean;
+};

package/build/core/types.js

@@ -0,0 +1,3 @@
+// Ported verbatim from expo-app-metrics's types.ts (sdk-57), renamed with this repo's
+// `I`-prefix convention
+export {};

package/build/react/app-metrics-error-boundary.d.ts

@@ -0,0 +1,26 @@
+import { Component, type ErrorInfo, type ReactElement, type ReactNode } from 'react';
+export type IAppMetricsErrorBoundaryFallbackProps = {
+    /** The value the subtree threw, usually an `Error` but any value can be thrown */
+    error: unknown;
+    /** Clears the caught error and re-renders the children from a clean, re-mounted state */
+    resetError: () => void;
+};
+export type IAppMetricsErrorBoundaryProps = {
+    children: ReactNode;
+    /** A React element, a render function receiving `error`/`resetError`, or `null` */
+    fallback: ReactElement | null | ((props: IAppMetricsErrorBoundaryFallbackProps) => ReactNode);
+};
+type IState = {
+    /** Tracked separately from `error` since the thrown value itself can be falsy */
+    hasError: boolean;
+    error: unknown;
+};
+/** Records a render-phase error via `reportError` and renders `fallback` in place of it */
+export declare class AppMetricsErrorBoundary extends Component<IAppMetricsErrorBoundaryProps, IState> {
+    state: IState;
+    static getDerivedStateFromError(error: unknown): IState;
+    componentDidCatch(error: unknown, errorInfo: ErrorInfo): void;
+    render(): ReactNode;
+    private resetError;
+}
+export {};

package/build/react/app-metrics-error-boundary.js

@@ -0,0 +1,28 @@
+import { Component, } from 'react';
+import { reportCaughtError } from '../core/report-caught-error.js';
+/** Records a render-phase error via `reportError` and renders `fallback` in place of it */
+export class AppMetricsErrorBoundary extends Component {
+    state = { hasError: false, error: null };
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error };
+    }
+    componentDidCatch(error, errorInfo) {
+        if (__DEV__) {
+            console.warn('[app-metrics] AppMetricsErrorBoundary caught a render error:', error);
+        }
+        reportCaughtError(error, errorInfo.componentStack?.trim() || undefined);
+    }
+    render() {
+        if (!this.state.hasError) {
+            return this.props.children;
+        }
+        const { fallback } = this.props;
+        if (typeof fallback === 'function') {
+            return fallback({ error: this.state.error, resetError: this.resetError });
+        }
+        return fallback;
+    }
+    resetError = () => {
+        this.setState({ hasError: false, error: null });
+    };
+}

package/build/react/app-metrics-root.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentType, type ReactElement, type ReactNode } from 'react';
+import { type IAppMetricsErrorBoundaryProps } from './app-metrics-error-boundary';
+export type IAppMetricsRootProps = {
+    children: ReactNode;
+    /** Omitting it leaves the tree unwrapped; pass `null` to capture without rendering anything */
+    errorBoundaryFallback?: IAppMetricsErrorBoundaryProps['fallback'];
+};
+/** Marks the first render, so time-to-first-render is measured without a manual call */
+export declare function AppMetricsRoot({ children, errorBoundaryFallback, }: IAppMetricsRootProps): ReactElement;
+export declare namespace AppMetricsRoot {
+    var wrap: <P extends Record<string, unknown>>(WrappedComponent: ComponentType<P>) => ComponentType<P>;
+}

package/build/react/app-metrics-root.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, } from 'react';
+import { markFirstRender } from '../core/index.js';
+import { AppMetricsErrorBoundary, } from './app-metrics-error-boundary.js';
+/** Marks the first render, so time-to-first-render is measured without a manual call */
+export function AppMetricsRoot({ children, errorBoundaryFallback, }) {
+    useEffect(() => {
+        markFirstRender();
+    }, []);
+    // Only OMITTING the prop leaves the tree unwrapped - an explicit `null` still mounts the
+    // boundary and renders nothing, so the error is captured rather than propagating
+    if (errorBoundaryFallback !== undefined) {
+        return (_jsx(AppMetricsErrorBoundary, { fallback: errorBoundaryFallback, children: children }));
+    }
+    return _jsx(_Fragment, { children: children });
+}
+/** Wraps `WrappedComponent` in a root, for one call at the app's entry point */
+AppMetricsRoot.wrap = function wrap(WrappedComponent) {
+    function Wrapped(props) {
+        return (_jsx(AppMetricsRoot, { children: _jsx(WrappedComponent, { ...props }) }));
+    }
+    Wrapped.displayName = `AppMetricsRoot(${WrappedComponent.displayName || WrappedComponent.name || 'Component'})`;
+    return Wrapped;
+};

package/build/react/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../core';
+export { AppMetricsErrorBoundary, type IAppMetricsErrorBoundaryFallbackProps, type IAppMetricsErrorBoundaryProps, } from './app-metrics-error-boundary';
+export { AppMetricsRoot, type IAppMetricsRootProps } from './app-metrics-root';
+export { useNetworkRequestObserver, type IUseNetworkRequestObserverOptions, } from './use-network-request-observer';

package/build/react/index.js

@@ -0,0 +1,4 @@
+export * from '../core/index.js';
+export { AppMetricsErrorBoundary, } from './app-metrics-error-boundary.js';
+export { AppMetricsRoot } from './app-metrics-root.js';
+export { useNetworkRequestObserver, } from './use-network-request-observer.js';

package/build/react/use-network-request-observer.d.ts

@@ -0,0 +1,5 @@
+import { NetworkRequestObserver } from '../core';
+import type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+export type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+/** Allocates a `NetworkRequestObserver` for the component's lifetime, releases it on unmount */
+export declare function useNetworkRequestObserver(options?: IUseNetworkRequestObserverOptions): NetworkRequestObserver;

package/build/react/use-network-request-observer.js

@@ -0,0 +1,23 @@
+import { useEffect, useRef } from 'react';
+import { useReleasingSharedObject } from 'expo-modules-core';
+import { NetworkRequestObserver } from '../core/index.js';
+import { filterKeyOf, subscribeNetworkRequestObserverEvents, } from '../core/network-request-observer-subscription.js';
+/** Allocates a `NetworkRequestObserver` for the component's lifetime, releases it on unmount */
+export function useNetworkRequestObserver(options = {}) {
+    const filterKey = filterKeyOf(options.filter);
+    const observer = useReleasingSharedObject(() => new NetworkRequestObserver(options.filter), []);
+    // The constructor already applied the initial filter - only a LATER change goes through
+    // `setFilter`, seeded with the mount key so the first effect run is a no-op
+    const appliedFilterKey = useRef(filterKey);
+    useEffect(() => {
+        if (appliedFilterKey.current === filterKey)
+            return;
+        appliedFilterKey.current = filterKey;
+        observer.setFilter(options.filter ?? null);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [observer, filterKey]);
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    useEffect(() => subscribeNetworkRequestObserverEvents(observer, () => optionsRef.current), [observer]);
+    return observer;
+}

package/build/solid/app-metrics-error-boundary.d.ts

@@ -0,0 +1,15 @@
+import { type JSX } from 'solid-js';
+export type IAppMetricsErrorBoundaryFallbackProps = {
+    /** The value the subtree threw, usually an `Error` but any value can be thrown */
+    error: unknown;
+    /** Clears the caught error and re-renders the children from a clean state */
+    resetError: () => void;
+};
+export type IAppMetricsErrorBoundaryFallback = JSX.Element | ((props: IAppMetricsErrorBoundaryFallbackProps) => JSX.Element);
+export type IAppMetricsErrorBoundaryProps = {
+    /** A JSX element, a render function receiving `error`/`resetError`, or `null` */
+    fallback: IAppMetricsErrorBoundaryFallback;
+    children: JSX.Element;
+};
+/** Records a render-phase error, renders `fallback` in place of the failed subtree */
+export declare function AppMetricsErrorBoundary(props: IAppMetricsErrorBoundaryProps): JSX.Element;

package/build/solid/app-metrics-error-boundary.js

@@ -0,0 +1,17 @@
+import { ErrorBoundary } from 'solid-js';
+import { reportCaughtError } from '../core/report-caught-error.js';
+/** Records a render-phase error, renders `fallback` in place of the failed subtree */
+export function AppMetricsErrorBoundary(props) {
+    return ErrorBoundary({
+        fallback: (error, resetError) => {
+            reportCaughtError(error);
+            const { fallback } = props;
+            return typeof fallback === 'function'
+                ? fallback({ error, resetError })
+                : fallback;
+        },
+        get children() {
+            return props.children;
+        },
+    });
+}

package/build/solid/app-metrics-root.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from 'solid-js';
+import { type IAppMetricsErrorBoundaryFallback } from './app-metrics-error-boundary';
+export type IAppMetricsRootProps = {
+    /** Omitting it leaves children unwrapped; pass `null` to capture without a fallback */
+    errorBoundaryFallback?: IAppMetricsErrorBoundaryFallback;
+    children: JSX.Element;
+};
+/** Marks the first render, so time-to-first-render is measured without a manual call */
+export declare function AppMetricsRoot(props: IAppMetricsRootProps): JSX.Element;

package/build/solid/app-metrics-root.js

@@ -0,0 +1,18 @@
+import { onMount } from 'solid-js';
+import { markFirstRender } from '../core/index.js';
+import { AppMetricsErrorBoundary, } from './app-metrics-error-boundary.js';
+/** Marks the first render, so time-to-first-render is measured without a manual call */
+export function AppMetricsRoot(props) {
+    onMount(() => markFirstRender());
+    // Only OMITTING the prop leaves children unwrapped - an explicit `null` still mounts the
+    // boundary and renders nothing, so the error is captured rather than propagating
+    if (props.errorBoundaryFallback === undefined) {
+        return props.children;
+    }
+    return AppMetricsErrorBoundary({
+        fallback: props.errorBoundaryFallback,
+        get children() {
+            return props.children;
+        },
+    });
+}

package/build/solid/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../core';
+export { AppMetricsErrorBoundary, type IAppMetricsErrorBoundaryFallback, type IAppMetricsErrorBoundaryFallbackProps, type IAppMetricsErrorBoundaryProps, } from './app-metrics-error-boundary';
+export { AppMetricsRoot, type IAppMetricsRootProps } from './app-metrics-root';
+export { useNetworkRequestObserver, type IUseNetworkRequestObserverOptions, } from './use-network-request-observer';

package/build/solid/index.js

@@ -0,0 +1,4 @@
+export * from '../core/index.js';
+export { AppMetricsErrorBoundary, } from './app-metrics-error-boundary.js';
+export { AppMetricsRoot } from './app-metrics-root.js';
+export { useNetworkRequestObserver, } from './use-network-request-observer.js';

package/build/solid/use-network-request-observer.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkRequestObserver } from '../core';
+import type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+export type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+/** Solid twin of `expo-app-metrics`'s `useNetworkRequestObserver` */
+export declare function useNetworkRequestObserver(getOptions?: () => IUseNetworkRequestObserverOptions): NetworkRequestObserver;

package/build/solid/use-network-request-observer.js

@@ -0,0 +1,6 @@
+import { createEffect, onCleanup } from 'solid-js';
+import { createNetworkRequestObserverLifecycle } from '../core/network-request-observer-lifecycle.js';
+/** Solid twin of `expo-app-metrics`'s `useNetworkRequestObserver` */
+export function useNetworkRequestObserver(getOptions = () => ({})) {
+    return createNetworkRequestObserverLifecycle(getOptions, createEffect, onCleanup);
+}

package/build/svelte/AppMetricsErrorBoundary.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+  // Records a render-phase error and renders `fallback` in place of the failed subtree - the
+  // Svelte twin of ../react's AppMetricsErrorBoundary and ../vue's, over `<svelte:boundary>`
+  import { reportCaughtError } from '../core/report-caught-error';
+  import type { IAppMetricsErrorBoundaryProps } from './app-metrics-error-boundary-props';
+
+  let { fallback, children }: IAppMetricsErrorBoundaryProps = $props();
+</script>
+
+<svelte:boundary onerror={(error) => reportCaughtError(error)}>
+  {@render children()}
+  {#snippet failed(error, reset)}
+    {#if fallback}
+      {@render fallback({ error, resetError: reset })}
+    {/if}
+  {/snippet}
+</svelte:boundary>

package/build/svelte/AppMetricsErrorBoundary.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { IAppMetricsErrorBoundaryProps } from './app-metrics-error-boundary-props';
+declare const AppMetricsErrorBoundary: import("svelte").Component<IAppMetricsErrorBoundaryProps, {}, "">;
+type AppMetricsErrorBoundary = ReturnType<typeof AppMetricsErrorBoundary>;
+export default AppMetricsErrorBoundary;

package/build/svelte/AppMetricsRoot.svelte

@@ -0,0 +1,22 @@
+<script lang="ts">
+  // Marks the first render so time-to-first-render is measured without a manual call, the
+  // Svelte twin of ../react's AppMetricsRoot and ../vue's
+  import { onMount } from 'svelte';
+  import { markFirstRender } from '../core';
+  import AppMetricsErrorBoundary from './AppMetricsErrorBoundary.svelte';
+  import type { IAppMetricsRootProps } from './app-metrics-root-props';
+
+  let { errorBoundaryFallback, children: rootChildren }: IAppMetricsRootProps = $props();
+
+  onMount(() => markFirstRender());
+</script>
+
+{#if errorBoundaryFallback !== undefined}
+  <AppMetricsErrorBoundary fallback={errorBoundaryFallback}>
+    {#snippet children()}
+      {@render rootChildren()}
+    {/snippet}
+  </AppMetricsErrorBoundary>
+{:else}
+  {@render rootChildren()}
+{/if}

package/build/svelte/AppMetricsRoot.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { IAppMetricsRootProps } from './app-metrics-root-props';
+declare const AppMetricsRoot: import("svelte").Component<IAppMetricsRootProps, {}, "">;
+type AppMetricsRoot = ReturnType<typeof AppMetricsRoot>;
+export default AppMetricsRoot;

package/build/svelte/app-metrics-error-boundary-props.d.ts

@@ -0,0 +1,12 @@
+import type { Snippet } from 'svelte';
+export type IAppMetricsErrorBoundaryFallbackProps = {
+    /** The value the subtree threw, usually an `Error` but any value can be thrown */
+    error: unknown;
+    /** Clears the caught error and re-renders the default slot from a clean state */
+    resetError: () => void;
+};
+export type IAppMetricsErrorBoundaryProps = {
+    /** A snippet receiving `error`/`resetError`, or `null` to capture without rendering */
+    fallback: Snippet<[IAppMetricsErrorBoundaryFallbackProps]> | null;
+    children: Snippet;
+};

package/build/svelte/app-metrics-error-boundary-props.js

@@ -0,0 +1,3 @@
+// Split out like adapters/svelte/src/components/view-props.ts: `tsc --build` sees a `.svelte`
+// import only through the ambient default-export declaration, never a named type it re-exports
+export {};

package/build/svelte/app-metrics-root-props.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import type { IAppMetricsErrorBoundaryFallbackProps } from './app-metrics-error-boundary-props';
+export type IAppMetricsRootProps = {
+    /** Omitting it leaves children unwrapped; pass `null` to capture without a fallback */
+    errorBoundaryFallback?: Snippet<[
+        IAppMetricsErrorBoundaryFallbackProps
+    ]> | null;
+    children: Snippet;
+};

package/build/svelte/app-metrics-root-props.js

@@ -0,0 +1 @@
+export {};

package/build/svelte/index.d.ts

@@ -0,0 +1,7 @@
+export * from '../core';
+export type { IAppMetricsErrorBoundaryFallbackProps, IAppMetricsErrorBoundaryProps, } from './app-metrics-error-boundary-props';
+export type { IAppMetricsRootProps } from './app-metrics-root-props';
+export { default as AppMetricsErrorBoundary } from './AppMetricsErrorBoundary.svelte';
+export { default as AppMetricsRoot } from './AppMetricsRoot.svelte';
+export { useNetworkRequestObserver } from './use-network-request-observer.svelte';
+export type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';

package/build/svelte/index.js

@@ -0,0 +1,4 @@
+export * from '../core/index.js';
+export { default as AppMetricsErrorBoundary } from './AppMetricsErrorBoundary.svelte';
+export { default as AppMetricsRoot } from './AppMetricsRoot.svelte';
+export { useNetworkRequestObserver } from './use-network-request-observer.svelte';

package/build/svelte/use-network-request-observer.svelte.d.ts

@@ -0,0 +1,3 @@
+import type { NetworkRequestObserver } from '../core';
+import type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+export declare function useNetworkRequestObserver(getOptions?: () => IUseNetworkRequestObserverOptions): NetworkRequestObserver;

package/build/svelte/use-network-request-observer.svelte.js

@@ -0,0 +1,14 @@
+// `$effect` is a compiler macro, can't be passed by reference like `watchEffect`/`createEffect`,
+// so it's wrapped instead of handed to `createNetworkRequestObserverLifecycle` directly
+import { createNetworkRequestObserverLifecycle } from '../core/network-request-observer-lifecycle.js';
+export function useNetworkRequestObserver(getOptions = () => ({})) {
+    const cleanups = [];
+    const observer = createNetworkRequestObserverLifecycle(getOptions, effect => {
+        $effect(effect);
+    }, cleanup => cleanups.push(cleanup));
+    $effect(() => () => {
+        for (const cleanup of cleanups)
+            cleanup();
+    });
+    return observer;
+}

package/build/vue/app-metrics-error-boundary.d.ts

@@ -0,0 +1,14 @@
+import { type VNode } from '@vue/runtime-core';
+export type IAppMetricsErrorBoundaryFallbackProps = {
+    /** The value the subtree threw, usually an `Error` but any value can be thrown */
+    error: unknown;
+    /** Clears the caught error and re-renders the default slot from a clean state */
+    resetError: () => void;
+};
+export type IAppMetricsErrorBoundaryFallback = VNode | null | ((props: IAppMetricsErrorBoundaryFallbackProps) => VNode | null);
+export type IAppMetricsErrorBoundaryProps = {
+    /** A VNode, a render function receiving `error`/`resetError`, or `null` */
+    fallback: IAppMetricsErrorBoundaryFallback;
+};
+/** Records a render-phase error, renders `fallback` in place of the default slot */
+export declare const AppMetricsErrorBoundary: import("@vue/runtime-core").DefineSetupFnComponent<IAppMetricsErrorBoundaryProps, {}, {}, IAppMetricsErrorBoundaryProps & {}, import("@vue/runtime-core").PublicProps>;

package/build/vue/app-metrics-error-boundary.js

@@ -0,0 +1,27 @@
+import { defineComponent, onErrorCaptured, shallowRef, } from '@vue/runtime-core';
+import { reportCaughtError } from '../core/report-caught-error.js';
+/** Records a render-phase error, renders `fallback` in place of the default slot */
+export const AppMetricsErrorBoundary = defineComponent((props, { slots }) => {
+    const hasError = shallowRef(false);
+    const caughtError = shallowRef(null);
+    // Returning `false` stops propagation, keeping the error off this engine's own
+    // uncaught-error channel, same asymmetry as adapters/vue's own render errors
+    onErrorCaptured(error => {
+        hasError.value = true;
+        caughtError.value = error;
+        reportCaughtError(error);
+        return false;
+    });
+    function resetError() {
+        hasError.value = false;
+        caughtError.value = null;
+    }
+    return () => {
+        if (!hasError.value)
+            return slots.default?.();
+        const { fallback } = props;
+        return typeof fallback === 'function'
+            ? fallback({ error: caughtError.value, resetError })
+            : fallback;
+    };
+}, { name: 'AppMetricsErrorBoundary', props: ['fallback'] });

package/build/vue/app-metrics-root.d.ts

@@ -0,0 +1,7 @@
+import { type IAppMetricsErrorBoundaryFallback } from './app-metrics-error-boundary';
+export type IAppMetricsRootProps = {
+    /** Omitting it leaves the default slot unwrapped; pass `null` to capture without rendering */
+    errorBoundaryFallback?: IAppMetricsErrorBoundaryFallback;
+};
+/** Marks the first render, so time-to-first-render is measured without a manual call */
+export declare const AppMetricsRoot: import("@vue/runtime-core").DefineSetupFnComponent<IAppMetricsRootProps, {}, {}, IAppMetricsRootProps & {}, import("@vue/runtime-core").PublicProps>;

package/build/vue/app-metrics-root.js

@@ -0,0 +1,15 @@
+import { defineComponent, h, onMounted } from '@vue/runtime-core';
+import { markFirstRender } from '../core/index.js';
+import { AppMetricsErrorBoundary, } from './app-metrics-error-boundary.js';
+/** Marks the first render, so time-to-first-render is measured without a manual call */
+export const AppMetricsRoot = defineComponent((props, { slots }) => {
+    onMounted(() => markFirstRender());
+    return () => {
+        // Only OMITTING the prop leaves the slot unwrapped - an explicit `null` still mounts the
+        // boundary and renders nothing, so the error is captured rather than propagating
+        if (props.errorBoundaryFallback !== undefined) {
+            return h(AppMetricsErrorBoundary, { fallback: props.errorBoundaryFallback }, slots.default);
+        }
+        return slots.default?.();
+    };
+}, { name: 'AppMetricsRoot', props: ['errorBoundaryFallback'] });

package/build/vue/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../core';
+export { AppMetricsErrorBoundary, type IAppMetricsErrorBoundaryFallback, type IAppMetricsErrorBoundaryFallbackProps, type IAppMetricsErrorBoundaryProps, } from './app-metrics-error-boundary';
+export { AppMetricsRoot, type IAppMetricsRootProps } from './app-metrics-root';
+export { useNetworkRequestObserver, type IUseNetworkRequestObserverOptions, } from './use-network-request-observer';

package/build/vue/index.js

@@ -0,0 +1,4 @@
+export * from '../core/index.js';
+export { AppMetricsErrorBoundary, } from './app-metrics-error-boundary.js';
+export { AppMetricsRoot } from './app-metrics-root.js';
+export { useNetworkRequestObserver, } from './use-network-request-observer.js';

package/build/vue/use-network-request-observer.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkRequestObserver } from '../core';
+import type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+export type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+/** Vue twin of `expo-app-metrics`'s `useNetworkRequestObserver` */
+export declare function useNetworkRequestObserver(getOptions?: () => IUseNetworkRequestObserverOptions): NetworkRequestObserver;

package/build/vue/use-network-request-observer.js

@@ -0,0 +1,6 @@
+import { onUnmounted, watchEffect } from '@vue/runtime-core';
+import { createNetworkRequestObserverLifecycle } from '../core/network-request-observer-lifecycle.js';
+/** Vue twin of `expo-app-metrics`'s `useNetworkRequestObserver` */
+export function useNetworkRequestObserver(getOptions = () => ({})) {
+    return createNetworkRequestObserverLifecycle(getOptions, watchEffect, onUnmounted);
+}

package/build-ngc/angular/app-metrics-root.d.ts

@@ -0,0 +1,8 @@
+import { type OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Marks the first render, so time-to-first-render is measured without a manual call */
+export declare class AppMetricsRoot implements OnInit {
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppMetricsRoot, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppMetricsRoot, "app-metrics-root", never, {}, {}, never, ["*"], true, never>;
+}