feat: forward all post options through to bugsplat-js

Re-export upstream BugSplatOptions as BugSplatPostOptions/BugSplatFeedbackOptions
and pass the whole options bag through to bs.post()/bs.postFeedback(), so
consumers can use attachments and attributes (e.g. to bundle a componentStack
with user-entered context from an ErrorBoundary fallback).

Adds a README recipe showing the disablePost + manual-post pattern.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: bobbyg603

README.md

@@ -177,6 +177,57 @@ The fallback prop accepts a React node or a render function:
 </ErrorBoundary>
 ```
 
+### Collecting user input before posting
+
+By default, `<ErrorBoundary>` posts to BugSplat the moment it catches an error. If you'd rather give the user a chance to describe what they were doing first — and bundle that into a single report instead of two — set `disablePost` on the boundary and post manually from your fallback:
+
+```tsx
+import { useState } from 'react';
+import { ErrorBoundary, post } from '@bugsplat/expo';
+import { Text, TextInput, Button, View } from 'react-native';
+
+<ErrorBoundary
+  disablePost
+  fallback={({ error, componentStack, resetErrorBoundary }) => {
+    const [description, setDescription] = useState('');
+    const [posted, setPosted] = useState(false);
+
+    const submit = async () => {
+      if (posted) return;
+      setPosted(true);
+      await post(error, {
+        description,
+        attributes: { route: 'tasks/123' },
+        attachments: componentStack
+          ? [{
+              filename: 'componentStack.txt',
+              data: new TextEncoder().encode(componentStack),
+            }]
+          : undefined,
+      });
+    };
+
+    return (
+      <View>
+        <Text>Something went wrong: {error.message}</Text>
+        <TextInput value={description} onChangeText={setDescription} />
+        <Button title="Submit" onPress={submit} />
+        <Button title="Dismiss" onPress={() => { submit(); resetErrorBoundary(); }} />
+      </View>
+    );
+  }}
+>
+  <App />
+</ErrorBoundary>
+```
+
+A few notes on this pattern:
+
+- `post()` is **not** idempotent. The `posted` flag in the example is the consumer's responsibility — without it, "Submit then Dismiss" would fire two reports.
+- `componentStack` is wrapped in `Uint8Array` via `TextEncoder` (works on both web and native via Hermes). If you only target web, `new Blob([componentStack], { type: 'text/plain' })` reads more naturally.
+- `attributes` becomes a queryable column in the BugSplat dashboard — useful for filtering crashes by route, feature flag, build channel, etc.
+- If posting fails and you want retry, catch errors from `post()` and reset `posted` accordingly. The recipe doesn't show this to keep it minimal.
+
 ### User Feedback
 
 Submit user feedback tied to your BugSplat database. Works on iOS, Android, and Web.

src/BugsplatExpo.ts

@@ -112,12 +112,7 @@ export async function post(
 
   const err = error instanceof Error ? error : new Error(error);
   try {
-    const result = await jsClient.post(err, {
-      appKey: options?.appKey,
-      user: options?.user,
-      email: options?.email,
-      description: options?.description,
-    });
+    const result = await jsClient.post(err, options);
     if (result.error) {
       return { success: false, error: result.error.message };
     }
@@ -144,12 +139,7 @@ export async function postFeedback(
   }
 
   try {
-    const result = await jsClient.postFeedback(title, {
-      appKey: options?.appKey,
-      user: options?.user,
-      email: options?.email,
-      description: options?.description,
-    });
+    const result = await jsClient.postFeedback(title, options);
     if (result.error) {
       return { success: false, error: result.error.message };
     }

src/BugsplatExpo.types.ts

@@ -1,3 +1,10 @@
+export type {
+  BugSplatAttachment,
+  BugSplatOptions,
+  BugSplatOptions as BugSplatPostOptions,
+  BugSplatOptions as BugSplatFeedbackOptions,
+} from 'bugsplat';
+
 /**
  * Options for initializing BugSplat.
  */
@@ -18,20 +25,6 @@ export interface BugSplatInitOptions {
   description?: string;
 }
 
-/**
- * Options for manually posting an error.
- */
-export interface BugSplatPostOptions {
-  /** Override default app key */
-  appKey?: string;
-  /** Override default user */
-  user?: string;
-  /** Override default email */
-  email?: string;
-  /** Description of the error context */
-  description?: string;
-}
-
 /**
  * Result from posting an error report.
  */
@@ -42,20 +35,6 @@ export interface BugSplatPostResult {
   error?: string;
 }
 
-/**
- * Options for submitting user feedback.
- */
-export interface BugSplatFeedbackOptions {
-  /** Override default app key */
-  appKey?: string;
-  /** Override default user name */
-  user?: string;
-  /** Override default user email */
-  email?: string;
-  /** Longer description of the feedback (title is the short summary) */
-  description?: string;
-}
-
 /**
  * Result from submitting user feedback.
  */

src/BugsplatExpo.web.ts

@@ -59,12 +59,7 @@ export async function post(
   const err = error instanceof Error ? error : new Error(error);
 
   try {
-    const result = await bs.post(err, {
-      appKey: options?.appKey,
-      user: options?.user,
-      email: options?.email,
-      description: options?.description,
-    });
+    const result = await bs.post(err, options);
 
     if (result.error) {
       return { success: false, error: result.error.message };
@@ -90,12 +85,7 @@ export async function postFeedback(
 ): Promise<BugSplatFeedbackResult> {
   const bs = getInstance();
   try {
-    const result = await bs.postFeedback(title, {
-      appKey: options?.appKey,
-      user: options?.user,
-      email: options?.email,
-      description: options?.description,
-    });
+    const result = await bs.postFeedback(title, options);
     if (result.error) {
       return { success: false, error: result.error.message };
     }

src/__tests__/BugsplatExpo.expoGo.test.ts

@@ -114,20 +114,37 @@ describe('BugsplatExpo (Expo Go / JS fallback)', () => {
       const error = new Error('test error');
       const result = await post(error);
       expect(result).toEqual({ success: true });
-      expect(mockBugSplatInstance.post).toHaveBeenCalledWith(error, {
-        appKey: undefined,
-        user: undefined,
-        email: undefined,
-        description: undefined,
-      });
+      expect(mockBugSplatInstance.post).toHaveBeenCalledWith(error, undefined);
+    });
+
+    it('forwards attachments to JS client post', async () => {
+      await init('test-db', 'MyApp', '1.0.0');
+      const attachments = [
+        { filename: 'componentStack.txt', data: new Uint8Array([1, 2, 3]) },
+      ];
+      await post(new Error('x'), { attachments });
+      expect(mockBugSplatInstance.post).toHaveBeenCalledWith(
+        expect.any(Error),
+        expect.objectContaining({ attachments })
+      );
+    });
+
+    it('forwards attributes to JS client post', async () => {
+      await init('test-db', 'MyApp', '1.0.0');
+      const attributes = { route: 'home', channel: 'beta' };
+      await post(new Error('x'), { attributes });
+      expect(mockBugSplatInstance.post).toHaveBeenCalledWith(
+        expect.any(Error),
+        expect.objectContaining({ attributes })
+      );
     });
 
     it('posts string error by wrapping in Error', async () => {
       await init('test-db', 'MyApp', '1.0.0');
       await post('string error');
       expect(mockBugSplatInstance.post).toHaveBeenCalledWith(
         expect.objectContaining({ message: 'string error' }),
-        expect.any(Object)
+        undefined
       );
     });
 
@@ -219,12 +236,18 @@ describe('BugsplatExpo (Expo Go / JS fallback)', () => {
       expect(result).toEqual({ success: true, crashId: 99 });
       expect(mockBugSplatInstance.postFeedback).toHaveBeenCalledWith(
         'Login button broken',
-        {
-          appKey: undefined,
-          user: undefined,
-          email: undefined,
-          description: 'Nothing happens when I tap it',
-        }
+        { description: 'Nothing happens when I tap it' }
+      );
+    });
+
+    it('forwards attachments and attributes to JS client postFeedback', async () => {
+      await init('test-db', 'MyApp', '1.0.0');
+      const attachments = [{ filename: 'log.txt', data: new Uint8Array([1]) }];
+      const attributes = { route: 'settings' };
+      await postFeedback('subject', { attachments, attributes });
+      expect(mockBugSplatInstance.postFeedback).toHaveBeenCalledWith(
+        'subject',
+        expect.objectContaining({ attachments, attributes })
       );
     });
 

src/__tests__/BugsplatExpo.test.ts

@@ -193,12 +193,7 @@ describe('BugsplatExpo (native)', () => {
       expect(result).toEqual({ success: true, crashId: 42 });
       expect(mockBugSplatInstance.postFeedback).toHaveBeenCalledWith(
         'Login button broken',
-        {
-          appKey: undefined,
-          user: undefined,
-          email: undefined,
-          description: 'Nothing happens when I tap it',
-        }
+        { description: 'Nothing happens when I tap it' }
       );
     });
 

src/__tests__/BugsplatExpo.web.test.ts

@@ -70,21 +70,49 @@ describe('BugsplatExpo (web)', () => {
       const error = new Error('test error');
       const result = await post(error);
       expect(result).toEqual({ success: true });
-      expect(mockPost).toHaveBeenCalledWith(error, {
-        appKey: undefined,
-        user: undefined,
-        email: undefined,
-        description: undefined,
+      expect(mockPost).toHaveBeenCalledWith(error, undefined);
+    });
+
+    it('forwards attachments to bs.post', async () => {
+      const attachments = [
+        {
+          filename: 'componentStack.txt',
+          data: new Uint8Array([1, 2, 3]),
+        },
+      ];
+      await post(new Error('x'), { attachments });
+      expect(mockPost).toHaveBeenCalledWith(
+        expect.any(Error),
+        expect.objectContaining({ attachments })
+      );
+    });
+
+    it('forwards attributes to bs.post', async () => {
+      const attributes = { route: 'tasks/123', feature: 'beta' };
+      await post(new Error('x'), { attributes });
+      expect(mockPost).toHaveBeenCalledWith(
+        expect.any(Error),
+        expect.objectContaining({ attributes })
+      );
+    });
+
+    it('forwards existing fields (description, user, email, appKey)', async () => {
+      await post(new Error('x'), {
+        appKey: 'k',
+        user: 'u',
+        email: 'e',
+        description: 'd',
       });
+      expect(mockPost).toHaveBeenCalledWith(
+        expect.any(Error),
+        { appKey: 'k', user: 'u', email: 'e', description: 'd' }
+      );
     });
 
     it('posts a string error by wrapping it in Error', async () => {
       const result = await post('string error');
       expect(result).toEqual({ success: true });
-      expect(mockPost).toHaveBeenCalledWith(
-        expect.any(Error),
-        expect.any(Object)
-      );
+      expect(mockPost).toHaveBeenCalledWith(expect.any(Error), undefined);
     });
 
     it('returns failure when post throws', async () => {
@@ -155,13 +183,22 @@ describe('BugsplatExpo (web)', () => {
       });
       expect(result).toEqual({ success: true, crashId: 7 });
       expect(mockPostFeedback).toHaveBeenCalledWith('Login button broken', {
-        appKey: undefined,
-        user: undefined,
-        email: undefined,
         description: 'Nothing happens when I tap it',
       });
     });
 
+    it('forwards attachments and attributes to bs.postFeedback', async () => {
+      const attachments = [
+        { filename: 'log.txt', data: new Uint8Array([1]) },
+      ];
+      const attributes = { route: 'settings' };
+      await postFeedback('subject', { attachments, attributes });
+      expect(mockPostFeedback).toHaveBeenCalledWith(
+        'subject',
+        expect.objectContaining({ attachments, attributes })
+      );
+    });
+
     it('returns failure when postFeedback throws', async () => {
       mockPostFeedback.mockRejectedValueOnce(new Error('network error'));
       const result = await postFeedback('subject');

src/index.ts

@@ -1,4 +1,6 @@
 export type {
+  BugSplatAttachment,
+  BugSplatOptions,
   BugSplatInitOptions,
   BugSplatPostOptions,
   BugSplatPostResult,