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

package/src/core/types.ts

@@ -0,0 +1,200 @@
+// Ported verbatim from expo-app-metrics's types.ts (sdk-57), renamed with this repo's
+// `I`-prefix convention
+
+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/src/react/app-metrics-error-boundary.tsx

@@ -0,0 +1,67 @@
+import {
+  Component,
+  type ErrorInfo,
+  type ReactElement,
+  type ReactNode,
+} from 'react';
+import { reportCaughtError } from '../core/report-caught-error';
+
+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 class AppMetricsErrorBoundary extends Component<
+  IAppMetricsErrorBoundaryProps,
+  IState
+> {
+  override state: IState = { hasError: false, error: null };
+
+  static getDerivedStateFromError(error: unknown): IState {
+    return { hasError: true, error };
+  }
+
+  override componentDidCatch(error: unknown, errorInfo: ErrorInfo): void {
+    if (__DEV__) {
+      console.warn(
+        '[app-metrics] AppMetricsErrorBoundary caught a render error:',
+        error,
+      );
+    }
+    reportCaughtError(error, errorInfo.componentStack?.trim() || undefined);
+  }
+
+  override render(): ReactNode {
+    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;
+  }
+
+  private resetError = (): void => {
+    this.setState({ hasError: false, error: null });
+  };
+}

package/src/react/app-metrics-root.tsx

@@ -0,0 +1,53 @@
+import {
+  useEffect,
+  type ComponentType,
+  type ReactElement,
+  type ReactNode,
+} from 'react';
+import { markFirstRender } from '../core';
+import {
+  AppMetricsErrorBoundary,
+  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 function AppMetricsRoot({
+  children,
+  errorBoundaryFallback,
+}: IAppMetricsRootProps): ReactElement {
+  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 (
+      <AppMetricsErrorBoundary fallback={errorBoundaryFallback}>
+        {children}
+      </AppMetricsErrorBoundary>
+    );
+  }
+  return <>{children}</>;
+}
+
+/** Wraps `WrappedComponent` in a root, for one call at the app's entry point */
+AppMetricsRoot.wrap = function wrap<P extends Record<string, unknown>>(
+  WrappedComponent: ComponentType<P>,
+): ComponentType<P> {
+  function Wrapped(props: P): ReactElement {
+    return (
+      <AppMetricsRoot>
+        <WrappedComponent {...props} />
+      </AppMetricsRoot>
+    );
+  }
+  Wrapped.displayName = `AppMetricsRoot(${WrappedComponent.displayName || WrappedComponent.name || 'Component'})`;
+  return Wrapped;
+};

package/src/react/index.ts

@@ -0,0 +1,11 @@
+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/src/react/use-network-request-observer.ts

@@ -0,0 +1,41 @@
+import { useEffect, useRef } from 'react';
+import { useReleasingSharedObject } from 'expo-modules-core';
+import { NetworkRequestObserver } from '../core';
+import {
+  filterKeyOf,
+  subscribeNetworkRequestObserverEvents,
+} from '../core/network-request-observer-subscription';
+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 function useNetworkRequestObserver(
+  options: IUseNetworkRequestObserverOptions = {},
+): NetworkRequestObserver {
+  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/src/solid/app-metrics-error-boundary.tsx

@@ -0,0 +1,36 @@
+import { ErrorBoundary, type JSX } from 'solid-js';
+import { reportCaughtError } from '../core/report-caught-error';
+
+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 function AppMetricsErrorBoundary(
+  props: IAppMetricsErrorBoundaryProps,
+): JSX.Element {
+  return ErrorBoundary({
+    fallback: (error: unknown, resetError: () => void): JSX.Element => {
+      reportCaughtError(error);
+      const { fallback } = props;
+      return typeof fallback === 'function'
+        ? fallback({ error, resetError })
+        : fallback;
+    },
+    get children(): JSX.Element {
+      return props.children;
+    },
+  });
+}

package/src/solid/app-metrics-root.tsx

@@ -0,0 +1,29 @@
+import { onMount, type JSX } from 'solid-js';
+import { markFirstRender } from '../core';
+import {
+  AppMetricsErrorBoundary,
+  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 function AppMetricsRoot(props: IAppMetricsRootProps): JSX.Element {
+  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(): JSX.Element {
+      return props.children;
+    },
+  });
+}

