@guidelytech/react 0.15.0 → 0.17.0

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 import * as react from 'react';
-import { ReactNode } from 'react';
+import { ReactNode, Component, ErrorInfo, ComponentType } from 'react';
 import { JsonValue, FlagsClientOptions, FlagsBootstrap, FlagsClient, FlagValue, FlagDetails, Attributes } from '@guidelytech/flags';
 export { Attributes, EvaluationResult, FlagDetails, FlagsBootstrap, FlagsClient, FlagsClientOptions, FlagsPayload, JsonValue } from '@guidelytech/flags';
-import { PublishedGuide, GuidelyOptions, GuidelyUser, GuidelyClient, ChecklistProgressState, GuidelyEvents } from '@guidelytech/sdk-core';
-export { AgentTurnInput, AgentTurnRedactor, ChecklistProgressState, GuidelyClient, GuidelyEvents, GuidelyOptions, GuidelyUser, PublishedGuide } from '@guidelytech/sdk-core';
+import { CaptureContext, ErrorLevelName, GuidelyClient, PublishedGuide, GuidelyOptions, GuidelyUser, ChecklistProgressState, GuidelyEvents } from '@guidelytech/sdk-core';
+export { AgentTurnInput, AgentTurnRedactor, Breadcrumb, CaptureContext, ChecklistProgressState, ErrorEvent, ErrorLevelName, ErrorMonitoringOptions, ExceptionDetail, GuidelyClient, GuidelyEvents, GuidelyOptions, GuidelyUser, PublishedGuide } from '@guidelytech/sdk-core';
 
 /** Is the boolean flag on? `fallback` (default `false`) until flags load, or when missing. */
 declare function useFlag(key: string, fallback?: boolean): boolean;
