diff --git a/docs/design/2026-09-15-sdk-design.md b/docs/design/2026-09-15-sdk-design.md
index 4cab0e69..4a0ec7d7 100644
--- a/docs/design/2026-09-15-sdk-design.md
+++ b/docs/design/2026-09-15-sdk-design.md
@@ -285,18 +285,22 @@ What changes is the payload gaining a `debug_ids` member alongside name, message
 
 | | Android 7.x | iOS 7.x |
 |---|---|---|
-| handled | `logException(Throwable, Map)` | `logException:reason:options:completion:` |
+| handled | `logException(Throwable, String domain, int skipFrames)` | `logException:reason:domain:skipFrames:completion:` |
 | unhandled | `logUnhandledException(Throwable, Map)` | `logUnhandledException:reason:completion:` |
 
 `logUnhandledException` is new on Android and is a better fit than `onUncaughtException(Thread, Throwable)`, which exists to be called from a real `UncaughtExceptionHandler`.
 
-**Both exception-logging methods are two ObjC overloads each on iOS, and the RN bridge calls the `NSString`-pair one.** Verified against `Bugsee.h:367,374,380-381` (`packages/react-native/Bugsee.xcframework/ios-arm64/Bugsee.framework/Headers/`):
+**The exception-logging methods come as `NSString`-pair and `NSException` overloads on iOS, and the RN bridge calls the `NSString`-pair ones.** Verified against `Bugsee.h` of 7.0.0-beta7 (bugsee-cocoa#233; 7.0.0-beta6 and earlier took a `BugseeExceptionLoggingOptions` object instead of `domain:skipFrames:`):
 
 ```objc
-+ (void)logException:(nonnull NSString *)name reason:(nonnull NSString *)reason options:(BugseeExceptionLoggingOptions *_Nullable)loggingOptions completion:(nullable BugseeEmptyBlock)completionBlock
-    NS_SWIFT_NAME(logException(name:reason:options:completion:));
-+ (void)logException:(nonnull NSException *)exception options:(BugseeExceptionLoggingOptions *_Nullable)loggingOptions completion:(nullable BugseeEmptyBlock)completionBlock
-    NS_SWIFT_NAME(logException(exception:options:completion:));
++ (void)logException:(nonnull NSException *)exception completion:(nullable BugseeEmptyBlock)completionBlock
+    NS_SWIFT_NAME(logException(exception:completion:));
++ (void)logException:(nonnull NSException *)exception domain:(nullable NSString *)domain skipFrames:(NSInteger)skipFrames completion:(nullable BugseeEmptyBlock)completionBlock
+    NS_SWIFT_NAME(logException(exception:domain:skipFrames:completion:));
++ (void)logException:(nonnull NSString *)name reason:(nonnull NSString *)reason completion:(nullable BugseeEmptyBlock)completionBlock
+    NS_SWIFT_NAME(logException(name:reason:completion:));
++ (void)logException:(nonnull NSString *)name reason:(nonnull NSString *)reason domain:(nullable NSString *)domain skipFrames:(NSInteger)skipFrames completion:(nullable BugseeEmptyBlock)completionBlock
+    NS_SWIFT_NAME(logException(name:reason:domain:skipFrames:completion:));
 
 + (void)logUnhandledException:(nonnull NSException *)exception completion:(nullable BugseeEmptyBlock)completionBlock
     NS_SWIFT_NAME(logUnhandledException(exception:completion:));
@@ -306,12 +310,12 @@ What changes is the payload gaining a `debug_ids` member alongside name, message
 
 The table's selectors are both the `NSString`-pair overload, which is the one the RN bridge has a name and a reason to hand it (a JS `Error`'s `name` and `message`), not a real `NSException`:
 
-- **handled** — `logException:reason:options:completion:`. Its **first** argument *is* the exception name (Swift label `name:`), the second is the reason; there is no `name:` selector segment because the first argument belongs to `logException:` itself. The `NSException`-overload's selector, `logException:options:completion:`, is the one this wrapper does not call.
+- **handled** — `logException:reason:domain:skipFrames:completion:`. Its **first** argument *is* the exception name (Swift label `name:`), the second is the reason; there is no `name:` selector segment because the first argument belongs to `logException:` itself. The `NSException` overloads (`logException:completion:`, `logException:domain:skipFrames:completion:`) are the ones this wrapper does not call.
 - **unhandled** — `logUnhandledException:reason:completion:`. Same shape: the first argument *is* the exception name (Swift label `name:` again), with no `name:` selector segment for the same reason. An `NSException`-taking overload also exists (`logUnhandledException:completion:`, Swift `logUnhandledException(exception:completion:)`), which this wrapper does not call either, since it never has a real `NSException` to hand it — only a JS error's name and message strings.
 
 (An earlier draft of this document mis-stated the unhandled selector as `logUnhandledException:name:reason:completion:` — that selector does not exist, because `name:` is a Swift argument label, not an ObjC selector segment.)
 
-The `ExceptionOptions` contract interface declares only `Domain` and `SkipFrames`, but the `logException` javadoc documents `"domain"`, `"labels"` and `"includeVideo"`. The parameter is `Map<String, Object>`, so the extra keys are accepted; the wrapper passes all three.
+JS `ExceptionOptions` is `{domain?}`. Both bridges pass the domain and `skipFrames` 0: Android to `logException(Throwable, String, int)` (bugsee-android#256 deprecated `logException(Throwable, Map)`, whose `labels` and `includeVideo` were never applied), iOS to `logException:reason:domain:skipFrames:completion:` (bugsee-cocoa#233). Neither takes labels: a report is labelled in `setReportHandler`. `skipFrames` is always 0: it leaves top native frames out of the report's signature, and an RN report is keyed on the JS signature in the payload. Neither SDK can leave the video out of one report, so there is no `includeVideo`.
 
 ### 9.2 Source maps
 
@@ -349,7 +353,7 @@ Carried over: `launch` / `relaunch` / `stop`, `log`, `trace`, `event`, `showRepo
 
 New: `setUserIdentifier` / `getUserIdentifier` / `clearUserIdentifier`, `startBlackout` / `endBlackout` / `isBlackout`, `addBreadcrumb` + `setBreadcrumbFilter`, `notify`, `addNetworkEvent`, `logUnhandledException`, `getAllAttributes`, `createReport` + `setReportHandler`, `getStatus` + `onStatusChange`, `startTransaction` / `startSpan` / `getActiveSpan`.
 
-Removed: `setEmail` / `getEmail` / `clearEmail`, `pause` / `resume`, `setKeyboardVisibility` (no replacement on either platform), `upload(…, includeVideo)`, `getDeviceId`.
+Removed: `setEmail` / `getEmail` / `clearEmail`, `pause` / `resume`, `setKeyboardVisibility` (no replacement on either platform), `upload(…, includeVideo)`, `logException`'s `labels` and `includeVideo` options (label a report in `setReportHandler`), `getDeviceId`.
 
 Two ergonomic changes: `toggleProtected(ref, bool)` becomes a `<BugseeSecure>` component that disposes on unmount, and `initialize()` becomes `attach()` for the case where Android launched itself from manifest metadata and only the JS layer needs wiring.
 
diff --git a/examples/bare/e2e/api-arguments.test.ts b/examples/bare/e2e/api-arguments.test.ts
index 7e55eaf2..3248c40c 100644
--- a/examples/bare/e2e/api-arguments.test.ts
+++ b/examples/bare/e2e/api-arguments.test.ts
@@ -151,7 +151,7 @@ describeDevice(`overloads and arguments on ${TARGET_NAME}`, () => {
       if (ON_SIMULATOR) {
         return;
       }
-      const result = await runFor(log!, 'api-exc-values', 'exc-values done', 5);
+      const result = await runFor(log!, 'api-exc-values', 'exc-values done', 3);
       run = result.run;
       done = result.line;
       errors = result.bundles.filter(b => b.request.type === 'error');
@@ -170,21 +170,22 @@ describeDevice(`overloads and arguments on ${TARGET_NAME}`, () => {
       report('payload reasons', reasons);
       expect(reasons.filter(r => r === `api-exc string ${nonce}`)).toHaveLength(1);
       expect(reasons.filter(r => r === 'Non-Error thrown: object')).toHaveLength(2);
-      // The three values plus the two includeVideo errors.
-      expect(errors).toHaveLength(5);
+      // The three values; the includeVideo calls file nothing ([API-11d]).
+      expect(errors).toHaveLength(3);
     });
 
-    // iOS ignores includeVideo too: https://github.com/bugsee/bugsee-cocoa/issues/226
-    itReports('[API-11d] includeVideo is accepted and changes nothing', () => {
+    // includeVideo is not an option: neither 7.x SDK can leave the video out of one
+    // report (https://github.com/bugsee/bugsee-cocoa/issues/226, bugsee-android#247).
+    itReports('[API-11d] includeVideo is refused and files nothing', () => {
       const nonce = run.scenario.nonce;
       const video = jsonAfter<Record<string, Settled>>(done.text, 'video');
-      expect(video.on!.ok && video.off!.ok).toBe(true);
-      const on = errors.find(b => payloadReason(b) === `api-exc video-on ${nonce}`);
-      const off = errors.find(b => payloadReason(b) === `api-exc video-off ${nonce}`);
-      expect(on).toBeDefined();
-      expect(off).toBeDefined();
-      report('includeVideo files', { on: types(on!), off: types(off!) });
-      expect(types(on!)).toEqual(types(off!));
+      report('includeVideo settled', video);
+      for (const call of [video.on!, video.off!]) {
+        expect(call.ok).toBe(false);
+        expect(call.error?.name).toBe('TypeError');
+      }
+      const reasons = [`api-exc video-on ${nonce}`, `api-exc video-off ${nonce}`];
+      expect(errors.filter(b => reasons.includes(payloadReason(b)))).toHaveLength(0);
     });
   });
 
@@ -201,7 +202,7 @@ describeDevice(`overloads and arguments on ${TARGET_NAME}`, () => {
       report('fallback', fallback.text.trim());
       if (!ON_SIMULATOR) {
         bundles = (await awaitBundles(1, 45_000)).filter(b => b.request.type === 'error');
-        report('boundary errors', bundles.map(b => ({ reason: reasonOf(b).slice(0, 160), labels: b.request.labels, crash: crashOf(b) === undefined ? '-' : 'yes' })));
+        report('boundary errors', bundles.map(b => ({ reason: reasonOf(b).slice(0, 160), crash: crashOf(b) === undefined ? '-' : 'yes' })));
       }
       await stopApp();
     });
@@ -226,13 +227,6 @@ describeDevice(`overloads and arguments on ${TARGET_NAME}`, () => {
         expect((crash.exceptionLoggingOptions as { exceptionDomain?: unknown }).exceptionDomain).toBe(`api-domain-${run.scenario.nonce}`);
       }
     });
-
-    /** Android 7.3.0 ignores logException labels (R10, exceptions.test.ts case 7): the same path.
-     * https://github.com/bugsee/bugsee-android/issues/247 */
-    (ON_ANDROID ? it.failing : itReports)('[API-13d] the options prop: labels reach the report', () => {
-      expect(bundles).toHaveLength(1);
-      expect(bundles[0]!.request.labels).toEqual(expect.arrayContaining([`api-label-${run.scenario.nonce}`]));
-    });
   });
 
   it('[API-15b-d] notify() carries severity, fields and urgent into the relay record; a sixth argument throws', async () => {
diff --git a/examples/bare/e2e/exceptions.test.ts b/examples/bare/e2e/exceptions.test.ts
index e255e12f..e597a2b5 100644
--- a/examples/bare/e2e/exceptions.test.ts
+++ b/examples/bare/e2e/exceptions.test.ts
@@ -28,11 +28,12 @@
  *   BUGSEE_E2E exc boundary-onError / boundary-fallback
  *   BUGSEE_E2E exc app-handler fatal=<bool>
  *
- * Case 7 is `it.failing` on Android for a documented gap (labels ignored,
- * still in 7.3.1; https://github.com/bugsee/bugsee-android/issues/247). Do not weaken it. Case 10 was `it.failing` on 7.3.0, which
+ * Case 7 (labels on a handled exception) is gone: neither SDK's logException
+ * takes labels any more (bugsee-android#256, bugsee-cocoa#233); a report is
+ * labelled in setReportHandler. Case 10 was `it.failing` on 7.3.0, which
  * also filed an error report for an unhandled exception; 7.3.1 files the
  * crash only (bugsee-android d390b5203, #192), so it is a plain `it`.
- * On iOS both are plain `it` (labels apply; Debug files no second report).
+ * On iOS it is a plain `it` (Debug files no second report).
  *
  * Case 12's red-box line must stay on Android. Gated release R2/R3 (controller
  * ruling): R13's second Bugsee crash was not retained on SDK 7.3.0; logcat
@@ -400,13 +401,6 @@ describeDevice(`JS exceptions on ${TARGET_NAME}`, () => {
         handledPayload.signature,
       );
     });
-
-    // Known SDK bug (R10): https://github.com/bugsee/bugsee-android/issues/247
-    itAndroid.failing('labels reach the report', () => {
-      const labels = handled.request.labels;
-      report('case 7 actual labels', labels);
-      expect(labels).toEqual(expect.arrayContaining([`lbl-${nonce}`]));
-    });
   });
 
   describeDebug('exc-rejection', () => {
@@ -959,7 +953,7 @@ describeDevice(`JS exceptions on ${TARGET_NAME}`, () => {
         | undefined;
       expect(opts).toBeDefined();
       expect(opts!.exceptionDomain).toBe(`e2e-${nonce}`);
-      expect(opts!.includeVideo).toBe(true);
+      expect(opts).not.toHaveProperty('includeVideo');
     });
 
     itIosDevice('the client signature carries the JS signature', () => {
@@ -968,11 +962,6 @@ describeDevice(`JS exceptions on ${TARGET_NAME}`, () => {
       );
     });
 
-    itIosDevice('labels reach the report', () => {
-      const labels = handled.request.labels;
-      report('case 7 iOS labels', labels);
-      expect(labels).toEqual(expect.arrayContaining([`lbl-${nonce}`]));
-    });
   });
 
   describeIosDeviceDebug('exc-rejection (iPhone)', () => {
diff --git a/examples/bare/scenarios/api-args.ts b/examples/bare/scenarios/api-args.ts
index f7d123dd..47baca83 100644
--- a/examples/bare/scenarios/api-args.ts
+++ b/examples/bare/scenarios/api-args.ts
@@ -6,8 +6,8 @@
  *   api-token        before launch(): launch('') / '   ' / 42 must reject
  *                    without starting anything; then the app launches.
  *   api-subs         remove() on onLifecycleEvent and onStatusChange.
- *   api-exc-values   logException(string | plain object | null) and
- *                    {includeVideo: true | false}.
+ *   api-exc-values   logException(string | plain object | null), and
+ *                    {includeVideo: true | false}, which must be refused.
  *   api-notify       notify() with severity, fields and urgent, and bare.
  *   api-spans        every SpanStatus through finish(status), startChildSpan,
  *                    setStatus then finish(), a dead handle, startSpan with no
@@ -137,9 +137,10 @@ async function exceptionValues(nonce: string): Promise<void> {
     null: await settled(() => Bugsee.logException(null)),
   };
   await delay(1_500);
+  // Not an option any more: each call throws TypeError and files nothing.
   const video = {
-    on: await settled(() => Bugsee.logException(new Error(`api-exc video-on ${nonce}`), { includeVideo: true })),
-    off: await settled(() => Bugsee.logException(new Error(`api-exc video-off ${nonce}`), { includeVideo: false })),
+    on: await settled(() => Bugsee.logException(new Error(`api-exc video-on ${nonce}`), { includeVideo: true } as never)),
+    off: await settled(() => Bugsee.logException(new Error(`api-exc video-off ${nonce}`), { includeVideo: false } as never)),
   };
   mark(`exc-values done nonce=${nonce} results=${JSON.stringify(results)} video=${JSON.stringify(video)}`);
 }
diff --git a/examples/bare/scenarios/api.tsx b/examples/bare/scenarios/api.tsx
index fcdccf5f..2cef7a8b 100644
--- a/examples/bare/scenarios/api.tsx
+++ b/examples/bare/scenarios/api.tsx
@@ -185,13 +185,13 @@ function Thrower({ nonce }: { nonce: string }): never {
 
 /**
  * N-08: an ErrorBoundary whose fallback is a function and whose `options`
- * carry a domain and labels, around a child that throws on render.
+ * carry a domain, around a child that throws on render.
  */
 function BoundaryStage({ nonce }: { nonce: string }) {
   return (
     <View style={[StyleSheet.absoluteFill, styles.white]}>
       <ErrorBoundary
-        options={{ domain: `api-domain-${nonce}`, labels: [`api-label-${nonce}`] }}
+        options={{ domain: `api-domain-${nonce}` }}
         onError={() => mark(`boundary onError nonce=${nonce}`)}
         fallback={({ error, componentStack }) => {
           mark(
diff --git a/examples/bare/scenarios/exceptions.tsx b/examples/bare/scenarios/exceptions.tsx
index becacf8e..7db0c77d 100644
--- a/examples/bare/scenarios/exceptions.tsx
+++ b/examples/bare/scenarios/exceptions.tsx
@@ -174,8 +174,6 @@ export function runExceptionScenario(
     } catch (e) {
       Bugsee.logException(e, {
         domain: `e2e-${nonce}`,
-        labels: ['e2e', `lbl-${nonce}`],
-        includeVideo: true,
       });
     }
     Bugsee.logException({ password: `pw-${nonce}`, message: `obj-${nonce}` });
diff --git a/examples/bare/scenarios/staging.ts b/examples/bare/scenarios/staging.ts
index eaba0705..728e32a5 100644
--- a/examples/bare/scenarios/staging.ts
+++ b/examples/bare/scenarios/staging.ts
@@ -142,7 +142,7 @@ export async function runStagingScenario(scenario: StagingScenario, nonce: strin
       try {
         stagingThrowSite(nonce, 'js handled');
       } catch (error) {
-        Bugsee.logException(error, { labels: ['campaign', `nonce-${nonce}`] });
+        Bugsee.logException(error);
       }
       mark(`handled-sent text="${campaignText(nonce, 'js handled')}" nonce=${nonce}`);
       return;
diff --git a/examples/playground/README.md b/examples/playground/README.md
index 33cf5315..bd35d8c3 100644
--- a/examples/playground/README.md
+++ b/examples/playground/README.md
@@ -200,8 +200,6 @@ The app shows a note next to each affected button.
 | Platform | Issue |
 |---|---|
 | iOS | [A second `createReport` wipes the first](https://github.com/bugsee/bugsee-cocoa/issues/224) |
-| iOS | [`logException` `includeVideo` ignored](https://github.com/bugsee/bugsee-cocoa/issues/226) |
-| Android | [`logException` labels and `includeVideo` ignored](https://github.com/bugsee/bugsee-android/issues/247) |
 | iOS | [`upload()` source type shows as unknown](https://github.com/bugsee/bugsee-cocoa/issues/223) |
 
 For manual test sessions, see [VALIDATION.md](./VALIDATION.md).
diff --git a/examples/playground/__tests__/errors.test.tsx b/examples/playground/__tests__/errors.test.tsx
index 748cada3..2f8e85e1 100644
--- a/examples/playground/__tests__/errors.test.tsx
+++ b/examples/playground/__tests__/errors.test.tsx
@@ -9,7 +9,7 @@ test('actions have valid call targets and unique ids', () => {
   errorsActions.forEach((a) => expect(() => callTarget(a.call)).not.toThrow());
   expect(new Set(errorsActions.map((a) => a.id)).size).toBe(errorsActions.length);
 });
-test('renders labels and the boundary demo', async () => {
+test('renders the actions and the boundary demo', async () => {
   await render(<ErrorsScreen />);
   expect(screen.getByText('Log handled string')).toBeTruthy();
   expect(screen.getByText('Throw inside ErrorBoundary')).toBeTruthy();
diff --git a/examples/playground/__tests__/shop.flow.test.ts b/examples/playground/__tests__/shop.flow.test.ts
index 6c1953fc..33b400f2 100644
--- a/examples/playground/__tests__/shop.flow.test.ts
+++ b/examples/playground/__tests__/shop.flow.test.ts
@@ -48,13 +48,10 @@ test('filter returns events without a body unchanged', () => {
   expect(SHOP_NETWORK_FILTER(n)).toBe(n);
 });
 
-test('pay(declined) logs a handled exception with labels and domain', async () => {
+test('pay(declined) logs a handled exception with a domain', async () => {
   startCheckoutFlow();
   expect(await pay('declined', { total: 5 })).toBe('declined');
-  expect(bugsee.logException).toHaveBeenCalledWith(expect.any(Error), {
-    labels: ['checkout', 'payment'],
-    domain: 'payment',
-  });
+  expect(bugsee.logException).toHaveBeenCalledWith(expect.any(Error), { domain: 'payment' });
   expect(global.fetch).toHaveBeenCalledWith(expect.stringContaining('/status/402'));
 });
 
diff --git a/examples/playground/__tests__/shop.screens.test.tsx b/examples/playground/__tests__/shop.screens.test.tsx
index ba0798b0..43855829 100644
--- a/examples/playground/__tests__/shop.screens.test.tsx
+++ b/examples/playground/__tests__/shop.screens.test.tsx
@@ -74,10 +74,7 @@ test('checkout declined logs the handled exception', async () => {
   await render(<Checkout />);
   await fireEvent.press(screen.getByText('Declined'));
   await fireEvent.press(screen.getByText('Pay'));
-  await waitFor(() => expect(bugsee.logException).toHaveBeenCalledWith(expect.any(Error), {
-    labels: ['checkout', 'payment'],
-    domain: 'payment',
-  }));
+  await waitFor(() => expect(bugsee.logException).toHaveBeenCalledWith(expect.any(Error), { domain: 'payment' }));
   expect(alert).toHaveBeenCalledWith('Checkout', 'Payment declined');
 });
 
diff --git a/examples/playground/src/screens/ErrorsScreen.tsx b/examples/playground/src/screens/ErrorsScreen.tsx
index 264ac28c..2f3cc1ef 100644
--- a/examples/playground/src/screens/ErrorsScreen.tsx
+++ b/examples/playground/src/screens/ErrorsScreen.tsx
@@ -5,7 +5,6 @@ import { NATIVE_UNAVAILABLE, PlaygroundNative } from '../../modules/playground-n
 import { ActionButton } from '../ui/ActionButton';
 import type { Action } from '../ui/action';
 import { afterTap } from '../ui/afterTap';
-import { KnownIssue } from '../ui/KnownIssue';
 import { Screen } from '../ui/Screen';
 import { Section } from '../ui/Section';
 
@@ -56,14 +55,6 @@ export const errorsActions: Action[] = [
     expect: 'A handled error report whose message is the string',
     run: () => Bugsee.logException('a plain string'),
   },
-  {
-    id: 'handled-labels',
-    label: 'Log handled error with labels',
-    call: "Bugsee.logException(new Error('labelled'), { labels: ['playground', 'handled'] })",
-    knownIssue: 'android-247',
-    expect: 'Labels playground, handled on the error',
-    run: () => Bugsee.logException(new Error('labelled'), { labels: ['playground', 'handled'] }),
-  },
   {
     id: 'handled-domain',
     label: 'Log handled error with domain',
@@ -71,24 +62,6 @@ export const errorsActions: Action[] = [
     expect: 'Domain com.bugsee.playground on the error',
     run: () => Bugsee.logException(new Error('domain'), { domain: 'com.bugsee.playground' }),
   },
-  {
-    id: 'handled-video-ios',
-    label: 'Log handled error with video',
-    call: "Bugsee.logException(new Error('video'), { includeVideo: true })",
-    platforms: ['ios'],
-    knownIssue: 'cocoa-226',
-    expect: 'A handled error report that includes video',
-    run: () => Bugsee.logException(new Error('video'), { includeVideo: true }),
-  },
-  {
-    id: 'handled-video-android',
-    label: 'Log handled error with video',
-    call: "Bugsee.logException(new Error('video'), { includeVideo: true })",
-    platforms: ['android'],
-    knownIssue: 'android-247',
-    expect: 'A handled error report that includes video',
-    run: () => Bugsee.logException(new Error('video'), { includeVideo: true }),
-  },
 
   {
     id: 'unhandled-api',
@@ -152,9 +125,9 @@ function BoundaryDemo() {
   const [armed, setArmed] = useState(false);
   return (
     <>
-      <Text>Expect: The fallback renders; a handled error with label boundary is reported</Text>
+      <Text>Expect: The fallback renders; a handled error with domain boundary is reported</Text>
       <ErrorBoundary
-        options={{ labels: ['boundary'] }}
+        options={{ domain: 'boundary' }}
         fallback={({ error, resetError }) => (
           <>
             <Text>Fallback: {error instanceof Error ? error.message : String(error)}</Text>
@@ -171,7 +144,6 @@ function BoundaryDemo() {
         <Bomb armed={armed} />
       </ErrorBoundary>
       <Button title="Throw inside ErrorBoundary" onPress={() => setArmed(true)} />
-      <KnownIssue id="android-247" />
     </>
   );
 }
diff --git a/examples/playground/src/screens/shop/Products.tsx b/examples/playground/src/screens/shop/Products.tsx
index 0343c4e5..fc26201f 100644
--- a/examples/playground/src/screens/shop/Products.tsx
+++ b/examples/playground/src/screens/shop/Products.tsx
@@ -34,7 +34,7 @@ export default function Products() {
       status = SpanStatus.Error;
       if (e instanceof DemoHttpError) {
         setError(`Could not load products (HTTP ${e.status})`);
-        Bugsee.logException(e, { labels: ['shop', 'products'] });
+        Bugsee.logException(e, { domain: 'products' });
       } else {
         setError(`Could not load products: ${e instanceof Error ? e.message : String(e)}`);
       }
diff --git a/examples/playground/src/shop/flow.ts b/examples/playground/src/shop/flow.ts
index c7e58e2f..99a99af1 100644
--- a/examples/playground/src/shop/flow.ts
+++ b/examples/playground/src/shop/flow.ts
@@ -82,10 +82,7 @@ export async function pay(
   try {
     if (outcome === 'declined') {
       await fetch(DEMO.STATUS(402));
-      Bugsee.logException(new Error('Payment declined'), {
-        labels: ['checkout', 'payment'],
-        domain: 'payment',
-      });
+      Bugsee.logException(new Error('Payment declined'), { domain: 'payment' });
       step?.finish(SpanStatus.Error);
       finishFlow(SpanStatus.Error);
       resetCart();
diff --git a/examples/playground/src/ui/knownIssues.ts b/examples/playground/src/ui/knownIssues.ts
index b7b298d6..e74331cc 100644
--- a/examples/playground/src/ui/knownIssues.ts
+++ b/examples/playground/src/ui/knownIssues.ts
@@ -4,16 +4,6 @@ export const KNOWN_ISSUES = {
     title: 'A second createReport wipes the first',
     platform: 'ios',
   },
-  'cocoa-226': {
-    url: 'https://github.com/bugsee/bugsee-cocoa/issues/226',
-    title: 'logException includeVideo ignored',
-    platform: 'ios',
-  },
-  'android-247': {
-    url: 'https://github.com/bugsee/bugsee-android/issues/247',
-    title: 'logException labels and includeVideo ignored',
-    platform: 'android',
-  },
   'cocoa-223': {
     url: 'https://github.com/bugsee/bugsee-cocoa/issues/223',
     title: 'upload() source type shows as unknown',
diff --git a/packages/react-native/android/src/main/java/com/bugsee/reactnative/BugseeModule.java b/packages/react-native/android/src/main/java/com/bugsee/reactnative/BugseeModule.java
index 4f523466..16e76deb 100644
--- a/packages/react-native/android/src/main/java/com/bugsee/reactnative/BugseeModule.java
+++ b/packages/react-native/android/src/main/java/com/bugsee/reactnative/BugseeModule.java
@@ -73,8 +73,8 @@ public class BugseeModule extends NativeBugseeSpec
     /** Production adapter: the SDK's handled / unhandled entry points. */
     private static final ExceptionBridge.Sdk PROD_EXCEPTION_SDK = new ExceptionBridge.Sdk() {
         @Override
-        public void logException(final Throwable t, @Nullable final Map<String, Object> options) {
-            Bugsee.logException(t, options);
+        public void logException(final Throwable t, @Nullable final String domain, final int skipFrames) {
+            Bugsee.logException(t, domain, skipFrames);
         }
 
         @Override
diff --git a/packages/react-native/android/src/main/java/com/bugsee/reactnative/ExceptionBridge.java b/packages/react-native/android/src/main/java/com/bugsee/reactnative/ExceptionBridge.java
index 5447cef8..2059ebe1 100644
--- a/packages/react-native/android/src/main/java/com/bugsee/reactnative/ExceptionBridge.java
+++ b/packages/react-native/android/src/main/java/com/bugsee/reactnative/ExceptionBridge.java
@@ -5,9 +5,6 @@
 
 import android.util.Log;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 /**
@@ -26,47 +23,45 @@ final class ExceptionBridge {
 
     /** What the module implements against; the production adapter calls {@code Bugsee.*}. */
     interface Sdk {
-        void logException(Throwable t, @Nullable Map<String, Object> options);
+        void logException(Throwable t, @Nullable String domain, int skipFrames);
 
         void logUnhandledException(Throwable t, @Nullable Map<String, Object> options);
     }
 
+    /** The JS options, parsed. */
+    static final class Options {
+        @Nullable final String domain;
+
+        Options(@Nullable final String domain) {
+            this.domain = domain;
+        }
+    }
+
     private ExceptionBridge() {
     }
 
     /**
-     * {@code domain} → {@link String}, {@code labels} → {@link List}{@code String},
-     * {@code includeVideo} → {@link Boolean}; other keys dropped. {@code null}
-     * for null text.
+     * {@code domain} → {@link String}; other keys, {@code labels} and
+     * {@code includeVideo} among them, dropped. {@code null} for null text.
      *
      * @throws BridgeJson.BadJson when the text is unparseable, or a known key
      *     has the wrong runtime type.
      */
     @Nullable
-    static Map<String, Object> options(@Nullable final String optionsJson) throws BridgeJson.BadJson {
+    static Options options(@Nullable final String optionsJson) throws BridgeJson.BadJson {
         if (optionsJson == null) {
             return null;
         }
         final Map<String, Object> raw = BridgeJson.parseObject(optionsJson);
-        final Map<String, Object> result = new HashMap<>();
+        String domain = null;
         if (raw.containsKey("domain")) {
-            final Object domain = raw.get("domain");
-            if (!(domain instanceof String)) {
+            final Object value = raw.get("domain");
+            if (!(value instanceof String)) {
                 throw new BridgeJson.BadJson("domain must be a string");
             }
-            result.put("domain", domain);
-        }
-        if (raw.containsKey("labels")) {
-            result.put("labels", stringList(raw.get("labels")));
-        }
-        if (raw.containsKey("includeVideo")) {
-            final Object includeVideo = raw.get("includeVideo");
-            if (!(includeVideo instanceof Boolean)) {
-                throw new BridgeJson.BadJson("includeVideo must be a boolean");
-            }
-            result.put("includeVideo", includeVideo);
+            domain = (String) value;
         }
-        return result;
+        return new Options(domain);
     }
 
     /**
@@ -78,14 +73,19 @@ static void logHandled(
             @NonNull final String payloadJson,
             @Nullable final String optionsJson
     ) {
-        Map<String, Object> opts = null;
+        Options opts = null;
         try {
             opts = options(optionsJson);
         } catch (final BridgeJson.BadJson e) {
             Log.e(TAG, "exception options rejected: " + e.getMessage());
         }
         try {
-            sdk.logException(new ReactNativeWebException(payloadJson), opts);
+            // skipFrames 0: it leaves top Java frames out of the report's signature,
+            // and an RN report is keyed on the JS signature in the payload.
+            sdk.logException(
+                    new ReactNativeWebException(payloadJson),
+                    opts == null ? null : opts.domain,
+                    0);
         } catch (final RuntimeException e) {
             Log.e(TAG, "logException failed: " + e.getClass().getName());
         }
@@ -99,20 +99,4 @@ static void logUnhandled(@NonNull final Sdk sdk, @NonNull final String payloadJs
             Log.e(TAG, "logUnhandledException failed: " + e.getClass().getName());
         }
     }
-
-    @NonNull
-    private static List<String> stringList(@Nullable final Object value) throws BridgeJson.BadJson {
-        if (!(value instanceof List)) {
-            throw new BridgeJson.BadJson("labels must be an array of strings");
-        }
-        final List<?> raw = (List<?>) value;
-        final List<String> result = new ArrayList<>(raw.size());
-        for (final Object element : raw) {
-            if (!(element instanceof String)) {
-                throw new BridgeJson.BadJson("labels must be an array of strings");
-            }
-            result.add((String) element);
-        }
-        return result;
-    }
 }
diff --git a/packages/react-native/android/src/test/java/com/bugsee/reactnative/ExceptionBridgeTest.java b/packages/react-native/android/src/test/java/com/bugsee/reactnative/ExceptionBridgeTest.java
index 1516a3cf..e714a5b0 100644
--- a/packages/react-native/android/src/test/java/com/bugsee/reactnative/ExceptionBridgeTest.java
+++ b/packages/react-native/android/src/test/java/com/bugsee/reactnative/ExceptionBridgeTest.java
@@ -11,8 +11,6 @@
 import org.junit.Test;
 
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -29,18 +27,28 @@ private static final class RecordingSdk implements ExceptionBridge.Sdk {
         static final class Call {
             final String kind;
             final Throwable throwable;
+            @Nullable final String domain;
+            final int skipFrames;
             @Nullable final Map<String, Object> options;
 
-            Call(final String kind, final Throwable throwable, @Nullable final Map<String, Object> options) {
+            Call(
+                    final String kind,
+                    final Throwable throwable,
+                    @Nullable final String domain,
+                    final int skipFrames,
+                    @Nullable final Map<String, Object> options
+            ) {
                 this.kind = kind;
                 this.throwable = throwable;
+                this.domain = domain;
+                this.skipFrames = skipFrames;
                 this.options = options;
             }
         }
 
         @Override
-        public void logException(final Throwable t, @Nullable final Map<String, Object> options) {
-            calls.add(new Call("handled", t, options));
+        public void logException(final Throwable t, @Nullable final String domain, final int skipFrames) {
+            calls.add(new Call("handled", t, domain, skipFrames, null));
             if (throwOnNext != null) {
                 final RuntimeException e = throwOnNext;
                 throwOnNext = null;
@@ -50,7 +58,7 @@ public void logException(final Throwable t, @Nullable final Map<String, Object>
 
         @Override
         public void logUnhandledException(final Throwable t, @Nullable final Map<String, Object> options) {
-            calls.add(new Call("unhandled", t, options));
+            calls.add(new Call("unhandled", t, null, 0, options));
             if (throwOnNext != null) {
                 final RuntimeException e = throwOnNext;
                 throwOnNext = null;
@@ -78,20 +86,18 @@ public void theReasonIsThePayloadVerbatim() {
     }
 
     @Test
-    public void handledGoesToLogExceptionWithItsOptions() throws Exception {
+    public void handledGoesToLogExceptionWithItsDomain() {
         final RecordingSdk sdk = new RecordingSdk();
         final String payload = "{\"name\":\"Error\",\"message\":\"x\"}";
-        final String optionsJson = "{\"domain\":\"auth\",\"labels\":[\"a\",\"b\"],\"includeVideo\":true}";
+        final String optionsJson = "{\"domain\":\"auth\",\"labels\":[\"a\",\"b\"]}";
         ExceptionBridge.logHandled(sdk, payload, optionsJson);
         assertEquals(1, sdk.calls.size());
         final RecordingSdk.Call call = sdk.calls.get(0);
         assertEquals("handled", call.kind);
         assertTrue(call.throwable instanceof ReactNativeWebException);
         assertEquals(payload, call.throwable.getMessage());
-        assertNotNull(call.options);
-        assertEquals("auth", call.options.get("domain"));
-        assertEquals(Arrays.asList("a", "b"), call.options.get("labels"));
-        assertEquals(Boolean.TRUE, call.options.get("includeVideo"));
+        assertEquals("auth", call.domain);
+        assertEquals(0, call.skipFrames);
     }
 
     @Test
@@ -108,27 +114,19 @@ public void unhandledGoesToLogUnhandledExceptionWithoutOptions() {
     }
 
     @Test
-    public void optionsMapDomainLabelsAndIncludeVideo() throws Exception {
-        final Map<String, Object> options = ExceptionBridge.options(
-                "{\"domain\":\"d\",\"labels\":[\"one\",\"two\"],\"includeVideo\":false}");
+    public void optionsCarryTheDomain() throws Exception {
+        final ExceptionBridge.Options options = ExceptionBridge.options("{\"domain\":\"d\"}");
         assertNotNull(options);
-        assertEquals("d", options.get("domain"));
-        final Object labels = options.get("labels");
-        assertTrue(labels instanceof List);
-        @SuppressWarnings("unchecked")
-        final List<String> list = (List<String>) labels;
-        assertEquals(Arrays.asList("one", "two"), list);
-        assertTrue(options.get("includeVideo") instanceof Boolean);
-        assertEquals(Boolean.FALSE, options.get("includeVideo"));
+        assertEquals("d", options.domain);
     }
 
+    /** labels and includeVideo are not options any more: dropped like any other unknown key. */
     @Test
     public void unknownOptionKeysAreDropped() throws Exception {
-        final Map<String, Object> options = ExceptionBridge.options(
-                "{\"domain\":\"d\",\"skipFrames\":2,\"extra\":true}");
+        final ExceptionBridge.Options options = ExceptionBridge.options(
+                "{\"domain\":\"d\",\"labels\":[1],\"skipFrames\":2,\"includeVideo\":1,\"extra\":true}");
         assertNotNull(options);
-        assertEquals(Collections.singleton("domain"), options.keySet());
-        assertEquals("d", options.get("domain"));
+        assertEquals("d", options.domain);
     }
 
     @Test
@@ -145,16 +143,16 @@ public void unparseableOptionsStillSendTheException() {
         final RecordingSdk.Call call = sdk.calls.get(0);
         assertEquals("handled", call.kind);
         assertEquals(payload, call.throwable.getMessage());
-        assertNull(call.options);
+        assertNull(call.domain);
     }
 
     @Test
-    public void aWronglyTypedLabelIsABadJson() {
+    public void aWronglyTypedDomainIsABadJson() {
         try {
-            ExceptionBridge.options("{\"labels\":[1,2]}");
-            fail("expected BadJson for non-string labels");
+            ExceptionBridge.options("{\"domain\":3}");
+            fail("expected BadJson for a non-string domain");
         } catch (final BridgeJson.BadJson expected) {
-            // Reached: a number in labels is not a List<String>.
+            // Reached: a number is not a domain.
         }
     }
 
diff --git a/packages/react-native/ios/BugseeModule.mm b/packages/react-native/ios/BugseeModule.mm
index bd60b6ba..d314be4f 100644
--- a/packages/react-native/ios/BugseeModule.mm
+++ b/packages/react-native/ios/BugseeModule.mm
@@ -1342,21 +1342,23 @@ - (void)testCrash {
 }
 
 /// A handled JS exception. `payloadJson` is the Task 7.1a payload, forwarded
-/// verbatim as the reason; `optionsJson` is `{domain?, labels?, includeVideo?}`
-/// or null. Unparseable options are logged and the exception is still sent
-/// with nil options — a void method has no promise to reject.
+/// verbatim as the reason; `optionsJson` is `{domain?}` or null.
+/// Unparseable options are logged and the exception is still sent without
+/// them — a void method has no promise to reject.
 - (void)logException:(NSString *)payloadJson
          optionsJson:(NSString * _Nullable)optionsJson {
   BGSRNRunOnMain(^{
     NSError *error = nil;
-    BugseeExceptionLoggingOptions *opts =
+    BGSRNExceptionOptions *opts =
         [BGSRNExceptions loggingOptionsFromJSON:optionsJson error:&error];
     if (optionsJson != nil && opts == nil) {
       NSLog(@"BugseeRN exception options unparseable: %@", BGSRNErrorMessage(error));
     }
     const NSUInteger bytes = [payloadJson lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
-    // WORKAROUND for bugsee-cocoa#227: held while the SDK is Launching, which
-    // would drop it silently (BGSRNLaunchHold).
+    // WORKAROUND for bugsee-cocoa#227: held while the SDK is Launching
+    // (BGSRNLaunchHold). 7.0.0-beta7 accepts logException then
+    // (bugsee-cocoa#234); the hold stays for createReport and showReportDialog,
+    // which still need Launched, and keeps the calls in order.
     NSString *label = [NSString stringWithFormat:@"exception handled bytes=%lu", (unsigned long)bytes];
     [BGSRNLaunchHold.shared submit:label call:^(BGSRNGatedRun run) {
       if (run == BGSRNGatedRunDrop) {
@@ -1364,12 +1366,16 @@ - (void)logException:(NSString *)payloadJson
         return;
       }
       const BugseeStatus status = BGSRNCurrentStatus();
+      // skipFrames 0: it leaves top native frames out of the report's
+      // signature, and an RN report is keyed on the JS signature in the payload.
       [Bugsee logException:BGSRNReactNativeExceptionName
                     reason:payloadJson
-                   options:opts
+                    domain:opts.domain
+                skipFrames:0
                 completion:nil];
       // "sent" only for a call the SDK accepts: it drops one made when it is
-      // not Launched (before launch(), or after stop()).
+      // not Launched (before launch(), or after stop()). The hold never runs a
+      // call while the SDK is Launching.
       if (status == BugseeStatusLaunched) {
         NSLog(@"BugseeRN exception handled sent bytes=%lu", (unsigned long)bytes);
       } else {
@@ -1385,9 +1391,11 @@ - (void)logException:(NSString *)payloadJson
 /// `live_report.plcrash` (bugsee-cocoa #177; beta3 claimed only the live
 /// file and dropped this report); beta4 still missed some relaunches on an
 /// iPhone XS, which 7.0.0-beta5 fixes (bugsee-cocoa #191: the report is
-/// claimed by the build that armed the reporter). Do not copy one file onto the other. The completion is wrapped in `BGSRNSettleOnce`: on the
-/// simulator the SDK compiles `logUnhandledException` out and never calls
-/// this completion (verified facts), and a promise must still settle.
+/// claimed by the build that armed the reporter). Do not copy one file onto the other. The completion is wrapped in `BGSRNSettleOnce`: before
+/// 7.0.0-beta7 the simulator SDK compiled `logUnhandledException` out and never
+/// called this completion (bugsee-cocoa#225); beta7 calls it and files nothing
+/// (bugsee-cocoa#232).
+/// The guard stays: a promise must settle exactly once, whatever the SDK does.
 - (void)logUnhandledException:(NSString *)payloadJson
                       resolve:(RCTPromiseResolveBlock)resolve
                        reject:(RCTPromiseRejectBlock)reject {
diff --git a/packages/react-native/ios/Support/Sources/BugseeRNSupport/BGSRNExceptions.m b/packages/react-native/ios/Support/Sources/BugseeRNSupport/BGSRNExceptions.m
index 81902cfa..eececc70 100644
--- a/packages/react-native/ios/Support/Sources/BugseeRNSupport/BGSRNExceptions.m
+++ b/packages/react-native/ios/Support/Sources/BugseeRNSupport/BGSRNExceptions.m
@@ -16,14 +16,21 @@ static id Fail(NSError **out, NSError *made) {
   return nil;
 }
 
-static BOOL IsCFBoolean(id value) {
-  return [value isKindOfClass:NSNumber.class] &&
-         CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID();
+@implementation BGSRNExceptionOptions
+
+- (instancetype)initWithDomain:(NSString *)domain {
+  self = [super init];
+  if (self) {
+    _domain = [domain copy];
+  }
+  return self;
 }
 
+@end
+
 @implementation BGSRNExceptions
 
-+ (BugseeExceptionLoggingOptions *)loggingOptionsFromJSON:(NSString *)json error:(NSError **)error {
++ (BGSRNExceptionOptions *)loggingOptionsFromJSON:(NSString *)json error:(NSError **)error {
   if (json == nil) {
     if (error != NULL) {
       *error = nil;
@@ -42,10 +49,7 @@ + (BugseeExceptionLoggingOptions *)loggingOptionsFromJSON:(NSString *)json error
                                        }]);
   }
 
-  BugseeExceptionLoggingOptions *opts = [BugseeExceptionLoggingOptions new];
-  // The SDK's own object defaults includeVideo to NO; JS's contract is YES
-  // unless the caller set false. Force it before reading the wire.
-  opts.includeVideo = YES;
+  NSString *domainValue = nil;
 
   id domain = object[@"domain"];
   if (domain != nil) {
@@ -54,44 +58,16 @@ + (BugseeExceptionLoggingOptions *)loggingOptionsFromJSON:(NSString *)json error
                                              code:1
                                          userInfo:@{NSLocalizedDescriptionKey : @"domain must be a string"}]);
     }
-    opts.exceptionDomain = (NSString *)domain;
-  }
-
-  id labels = object[@"labels"];
-  if (labels != nil) {
-    if (![labels isKindOfClass:NSArray.class]) {
-      return Fail(error, [NSError errorWithDomain:BGSRNExceptionsErrorDomain
-                                             code:1
-                                         userInfo:@{NSLocalizedDescriptionKey : @"labels must be an array of strings"}]);
-    }
-    NSMutableArray<NSString *> *kept = [NSMutableArray array];
-    for (id element in (NSArray *)labels) {
-      if (![element isKindOfClass:NSString.class]) {
-        return Fail(error, [NSError errorWithDomain:BGSRNExceptionsErrorDomain
-                                               code:1
-                                           userInfo:@{NSLocalizedDescriptionKey : @"labels must be an array of strings"}]);
-      }
-      [kept addObject:element];
-    }
-    opts.labels = kept;
-  }
-
-  id includeVideo = object[@"includeVideo"];
-  if (includeVideo != nil) {
-    if (!IsCFBoolean(includeVideo)) {
-      return Fail(error, [NSError errorWithDomain:BGSRNExceptionsErrorDomain
-                                             code:1
-                                         userInfo:@{NSLocalizedDescriptionKey : @"includeVideo must be a boolean"}]);
-    }
-    opts.includeVideo = [(NSNumber *)includeVideo boolValue];
+    domainValue = (NSString *)domain;
   }
 
-  // Unknown keys (skipFrames, mergingRules, …) are ignored: JS already
-  // rejects them, and a future key must not refuse a report the facade sent.
+  // Unknown keys (labels, skipFrames, mergingRules, includeVideo, …) are
+  // ignored: JS already rejects them, and a future key must not refuse a report
+  // the facade sent.
   if (error != NULL) {
     *error = nil;
   }
-  return opts;
+  return [[BGSRNExceptionOptions alloc] initWithDomain:domainValue];
 }
 
 @end
diff --git a/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNExceptions.h b/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNExceptions.h
index 4b411148..647e38db 100644
--- a/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNExceptions.h
+++ b/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNExceptions.h
@@ -1,7 +1,4 @@
 #import <Foundation/Foundation.h>
-// Not `@import Bugsee;`: this header is included from ObjC++, where C++ modules
-// are off on both delivery paths and a module import is a hard error.
-#import <Bugsee/Bugsee.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -11,14 +8,18 @@ FOUNDATION_EXPORT NSString *const BGSRNReactNativeExceptionName;
 
 FOUNDATION_EXPORT NSErrorDomain const BGSRNExceptionsErrorDomain;
 
+/// What `+[Bugsee logException:reason:domain:skipFrames:completion:]` takes from the
+/// JS options, besides `skipFrames`, which JS does not have.
+@interface BGSRNExceptionOptions : NSObject
+@property(nonatomic, copy, readonly, nullable) NSString *domain;
+@end
+
 @interface BGSRNExceptions : NSObject
 
-/// `{domain?, labels?, includeVideo?}` as SDK options: domain →
-/// `exceptionDomain`; `includeVideo` defaults to YES (the SDK's own object
-/// defaults to NO). nil for nil text. Unparseable text or a wrongly typed
-/// value → nil and `*error`.
-+ (nullable BugseeExceptionLoggingOptions *)loggingOptionsFromJSON:(nullable NSString *)json
-                                                             error:(NSError *_Nullable *_Nullable)error;
+/// `{domain?}`. nil for nil text. Unparseable text or a wrongly typed domain → nil
+/// and `*error`. Other keys, `labels` and `includeVideo` among them, are ignored.
++ (nullable BGSRNExceptionOptions *)loggingOptionsFromJSON:(nullable NSString *)json
+                                                     error:(NSError *_Nullable *_Nullable)error;
 
 @end
 
diff --git a/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNLaunchHold.h b/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNLaunchHold.h
index 9f7af521..937615e6 100644
--- a/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNLaunchHold.h
+++ b/packages/react-native/ios/Support/Sources/BugseeRNSupport/include/BGSRNLaunchHold.h
@@ -6,7 +6,11 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /// WORKAROUND for https://github.com/bugsee/bugsee-cocoa/issues/227 -- remove
-/// this class, and its call sites in BugseeModule.mm, once that is fixed.
+/// this class, and its call sites in BugseeModule.mm, once every call it holds
+/// is accepted while the SDK is `Launching`. 7.0.0-beta7 accepts logException,
+/// logError and uploadWithSummary then (bugsee-cocoa#234);
+/// `+createReportWithCompletion:` and `+showReportDialog...` still return
+/// silently, so the hold stays for them and keeps all the calls in order.
 ///
 /// iOS 7.0.0-beta5 drops a report-creating call made while the SDK is
 /// `Launching`: `+logException:asHandled:withOptions:andCompletion:`
diff --git a/packages/react-native/ios/Support/Tests/BugseeRNSupportTests/BGSRNExceptionsTests.m b/packages/react-native/ios/Support/Tests/BugseeRNSupportTests/BGSRNExceptionsTests.m
index 27a6dbfd..23fe3a21 100644
--- a/packages/react-native/ios/Support/Tests/BugseeRNSupportTests/BGSRNExceptionsTests.m
+++ b/packages/react-native/ios/Support/Tests/BugseeRNSupportTests/BGSRNExceptionsTests.m
@@ -1,5 +1,4 @@
 @import XCTest;
-@import Bugsee;
 @import BugseeRNSupport;
 
 /// Pins the iOS half of the exception-options wire shape and the backend
@@ -9,9 +8,9 @@ @interface BGSRNExceptionsTests : XCTestCase
 
 @implementation BGSRNExceptionsTests
 
-- (BugseeExceptionLoggingOptions *)optionsFrom:(NSString *_Nullable)json {
+- (BGSRNExceptionOptions *)optionsFrom:(NSString *_Nullable)json {
   NSError *error = nil;
-  BugseeExceptionLoggingOptions *opts = [BGSRNExceptions loggingOptionsFromJSON:json error:&error];
+  BGSRNExceptionOptions *opts = [BGSRNExceptions loggingOptionsFromJSON:json error:&error];
   XCTAssertNotNil(opts, @"rejected %@: %@", json, error);
   XCTAssertNil(error);
   return opts;
@@ -28,27 +27,14 @@ - (void)testTheNameIsTheBackendContract {
   XCTAssertEqualObjects(BGSRNReactNativeExceptionName, @"ReactNativeWebException");
 }
 
-- (void)testDomainBecomesExceptionDomain {
-  BugseeExceptionLoggingOptions *opts = [self optionsFrom:@"{\"domain\":\"auth\"}"];
-  XCTAssertEqualObjects(opts.exceptionDomain, @"auth");
+- (void)testDomainIsKept {
+  BGSRNExceptionOptions *opts = [self optionsFrom:@"{\"domain\":\"auth\"}"];
+  XCTAssertEqualObjects(opts.domain, @"auth");
 }
 
-- (void)testIncludeVideoDefaultsToYes {
-  BugseeExceptionLoggingOptions *empty = [self optionsFrom:@"{}"];
-  XCTAssertTrue(empty.includeVideo, @"SDK defaults to NO; the wrapper must force YES");
-
-  BugseeExceptionLoggingOptions *domainOnly = [self optionsFrom:@"{\"domain\":\"x\"}"];
-  XCTAssertTrue(domainOnly.includeVideo);
-}
-
-- (void)testIncludeVideoFalseIsKept {
-  BugseeExceptionLoggingOptions *opts = [self optionsFrom:@"{\"includeVideo\":false}"];
-  XCTAssertFalse(opts.includeVideo);
-}
-
-- (void)testLabelsAreKept {
-  BugseeExceptionLoggingOptions *opts = [self optionsFrom:@"{\"labels\":[\"a\",\"b\"]}"];
-  XCTAssertEqualObjects(opts.labels, (@[ @"a", @"b" ]));
+- (void)testAnEmptyObjectHasNoDomain {
+  BGSRNExceptionOptions *opts = [self optionsFrom:@"{}"];
+  XCTAssertNil(opts.domain);
 }
 
 - (void)testNilJsonIsNilOptions {
@@ -65,20 +51,16 @@ - (void)testUnparseableJsonIsAnError {
   [self assertBad:@"not json"];
 }
 
-- (void)testANonStringLabelIsAnError {
-  [self assertBad:@"{\"labels\":[\"a\",1]}"];
-  [self assertBad:@"{\"labels\":\"a\"}"];
+- (void)testANonStringDomainIsAnError {
   [self assertBad:@"{\"domain\":3}"];
-  [self assertBad:@"{\"includeVideo\":1}"];
 }
 
+/// labels and includeVideo are not options any more (bugsee-cocoa#233): any
+/// value, of any type, is ignored like every other unknown key.
 - (void)testUnknownKeysAreIgnored {
-  BugseeExceptionLoggingOptions *opts =
-      [self optionsFrom:@"{\"domain\":\"d\",\"skipFrames\":2,\"mergingRules\":{},\"extra\":true}"];
-  XCTAssertEqualObjects(opts.exceptionDomain, @"d");
-  XCTAssertTrue(opts.includeVideo);
-  XCTAssertNil(opts.labels);
-  XCTAssertNil(opts.mergingRules);
+  BGSRNExceptionOptions *opts = [self optionsFrom:
+      @"{\"domain\":\"d\",\"labels\":[1],\"skipFrames\":2,\"mergingRules\":{},\"includeVideo\":1,\"extra\":true}"];
+  XCTAssertEqualObjects(opts.domain, @"d");
 }
 
 /// Malformed options say so in the bridge's own words, never the system
diff --git a/packages/react-native/src/NativeBugsee.ts b/packages/react-native/src/NativeBugsee.ts
index 697b3b9d..ad2b12ea 100644
--- a/packages/react-native/src/NativeBugsee.ts
+++ b/packages/react-native/src/NativeBugsee.ts
@@ -507,7 +507,7 @@ export interface Spec extends TurboModule {
   /** Uploads the created report. The handle is dead afterwards, whatever the result. */
   createdReportUpload(handleId: string): Promise<boolean>;
 
-  /** A handled JS exception. `payloadJson` is the Task 7.1a payload; `optionsJson` is `{domain?, labels?, includeVideo?}` or null. */
+  /** A handled JS exception. `payloadJson` is the Task 7.1a payload; `optionsJson` is `{domain?}` or null. */
   logException(payloadJson: string, optionsJson: string | null): void;
   /** An unhandled JS exception. Resolves once the SDK has the report; never rejects. */
   logUnhandledException(payloadJson: string): Promise<void>;
diff --git a/packages/react-native/src/exceptions/__tests__/ErrorBoundary.test.tsx b/packages/react-native/src/exceptions/__tests__/ErrorBoundary.test.tsx
index 49df84bb..116d5eca 100644
--- a/packages/react-native/src/exceptions/__tests__/ErrorBoundary.test.tsx
+++ b/packages/react-native/src/exceptions/__tests__/ErrorBoundary.test.tsx
@@ -223,7 +223,7 @@ describe('ErrorBoundary', () => {
 
   it('options reach the report', () => {
     const error = new Error('boom');
-    const options = { domain: 'auth', labels: ['a'] as const };
+    const options = { domain: 'auth' };
     render(
       <ErrorBoundary options={options}>
         <ThrowOnce error={error} armed={{ value: true }} />
diff --git a/packages/react-native/src/exceptions/__tests__/options.test.ts b/packages/react-native/src/exceptions/__tests__/options.test.ts
index ee3d2eb7..174c6225 100644
--- a/packages/react-native/src/exceptions/__tests__/options.test.ts
+++ b/packages/react-native/src/exceptions/__tests__/options.test.ts
@@ -25,15 +25,8 @@ describe('encodeExceptionOptions', () => {
     );
   });
 
-  it('domain, labels and includeVideo encode in that order', () => {
-    const encoded = encodeExceptionOptions({
-      includeVideo: true,
-      domain: 'auth',
-      labels: ['a', 'b'],
-    });
-    expect(encoded).toBe(
-      '{"domain":"auth","labels":["a","b"],"includeVideo":true}',
-    );
+  it('a domain encodes as {domain}', () => {
+    expect(encodeExceptionOptions({ domain: 'auth' })).toBe('{"domain":"auth"}');
   });
 
   it('accepts a domain of exactly EXCEPTION_DOMAIN_MAX_LENGTH', () => {
@@ -59,23 +52,16 @@ describe('encodeExceptionOptions', () => {
     ).toThrow(new TypeError('ExceptionOptions.domain must be a string'));
   });
 
-  it('rejects labels that are not an array of strings', () => {
+  it('rejects labels: neither SDK takes them on logException (setReportHandler does)', () => {
     expect(() =>
-      encodeExceptionOptions({ labels: 'x' as unknown as string[] }),
-    ).toThrow(
-      new TypeError('ExceptionOptions.labels must be an array of strings'),
-    );
-    expect(() =>
-      encodeExceptionOptions({ labels: [1] as unknown as string[] }),
-    ).toThrow(
-      new TypeError('ExceptionOptions.labels must be an array of strings'),
-    );
+      encodeExceptionOptions({ labels: ['a'] } as never),
+    ).toThrow(new TypeError('ExceptionOptions has unknown key "labels"'));
   });
 
-  it('rejects a non-boolean includeVideo', () => {
+  it('rejects includeVideo: neither SDK can leave the video out', () => {
     expect(() =>
-      encodeExceptionOptions({ includeVideo: 1 as unknown as boolean }),
-    ).toThrow(new TypeError('ExceptionOptions.includeVideo must be a boolean'));
+      encodeExceptionOptions({ includeVideo: true } as never),
+    ).toThrow(new TypeError('ExceptionOptions has unknown key "includeVideo"'));
   });
 
   it('rejects an unknown key, naming it', () => {
@@ -104,13 +90,6 @@ describe('encodeExceptionOptions', () => {
     } catch (error) {
       expect((error as Error).message).not.toContain(longSecret);
     }
-    const labelSecret = 'SECRET_LABEL_VALUE';
-    try {
-      encodeExceptionOptions({ labels: [labelSecret, 1] as unknown as string[] });
-      throw new Error('expected throw');
-    } catch (error) {
-      expect((error as Error).message).not.toContain(labelSecret);
-    }
   });
 });
 
diff --git a/packages/react-native/src/exceptions/__tests__/report.test.ts b/packages/react-native/src/exceptions/__tests__/report.test.ts
index 9b71128c..c5b1a53e 100644
--- a/packages/react-native/src/exceptions/__tests__/report.test.ts
+++ b/packages/react-native/src/exceptions/__tests__/report.test.ts
@@ -71,7 +71,7 @@ describe('report', () => {
   it('a handled error crosses as its payload and options', () => {
     const { reportHandled: report, native } = load();
     const error = new Error('boom');
-    report(error, { domain: 'auth', labels: ['a'], includeVideo: false });
+    report(error, { domain: 'auth' });
     const payload = buildExceptionPayload({
       error,
       platformOS: 'android',
@@ -79,7 +79,7 @@ describe('report', () => {
     expect(native.logException).toHaveBeenCalledTimes(1);
     expect(native.logException).toHaveBeenCalledWith(
       encodeBridgeObject(payload as unknown as Record<string, unknown>),
-      encodeExceptionOptions({ domain: 'auth', labels: ['a'], includeVideo: false }),
+      encodeExceptionOptions({ domain: 'auth' }),
     );
   });
 
diff --git a/packages/react-native/src/exceptions/options.ts b/packages/react-native/src/exceptions/options.ts
index 40635037..2a9e9e0b 100644
--- a/packages/react-native/src/exceptions/options.ts
+++ b/packages/react-native/src/exceptions/options.ts
@@ -3,23 +3,21 @@ import { errorName } from '../errorName';
 /**
  * Options for a handled JS exception (`Bugsee.logException`).
  *
- * Encoded as JSON text for the TurboModule: `{domain?, labels?, includeVideo?}`
- * or `null` when nothing was set. Unknown keys are rejected; messages name the
+ * Encoded as JSON text for the TurboModule: `{domain?}` or `null` when
+ * nothing was set. Unknown keys are rejected; messages name the
  * field and never the rejected value.
  */
 
 export interface ExceptionOptions {
-  /** Groups the issue on the dashboard. Non-empty, at most 256 characters. */
+  /** The exception domain. Android groups issues by it; iOS records it with the report. Non-empty, at most 256 characters. */
   domain?: string;
-  /** Issue labels. Android 7.3.0 ignores them (to raise); iOS applies them. */
-  labels?: readonly string[];
-  /** Recorded in the report's exception options on iOS; neither 7.x SDK acts on it yet. */
-  includeVideo?: boolean;
 }
 
 export const EXCEPTION_DOMAIN_MAX_LENGTH = 256;
 
-const ALLOWED_KEYS = new Set(['domain', 'labels', 'includeVideo']);
+// Neither 7.x SDK's logException takes labels (label a report in setReportHandler)
+// or can leave the video out of one report, so there is no `labels` or `includeVideo`.
+const ALLOWED_KEYS = new Set(['domain']);
 
 /** Every error `encodeExceptionOptions` threw: by identity, not by text. */
 const thrownHere = new WeakSet<Error>();
@@ -64,7 +62,6 @@ export function encodeExceptionOptions(
     }
   }
 
-  // Built in domain → labels → includeVideo order so the wire text is stable.
   const out: Record<string, unknown> = {};
 
   if (record.domain !== undefined) {
@@ -82,25 +79,6 @@ export function encodeExceptionOptions(
     out.domain = record.domain;
   }
 
-  if (record.labels !== undefined) {
-    if (!Array.isArray(record.labels)) {
-      refuse(new TypeError('ExceptionOptions.labels must be an array of strings'));
-    }
-    for (const label of record.labels) {
-      if (typeof label !== 'string') {
-        refuse(new TypeError('ExceptionOptions.labels must be an array of strings'));
-      }
-    }
-    out.labels = [...record.labels];
-  }
-
-  if (record.includeVideo !== undefined) {
-    if (typeof record.includeVideo !== 'boolean') {
-      refuse(new TypeError('ExceptionOptions.includeVideo must be a boolean'));
-    }
-    out.includeVideo = record.includeVideo;
-  }
-
   if (Object.keys(out).length === 0) {
     return null;
   }