package/src/solid/index.ts

@@ -0,0 +1,12 @@
+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/src/solid/use-network-request-observer.ts

@@ -0,0 +1,17 @@
+import { createEffect, onCleanup } from 'solid-js';
+import { createNetworkRequestObserverLifecycle } from '../core/network-request-observer-lifecycle';
+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 function useNetworkRequestObserver(
+  getOptions: () => IUseNetworkRequestObserverOptions = () => ({}),
+): NetworkRequestObserver {
+  return createNetworkRequestObserverLifecycle(
+    getOptions,
+    createEffect,
+    onCleanup,
+  );
+}

package/src/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/src/svelte/AppMetricsRoot.svelte

@@ -0,0 +1,21 @@
+<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}>
+    {@render rootChildren()}
+  </AppMetricsErrorBoundary>
+{:else}
+  {@render rootChildren()}
+{/if}

package/src/svelte/app-metrics-error-boundary-props.ts

@@ -0,0 +1,17 @@
+// 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
+
+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/src/svelte/app-metrics-root-props.ts

@@ -0,0 +1,10 @@
+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/src/svelte/index.ts

@@ -0,0 +1,10 @@
+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/src/svelte/svelte-compile.test-helper.ts

@@ -0,0 +1,7 @@
+// Re-exports the existing harness instead of a third copy (packages/sqlite and
+// packages/navigation each already carry one, not part of either package's public exports)
+export {
+  createSvelteHarness,
+  loadComponent,
+  type ISvelteHarness,
+} from '../../../sqlite/src/svelte/svelte-compile.test-helper';

package/src/svelte/use-network-request-observer.svelte.ts

@@ -0,0 +1,26 @@
+// `$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';
+import type { NetworkRequestObserver } from '../core';
+import type { IUseNetworkRequestObserverOptions } from '../core/network-request-observer-lifecycle';
+
+export function useNetworkRequestObserver(
+  getOptions: () => IUseNetworkRequestObserverOptions = () => ({}),
+): NetworkRequestObserver {
+  const cleanups: Array<() => void> = [];
+
+  const observer = createNetworkRequestObserverLifecycle(
+    getOptions,
+    effect => {
+      $effect(effect);
+    },
+    cleanup => cleanups.push(cleanup),
+  );
+
+  $effect(() => () => {
+    for (const cleanup of cleanups) cleanup();
+  });
+
+  return observer;
+}

package/src/vue/app-metrics-error-boundary.ts

@@ -0,0 +1,56 @@
+import {
+  defineComponent,
+  onErrorCaptured,
+  shallowRef,
+  type VNode,
+} from '@vue/runtime-core';
+import { reportCaughtError } from '../core/report-caught-error';
+
+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 const AppMetricsErrorBoundary =
+  defineComponent<IAppMetricsErrorBoundaryProps>(
+    (props, { slots }) => {
+      const hasError = shallowRef(false);
+      const caughtError = shallowRef<unknown>(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(): void {
+        hasError.value = false;
+        caughtError.value = null;
+      }
+
+      return (): VNode | VNode[] | null | undefined => {
+        if (!hasError.value) return slots.default?.();
+        const { fallback } = props;
+        return typeof fallback === 'function'
+          ? fallback({ error: caughtError.value, resetError })
+          : fallback;
+      };
+    },
+    { name: 'AppMetricsErrorBoundary', props: ['fallback'] },
+  );

package/src/vue/app-metrics-root.ts

@@ -0,0 +1,32 @@
+import { defineComponent, h, onMounted, type VNode } from '@vue/runtime-core';
+import { markFirstRender } from '../core';
+import {
+  AppMetricsErrorBoundary,
+  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 const AppMetricsRoot = defineComponent<IAppMetricsRootProps>(
+  (props, { slots }) => {
+    onMounted(() => markFirstRender());
+
+    return (): VNode | VNode[] | null | undefined => {
+      // 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'] },
+);