@@ -51,6 +51,101 @@ interface FlagsProviderProps extends Omit<FlagsClientOptions, "payload"> {
  */
 declare function FlagsProvider({ children, client: external, payload, ...options }: FlagsProviderProps): react.JSX.Element;
 
+/** `captureException`'s second argument. */
+type Hint = CaptureContext & Record<string, unknown>;
+interface ErrorBoundaryFallbackProps {
+    error: unknown;
+    componentStack: string;
+    /** The Guidely event id ("" when nothing was sent: error tracking off, no consent, filtered). */
+    eventId: string;
+    /** Clears the error and renders the children again. */
+    resetError(): void;
+}
+interface GuidelyErrorBoundaryProps {
+    children?: ReactNode;
+    /** Rendered instead of the children after an error (an element, or a function of the error). Nothing is rendered without one. */
+    fallback?: ReactNode | ((props: ErrorBoundaryFallbackProps) => ReactNode);
+    /** Called after the error is reported (`eventId` is "" when it waits for the provider's client, or was not sent). */
+    onError?: (error: unknown, componentStack: string, eventId: string) => void;
+    /** Edit what is sent (`context.tags.area = "checkout"`), like Sentry's `beforeCapture(scope, …)`. */
+    beforeCapture?: (context: CaptureContext, error: unknown, componentStack: string) => void;
+    /** Called by `resetError()`, before the children render again. */
+    onReset?: (error: unknown, componentStack: string, eventId: string) => void;
+    /** Opens the bug-report dialog for the event, when this SDK version has one. */
+    showDialog?: boolean;
+    tags?: CaptureContext["tags"];
+    extra?: CaptureContext["extra"];
+    fingerprint?: string[];
+    /** Default `error`. */
+    level?: ErrorLevelName;
+    /** Marks the error handled (default: true when a `fallback` is given, as Sentry does). */
+    handled?: boolean;
+    /** The client to report to (default: the `GuidelyProvider`'s, else the live `createGuidely()` client). */
+    client?: GuidelyClient | null;
+}
+interface BoundaryState {
+    error: unknown;
+    componentStack: string;
+    eventId: string;
+}
+/**
+ * Catches render errors in its children, reports them (`mechanism: react.errorboundary`) and
+ * renders `fallback`. Works without a provider when a client was made with `createGuidely()`.
+ *
+ * ```tsx
+ * <GuidelyErrorBoundary fallback={({ resetError }) => <button onClick={resetError}>Try again</button>} tags={{ area: "checkout" }}>
+ *   <Checkout />
+ * </GuidelyErrorBoundary>
+ * ```
+ */
+declare class GuidelyErrorBoundary extends Component<GuidelyErrorBoundaryProps, BoundaryState & {
+    failed: boolean;
+}> {
+    static contextType: react.Context<GuidelyClient | null>;
+    context: GuidelyClient | null;
+    state: {
+        failed: boolean;
+        error: unknown;
+        componentStack: string;
+        eventId: string;
+    };
+    static getDerivedStateFromError(error: unknown): Partial<BoundaryState & {
+        failed: boolean;
+    }>;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    resetError: () => void;
+    render(): ReactNode;
+}
+/** Wraps a component in a `GuidelyErrorBoundary` (Sentry's `withErrorBoundary`). */
+declare function withGuidelyErrorBoundary<P extends object>(Wrapped: ComponentType<P>, options?: Omit<GuidelyErrorBoundaryProps, "children">): ComponentType<P>;
+/**
+ * Reports `error` once (per error object) when it is set: for error pages that receive the error as
+ * a prop, such as Next.js `error.tsx` or React Router's `errorElement`. Returns the event id.
+ */
+declare function useCaptureException(error: unknown, hint?: Hint): string;
+/** What React 19 passes to `onUncaughtError` / `onCaughtError` / `onRecoverableError`. */
+interface ReactErrorInfo {
+    componentStack?: string | null;
+    /** `onCaughtError` only: the boundary that caught the error. */
+    errorBoundary?: unknown;
+}
+/**
+ * React 19 root error hooks (Sentry's `reactErrorHandler`):
+ *
+ * ```ts
+ * createRoot(el, {
+ *   onUncaughtError: guidelyReactErrorHandler(),
+ *   onCaughtError: guidelyReactErrorHandler(),
+ *   onRecoverableError: guidelyReactErrorHandler(),
+ * });
+ * ```
+ *
+ * Errors caught by a boundary are reported as handled; errors a `GuidelyErrorBoundary` caught are
+ * left to it. The client defaults to the live `createGuidely()` / provider client at the time of
+ * the error. `callback` replaces React's default logging (the error is `console.error`ed without one).
+ */
+declare function guidelyReactErrorHandler(client?: GuidelyClient | null, callback?: (error: unknown, errorInfo: ReactErrorInfo, eventId: string) => void): (error: unknown, errorInfo?: ReactErrorInfo) => void;
+
 interface GuidelyProviderProps extends Omit<GuidelyOptions, "user"> {
     /** Identify this user as soon as the client is ready; `undefined` resets the identity. */
     user?: GuidelyUser | null;
@@ -91,4 +186,4 @@ interface GuideState {
 /** Live state of a guide (by id or key): active, completed, current step. */
 declare function useGuideState(idOrKey: string): GuideState;
 
-export { Feature, FeatureFlag, type FeatureProps, FeatureValue, type FeatureValueProps, FlagsProvider, type FlagsProviderProps, type GuideState, GuidelyProvider, type GuidelyProviderProps, noopClient, useChecklistProgress, useFeatureValue, useFlag, useFlagDetails, useFlags, useFlagsClient, useFlagsReady, useGuideState, useGuidely, useGuidelyEvent, useGuidelyIdentify, useGuidelyReady };
+export { type ErrorBoundaryFallbackProps, Feature, FeatureFlag, type FeatureProps, FeatureValue, type FeatureValueProps, FlagsProvider, type FlagsProviderProps, type GuideState, GuidelyErrorBoundary, type GuidelyErrorBoundaryProps, GuidelyProvider, type GuidelyProviderProps, type ReactErrorInfo, guidelyReactErrorHandler, noopClient, useCaptureException, useChecklistProgress, useFeatureValue, useFlag, useFlagDetails, useFlags, useFlagsClient, useFlagsReady, useGuideState, useGuidely, useGuidelyEvent, useGuidelyIdentify, useGuidelyReady, withGuidelyErrorBoundary };

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import * as react from 'react';
-import { ReactNode } from 'react';
+import { ReactNode, Component, ErrorInfo, ComponentType } from 'react';
 import { JsonValue, FlagsClientOptions, FlagsBootstrap, FlagsClient, FlagValue, FlagDetails, Attributes } from '@guidelytech/flags';
 export { Attributes, EvaluationResult, FlagDetails, FlagsBootstrap, FlagsClient, FlagsClientOptions, FlagsPayload, JsonValue } from '@guidelytech/flags';
-import { PublishedGuide, GuidelyOptions, GuidelyUser, GuidelyClient, ChecklistProgressState, GuidelyEvents } from '@guidelytech/sdk-core';
-export { AgentTurnInput, AgentTurnRedactor, ChecklistProgressState, GuidelyClient, GuidelyEvents, GuidelyOptions, GuidelyUser, PublishedGuide } from '@guidelytech/sdk-core';
+import { CaptureContext, ErrorLevelName, GuidelyClient, PublishedGuide, GuidelyOptions, GuidelyUser, ChecklistProgressState, GuidelyEvents } from '@guidelytech/sdk-core';
+export { AgentTurnInput, AgentTurnRedactor, Breadcrumb, CaptureContext, ChecklistProgressState, ErrorEvent, ErrorLevelName, ErrorMonitoringOptions, ExceptionDetail, GuidelyClient, GuidelyEvents, GuidelyOptions, GuidelyUser, PublishedGuide } from '@guidelytech/sdk-core';
 
 /** Is the boolean flag on? `fallback` (default `false`) until flags load, or when missing. */
 declare function useFlag(key: string, fallback?: boolean): boolean;
@@ -51,6 +51,101 @@ interface FlagsProviderProps extends Omit<FlagsClientOptions, "payload"> {
  */
 declare function FlagsProvider({ children, client: external, payload, ...options }: FlagsProviderProps): react.JSX.Element;
 
+/** `captureException`'s second argument. */
+type Hint = CaptureContext & Record<string, unknown>;
+interface ErrorBoundaryFallbackProps {
+    error: unknown;
+    componentStack: string;
+    /** The Guidely event id ("" when nothing was sent: error tracking off, no consent, filtered). */
+    eventId: string;
+    /** Clears the error and renders the children again. */
+    resetError(): void;
+}
+interface GuidelyErrorBoundaryProps {
+    children?: ReactNode;
+    /** Rendered instead of the children after an error (an element, or a function of the error). Nothing is rendered without one. */
+    fallback?: ReactNode | ((props: ErrorBoundaryFallbackProps) => ReactNode);
+    /** Called after the error is reported (`eventId` is "" when it waits for the provider's client, or was not sent). */
+    onError?: (error: unknown, componentStack: string, eventId: string) => void;
+    /** Edit what is sent (`context.tags.area = "checkout"`), like Sentry's `beforeCapture(scope, …)`. */
+    beforeCapture?: (context: CaptureContext, error: unknown, componentStack: string) => void;
+    /** Called by `resetError()`, before the children render again. */
+    onReset?: (error: unknown, componentStack: string, eventId: string) => void;
+    /** Opens the bug-report dialog for the event, when this SDK version has one. */
+    showDialog?: boolean;
+    tags?: CaptureContext["tags"];
+    extra?: CaptureContext["extra"];
+    fingerprint?: string[];
+    /** Default `error`. */
+    level?: ErrorLevelName;
+    /** Marks the error handled (default: true when a `fallback` is given, as Sentry does). */
+    handled?: boolean;
+    /** The client to report to (default: the `GuidelyProvider`'s, else the live `createGuidely()` client). */
+    client?: GuidelyClient | null;
+}
+interface BoundaryState {
+    error: unknown;
+    componentStack: string;
+    eventId: string;
+}
+/**
+ * Catches render errors in its children, reports them (`mechanism: react.errorboundary`) and
+ * renders `fallback`. Works without a provider when a client was made with `createGuidely()`.
+ *
+ * ```tsx
+ * <GuidelyErrorBoundary fallback={({ resetError }) => <button onClick={resetError}>Try again</button>} tags={{ area: "checkout" }}>
+ *   <Checkout />
+ * </GuidelyErrorBoundary>
+ * ```
+ */
+declare class GuidelyErrorBoundary extends Component<GuidelyErrorBoundaryProps, BoundaryState & {
+    failed: boolean;
+}> {
+    static contextType: react.Context<GuidelyClient | null>;
+    context: GuidelyClient | null;
+    state: {
+        failed: boolean;
+        error: unknown;
+        componentStack: string;
+        eventId: string;
+    };
+    static getDerivedStateFromError(error: unknown): Partial<BoundaryState & {
+        failed: boolean;
+    }>;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    resetError: () => void;
+    render(): ReactNode;
+}
+/** Wraps a component in a `GuidelyErrorBoundary` (Sentry's `withErrorBoundary`). */
+declare function withGuidelyErrorBoundary<P extends object>(Wrapped: ComponentType<P>, options?: Omit<GuidelyErrorBoundaryProps, "children">): ComponentType<P>;
+/**
+ * Reports `error` once (per error object) when it is set: for error pages that receive the error as
+ * a prop, such as Next.js `error.tsx` or React Router's `errorElement`. Returns the event id.
+ */
+declare function useCaptureException(error: unknown, hint?: Hint): string;
+/** What React 19 passes to `onUncaughtError` / `onCaughtError` / `onRecoverableError`. */
+interface ReactErrorInfo {
+    componentStack?: string | null;
+    /** `onCaughtError` only: the boundary that caught the error. */
+    errorBoundary?: unknown;
+}
+/**
+ * React 19 root error hooks (Sentry's `reactErrorHandler`):
+ *
+ * ```ts
+ * createRoot(el, {
+ *   onUncaughtError: guidelyReactErrorHandler(),
+ *   onCaughtError: guidelyReactErrorHandler(),
+ *   onRecoverableError: guidelyReactErrorHandler(),
+ * });
+ * ```
+ *
+ * Errors caught by a boundary are reported as handled; errors a `GuidelyErrorBoundary` caught are
+ * left to it. The client defaults to the live `createGuidely()` / provider client at the time of
+ * the error. `callback` replaces React's default logging (the error is `console.error`ed without one).
+ */
+declare function guidelyReactErrorHandler(client?: GuidelyClient | null, callback?: (error: unknown, errorInfo: ReactErrorInfo, eventId: string) => void): (error: unknown, errorInfo?: ReactErrorInfo) => void;
+
 interface GuidelyProviderProps extends Omit<GuidelyOptions, "user"> {
     /** Identify this user as soon as the client is ready; `undefined` resets the identity. */
     user?: GuidelyUser | null;
@@ -91,4 +186,4 @@ interface GuideState {
 /** Live state of a guide (by id or key): active, completed, current step. */
 declare function useGuideState(idOrKey: string): GuideState;
 
-export { Feature, FeatureFlag, type FeatureProps, FeatureValue, type FeatureValueProps, FlagsProvider, type FlagsProviderProps, type GuideState, GuidelyProvider, type GuidelyProviderProps, noopClient, useChecklistProgress, useFeatureValue, useFlag, useFlagDetails, useFlags, useFlagsClient, useFlagsReady, useGuideState, useGuidely, useGuidelyEvent, useGuidelyIdentify, useGuidelyReady };
+export { type ErrorBoundaryFallbackProps, Feature, FeatureFlag, type FeatureProps, FeatureValue, type FeatureValueProps, FlagsProvider, type FlagsProviderProps, type GuideState, GuidelyErrorBoundary, type GuidelyErrorBoundaryProps, GuidelyProvider, type GuidelyProviderProps, type ReactErrorInfo, guidelyReactErrorHandler, noopClient, useCaptureException, useChecklistProgress, useFeatureValue, useFlag, useFlagDetails, useFlags, useFlagsClient, useFlagsReady, useGuideState, useGuidely, useGuidelyEvent, useGuidelyIdentify, useGuidelyReady, withGuidelyErrorBoundary };

package/dist/index.js

@@ -1,19 +1,146 @@
 "use client";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.tsx
 import { createStaticFlags as createStaticFlags2, stableStringify as stableStringify2 } from "@guidelytech/flags";
 import { createGuidely } from "@guidelytech/sdk-core";
-import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { useContext as useContext3, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef2, useState as useState3 } from "react";
+
+// src/context.ts
+import { createContext } from "react";
+var GuidelyContext = createContext(null);
+
+// src/errors.tsx
+import { GuidelyClient } from "@guidelytech/sdk-core";
+import { Component, useContext, useEffect, useState, version } from "react";
+import { jsx } from "react/jsx-runtime";
+var reported = /* @__PURE__ */ new WeakSet();
+var stackOf = (info) => (info?.componentStack ?? "").slice(0, 8e3);
+function liveClient(client) {
+  try {
+    if (client && !client.getState().destroyed) return client;
+    const current = GuidelyClient.get();
+    return current && !current.getState().destroyed ? current : null;
+  } catch {
+    return null;
+  }
+}
+var pending = [];
+function drainPendingErrors(client) {
+  for (const p of pending.splice(0)) {
+    let eventId = "";
+    try {
+      eventId = client.captureException(p.error, p.ctx) || "";
+    } catch {
+    }
+    if (eventId) p.done?.(eventId);
+  }
+}
+function capture(client, error, ctx, done) {
+  if (error && typeof error === "object") {
+    if (reported.has(error)) return "";
+    reported.add(error);
+  }
+  const c = liveClient(client);
+  if (!c) {
+    if (pending.length < 10) pending.push({ error, ctx, done });
+    return "";
+  }
+  try {
+    return c.captureException(error, ctx) || "";
+  } catch {
+    return "";
+  }
+}
+var EMPTY = { error: null, componentStack: "", eventId: "" };
+var GuidelyErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "state", { ...EMPTY, failed: false });
+    __publicField(this, "resetError", () => {
+      const { error, componentStack, eventId } = this.state;
+      this.props.onReset?.(error, componentStack, eventId);
+      this.setState({ ...EMPTY, failed: false });
+    });
+  }
+  static getDerivedStateFromError(error) {
+    return { error, failed: true };
+  }
+  componentDidCatch(error, info) {
+    const { tags, extra, fingerprint, level, handled, fallback, beforeCapture, onError, showDialog } = this.props;
+    const componentStack = stackOf(info);
+    const ctx = {
+      level: level ?? "error",
+      ...tags ? { tags: { ...tags } } : {},
+      ...extra ? { extra: { ...extra } } : {},
+      ...fingerprint ? { fingerprint } : {},
+      contexts: { react: { version, componentStack } },
+      mechanism: { type: "react.errorboundary", handled: handled ?? !!fallback }
+    };
+    try {
+      beforeCapture?.(ctx, error, componentStack);
+    } catch {
+    }
+    const client = this.props.client ?? this.context;
+    const eventId = capture(client, error, ctx, (id) => {
+      if (this.state.error === error) this.setState({ eventId: id });
+    });
+    this.setState({ componentStack, eventId });
+    onError?.(error, componentStack, eventId);
+    if (showDialog && eventId) {
+      try {
+        liveClient(client)?.showBugReport?.();
+      } catch {
+      }
+    }
+  }
+  render() {
+    if (!this.state.failed) return this.props.children;
+    const { fallback } = this.props;
+    if (typeof fallback === "function") return fallback({ error: this.state.error, componentStack: this.state.componentStack, eventId: this.state.eventId, resetError: this.resetError });
+    return fallback ?? null;
+  }
+};
+__publicField(GuidelyErrorBoundary, "contextType", GuidelyContext);
+function withGuidelyErrorBoundary(Wrapped, options = {}) {
+  const name = Wrapped.displayName || Wrapped.name || "Component";
+  const WithBoundary = (props) => /* @__PURE__ */ jsx(GuidelyErrorBoundary, { ...options, children: /* @__PURE__ */ jsx(Wrapped, { ...props }) });
+  WithBoundary.displayName = `guidelyErrorBoundary(${name})`;
+  return WithBoundary;
+}
+function useCaptureException(error, hint) {
+  const client = useContext(GuidelyContext);
+  const [eventId, setEventId] = useState("");
+  useEffect(() => {
+    if (error === null || error === void 0) return;
+    const id = capture(client, error, { ...hint ?? {}, mechanism: hint?.mechanism ?? { type: "react.errorpage", handled: true } }, setEventId);
+    if (id) setEventId(id);
+  }, [client, error]);
+  return eventId;
+}
+function guidelyReactErrorHandler(client, callback) {
+  return (error, errorInfo = {}) => {
+    let eventId = "";
+    if (!(errorInfo.errorBoundary instanceof GuidelyErrorBoundary)) {
+      const caught = errorInfo.errorBoundary !== void 0 && errorInfo.errorBoundary !== null;
+      eventId = capture(client ?? null, error, { contexts: { react: { version, componentStack: stackOf(errorInfo) } }, mechanism: { type: "react", handled: caught } });
+    }
+    if (callback) callback(error, errorInfo, eventId);
+    else console.error(error);
+  };
+}
 
 // src/flags.tsx
 import { createFlagsClient, createStaticFlags, jsonEquals, stableStringify } from "@guidelytech/flags";
-import { createContext, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { Fragment, jsx } from "react/jsx-runtime";
-var FlagsContext = createContext(null);
-var EMPTY = createStaticFlags();
+import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useMemo, useRef, useState as useState2, useSyncExternalStore } from "react";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+var FlagsContext = createContext2(null);
+var EMPTY2 = createStaticFlags();
 function useReader() {
-  const src = useContext(FlagsContext);
-  return src?.client ?? src?.bootstrap ?? EMPTY;
+  const src = useContext2(FlagsContext);
+  return src?.client ?? src?.bootstrap ?? EMPTY2;
 }
 function useFlagsValue(select) {
   const reader = useReader();
@@ -43,29 +170,29 @@ function useFlagsReady() {
   return useFlagsValue((r) => r.isReady());
 }
 function useFlagsClient() {
-  return useContext(FlagsContext)?.client ?? null;
+  return useContext2(FlagsContext)?.client ?? null;
 }
 function Feature({ flag, children, fallback = null }) {
-  return /* @__PURE__ */ jsx(Fragment, { children: useFlag(flag) ? children : fallback });
+  return /* @__PURE__ */ jsx2(Fragment, { children: useFlag(flag) ? children : fallback });
 }
 var FeatureFlag = Feature;
 function FeatureValue({ flag, value, children, fallback = null }) {
   const current = useFeatureValue(flag, null);
-  return /* @__PURE__ */ jsx(Fragment, { children: jsonEquals(current, value) ? children : fallback });
+  return /* @__PURE__ */ jsx2(Fragment, { children: jsonEquals(current, value) ? children : fallback });
 }
 function useBootstrap(payload, attributes) {
   const key = stableStringify(attributes);
-  return useMemo(() => payload ? createStaticFlags({ payload, attributes }) : EMPTY, [payload, key]);
+  return useMemo(() => payload ? createStaticFlags({ payload, attributes }) : EMPTY2, [payload, key]);
 }
 function FlagsProvider({ children, client: external, payload, ...options }) {
-  const [created, setCreated] = useState(null);
+  const [created, setCreated] = useState2(null);
   const optionsRef = useRef(options);
   optionsRef.current = options;
   const sdkKey = options.sdkKey ?? options.projectId;
   const { apiUrl, environment } = options;
   const payloadRef = useRef(payload);
   payloadRef.current = payload;
-  useEffect(() => {
+  useEffect2(() => {
     if (external || !sdkKey || typeof window === "undefined") return;
     let c;
     try {
@@ -83,23 +210,22 @@ function FlagsProvider({ children, client: external, payload, ...options }) {
   const client = external ?? created;
   const attributes = options.attributes ?? {};
   const attrsKey = stableStringify(attributes);
-  useEffect(() => {
+  useEffect2(() => {
     if (client && options.attributes) client.setAttributes(options.attributes);
   }, [client, attrsKey]);
   const bootstrap = useBootstrap(payload, attributes);
   const value = useMemo(() => ({ client, bootstrap }), [client, bootstrap]);
-  return /* @__PURE__ */ jsx(FlagsContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx2(FlagsContext.Provider, { value, children });
 }
 
 // src/index.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-var GuidelyContext = createContext2(null);
+import { jsx as jsx3 } from "react/jsx-runtime";
 function userAttributes(user) {
   if (!user?.id) return {};
   return { ...user.traits ?? {}, id: user.id, ...user.account ? { account: { ...user.account.traits ?? {}, id: user.account.id } } : {} };
 }
 function GuidelyProvider({ children, user, flagsPayload, flagAttributes, ...options }) {
-  const [client, setClient] = useState2(null);
+  const [client, setClient] = useState3(null);
   const optionsRef = useRef2(options);
   optionsRef.current = options;
   const userRef = useRef2(user);
@@ -112,22 +238,23 @@ function GuidelyProvider({ children, user, flagsPayload, flagAttributes, ...opti
   const appAttributesRef = useRef2(appAttributes);
   appAttributesRef.current = appAttributes;
   const { projectId, environment, apiUrl } = options;
-  useEffect2(() => {
+  useEffect3(() => {
     if (typeof window === "undefined" || !projectId) return;
     const o = optionsRef.current;
     const c = createGuidely({ ...o, projectId, environment, apiUrl, user: userRef.current?.id ? userRef.current : void 0, flags: o.flags === false ? false : { ...o.flags ?? {}, payload: payloadRef.current ?? void 0, attributes: appAttributesRef.current } });
     setClient(c);
+    drainPendingErrors(c);
     return () => {
       c.destroy();
       setClient((cur) => cur === c ? null : cur);
     };
   }, [projectId, environment, apiUrl]);
-  useEffect2(() => {
+  useEffect3(() => {
     client?.flags.setAttributes(appAttributes);
   }, [client, appAttributes]);
   const userKey = user ? JSON.stringify([user.id, user.traits ?? null, user.account ?? null]) : "";
   const hadUser = useRef2(false);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!client) return;
     if (user && user.id) {
       hadUser.current = true;
@@ -139,7 +266,7 @@ function GuidelyProvider({ children, user, flagsPayload, flagAttributes, ...opti
   }, [client, userKey]);
   const bootstrap = useBootstrap(payload, { ...userAttributes(user), ...appAttributes });
   const flags = useMemo2(() => ({ client: client?.flags ?? null, bootstrap }), [client, bootstrap]);
-  return /* @__PURE__ */ jsx2(GuidelyContext.Provider, { value: client, children: /* @__PURE__ */ jsx2(FlagsContext.Provider, { value: flags, children }) });
+  return /* @__PURE__ */ jsx3(GuidelyContext.Provider, { value: client, children: /* @__PURE__ */ jsx3(FlagsContext.Provider, { value: flags, children }) });
 }
 var NOOP_RESULTS = {
   init: Promise.resolve(),
@@ -160,7 +287,9 @@ var NOOP_RESULTS = {
   getSessionId: "",
   isRecording: false,
   agentConversation: false,
-  trackAgentTurn: false
+  trackAgentTurn: false,
+  captureException: "",
+  captureMessage: ""
 };
 var noopFlags = new Proxy(createStaticFlags2(), {
   get(target, prop, receiver) {
@@ -188,12 +317,12 @@ var noopClient = new Proxy({}, {
   }
 });
 function useGuidely() {
-  return useContext2(GuidelyContext) ?? noopClient;
+  return useContext3(GuidelyContext) ?? noopClient;
 }
 function useGuidelyReady() {
-  const client = useContext2(GuidelyContext);
-  const [ready, setReady] = useState2(false);
-  useEffect2(() => {
+  const client = useContext3(GuidelyContext);
+  const [ready, setReady] = useState3(false);
+  useEffect3(() => {
     if (!client) {
       setReady(false);
       return;
@@ -204,27 +333,27 @@ function useGuidelyReady() {
   return ready;
 }
 function useGuidelyIdentify(userId, traits, account) {
-  const client = useContext2(GuidelyContext);
+  const client = useContext3(GuidelyContext);
   const key = JSON.stringify([userId ?? null, traits ?? null, account ?? null]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!client || !userId) return;
     void client.identify(userId, traits, account);
   }, [client, key]);
 }
 function useGuidelyEvent(event, handler) {
-  const client = useContext2(GuidelyContext);
+  const client = useContext3(GuidelyContext);
   const ref = useRef2(handler);
   ref.current = handler;
-  useEffect2(() => {
+  useEffect3(() => {
     if (!client) return;
     const cb = ((...args) => ref.current(...args));
     return client.on(event, cb);
   }, [client, event]);
 }
 function useChecklistProgress(idOrKey) {
-  const client = useContext2(GuidelyContext);
-  const [progress, setProgress] = useState2({ completedTaskIds: [], completedAt: null, dismissedAt: null });
-  useEffect2(() => {
+  const client = useContext3(GuidelyContext);
+  const [progress, setProgress] = useState3({ completedTaskIds: [], completedAt: null, dismissedAt: null });
+  useEffect3(() => {
     if (!client) return;
     const update = () => setProgress(client.getChecklistProgress(idOrKey));
     update();
@@ -234,9 +363,9 @@ function useChecklistProgress(idOrKey) {
   return progress;
 }
 function useGuideState(idOrKey) {
-  const client = useContext2(GuidelyContext);
-  const [state, setState] = useState2({ active: false, completed: false, stepId: null, stepIndex: -1, guide: null });
-  useEffect2(() => {
+  const client = useContext3(GuidelyContext);
+  const [state, setState] = useState3({ active: false, completed: false, stepId: null, stepIndex: -1, guide: null });
+  useEffect3(() => {
     if (!client) return;
     const matches = (g) => g.id === idOrKey || g.key === idOrKey;
     const compute = () => {
@@ -256,8 +385,11 @@ export {
   FeatureFlag,
   FeatureValue,
   FlagsProvider,
+  GuidelyErrorBoundary,
   GuidelyProvider,
+  guidelyReactErrorHandler,
   noopClient,
+  useCaptureException,
   useChecklistProgress,
   useFeatureValue,
   useFlag,
@@ -269,6 +401,7 @@ export {
   useGuidely,
   useGuidelyEvent,
   useGuidelyIdentify,
-  useGuidelyReady
+  useGuidelyReady,
+  withGuidelyErrorBoundary
 };
 //# sourceMappingURL=index.js.map