fix: guard reporter calls + reach 100% branch coverage

Wrap Reporter.report and Reporter.addBreadcrumbs in try-catch so a
failing reporter cannot mask the original error. Log only in debug.
Drop unreachable breadcrumbData cache guard and add tests for
defensive breadcrumb extraction branches.

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

Author: w01fgang

src/__tests__/coverage-gaps.test.ts

@@ -264,6 +264,51 @@ describe('coverage gaps', () => {
       );
       expect(out).toEqual({ a: 1 });
     });
+
+    it('non-object, non-array config returns empty object', () => {
+      const out = BreadcrumbExtractorUtil.extract(
+        42 as never,
+        [{ id: 1 }],
+        false,
+      );
+      expect(out).toEqual({});
+    });
+
+    it('extractor without keys/transform/as returns empty object', () => {
+      const out = BreadcrumbExtractorUtil.extract(
+        [{ param: 0 } as never],
+        [{ id: 1 }],
+        false,
+      );
+      expect(out).toEqual({});
+    });
+
+    it('positional string entry with undefined arg is dropped', () => {
+      const out = BreadcrumbExtractorUtil.extract(
+        ['label'],
+        [undefined] as never,
+        false,
+      );
+      expect(out).toEqual({});
+    });
+
+    it('positional entry that is neither string nor array is skipped', () => {
+      const out = BreadcrumbExtractorUtil.extract(
+        [42 as never],
+        [{ id: 1 }],
+        false,
+      );
+      expect(out).toEqual({});
+    });
+
+    it('object-style config with non-array non-function paramConfig returns empty', () => {
+      const out = BreadcrumbExtractorUtil.extract(
+        { 0: 'unexpected' as never },
+        [{ id: 1 }],
+        false,
+      );
+      expect(out).toEqual({});
+    });
   });
 
   describe('extractDoctests untagged unterminated fence', () => {
@@ -272,4 +317,175 @@ describe('coverage gaps', () => {
       expect(extractDoctests(source)).toHaveLength(0);
     });
   });
+
+  describe('reporter error resilience', () => {
+    let priorReporter: ReturnType<typeof Try.getDefaultReporter>;
+
+    beforeEach(() => {
+      priorReporter = Try.getDefaultReporter();
+    });
+
+    afterEach(() => {
+      Try.setDefaultReporter(priorReporter);
+    });
+
+    it('sync: reporter.report() throwing does not mask original error', () => {
+      Try.setDefaultReporter({
+        report: () => {
+          throw new Error('reporter down');
+        },
+        addBreadcrumbs: vi.fn(),
+        createWrappedError: (e, m) => {
+          const w = new Error(m);
+          w.cause = e;
+          return w;
+        },
+      });
+
+      expect(() =>
+        new Try(() => {
+          throw new Error('original');
+        })
+          .report('wrapped')
+          .unwrap(),
+      ).toThrow('wrapped');
+    });
+
+    it('async: reporter.report() throwing does not mask original error', async () => {
+      Try.setDefaultReporter({
+        report: () => {
+          throw new Error('reporter down');
+        },
+        addBreadcrumbs: vi.fn(),
+        createWrappedError: (e, m) => {
+          const w = new Error(m);
+          w.cause = e;
+          return w;
+        },
+      });
+
+      await expect(
+        new Try(async () => {
+          throw new Error('original');
+        })
+          .report('wrapped')
+          .unwrap(),
+      ).rejects.toThrow('wrapped');
+    });
+
+    it('reporter.addBreadcrumbs() throwing does not break execution', async () => {
+      Try.setDefaultReporter({
+        report: vi.fn(),
+        addBreadcrumbs: () => {
+          throw new Error('breadcrumb store unavailable');
+        },
+        createWrappedError: (e) => e,
+      });
+
+      const result = await new Try(
+        async (_ctx: { id: string }) => {
+          throw new Error('original');
+        },
+        { id: 'x' },
+      )
+        .breadcrumbs(['id'])
+        .default('fallback')
+        .value();
+
+      expect(result).toBe('fallback');
+    });
+
+    it('sync: reporter.addBreadcrumbs() throwing does not break execution', () => {
+      Try.setDefaultReporter({
+        report: vi.fn(),
+        addBreadcrumbs: () => {
+          throw new Error('breadcrumb store unavailable');
+        },
+        createWrappedError: (e) => e,
+      });
+
+      const err = new Try(
+        (_ctx: { id: string }) => {
+          throw new Error('original');
+        },
+        { id: 'x' },
+      )
+        .breadcrumbs(['id'])
+        .error();
+
+      expect(err).toBeInstanceOf(Error);
+      expect((err as Error).message).toBe('original');
+    });
+
+    it('reporter errors are logged in debug mode', async () => {
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      Try.setDefaultReporter({
+        report: () => {
+          throw new Error('reporter down');
+        },
+        addBreadcrumbs: vi.fn(),
+        createWrappedError: (e) => e,
+      });
+
+      await new Try(async () => {
+        throw new Error('original');
+      })
+        .debug(true)
+        .report('msg')
+        .default('fallback')
+        .value();
+
+      expect(spy).toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('reporter errors are silent without debug', async () => {
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      Try.setDefaultReporter({
+        report: () => {
+          throw new Error('reporter down');
+        },
+        addBreadcrumbs: vi.fn(),
+        createWrappedError: (e) => e,
+      });
+
+      await new Try(async () => {
+        throw new Error('original');
+      })
+        .report('msg')
+        .default('fallback')
+        .value();
+
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('addBreadcrumbs errors are logged in debug mode', async () => {
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      Try.setDefaultReporter({
+        report: vi.fn(),
+        addBreadcrumbs: () => {
+          throw new Error('breadcrumb store down');
+        },
+        createWrappedError: (e) => e,
+      });
+
+      await new Try(
+        async (_ctx: { id: string }) => {
+          throw new Error('original');
+        },
+        { id: 'x' },
+      )
+        .debug(true)
+        .breadcrumbs(['id'])
+        .default('fallback')
+        .value();
+
+      expect(spy).toHaveBeenCalledWith(
+        'Reporter.addBreadcrumbs threw:',
+        expect.any(Error),
+      );
+      spy.mockRestore();
+    });
+  });
 });

src/core/Try.ts

@@ -814,14 +814,22 @@ export class Try<
 
   /**
    * Report error using the configured reporter with context.
+   * Reporter failures are swallowed so a broken reporter never masks
+   * the original error from the caller.
    */
   private reportError(error: Error): void {
     this.addBreadcrumbsIfConfigured();
 
-    Try.defaultReporter.report(error, {
-      message: this.config.message,
-      tags: this.config.tags,
-    });
+    try {
+      Try.defaultReporter.report(error, {
+        message: this.config.message,
+        tags: this.config.tags,
+      });
+    } catch (reporterError) {
+      if (this.config.debug) {
+        console.error('Reporter.report threw:', reporterError);
+      }
+    }
   }
 
   /**
@@ -840,11 +848,9 @@ export class Try<
       return;
     }
 
-    if (!this.local.breadcrumbData) {
-      this.local.breadcrumbData = this.extractAllBreadcrumbData(
-        this.config.breadcrumbConfig,
-      );
-    }
+    this.local.breadcrumbData = this.extractAllBreadcrumbData(
+      this.config.breadcrumbConfig,
+    );
 
     // Mark the guard before short-circuiting on empty data so subsequent
     // terminals (and clones sharing `exec`) do not re-run extraction for
@@ -857,7 +863,13 @@ export class Try<
 
     const functionName = this.fn.name || 'anonymous';
 
-    Try.defaultReporter.addBreadcrumbs(this.local.breadcrumbData, functionName);
+    try {
+      Try.defaultReporter.addBreadcrumbs(this.local.breadcrumbData, functionName);
+    } catch (reporterError) {
+      if (this.config.debug) {
+        console.error('Reporter.addBreadcrumbs threw:', reporterError);
+      }
+    }
     this.local.breadcrumbsAdded = true;
     this.exec.breadcrumbsEmitted.add(this.config.breadcrumbConfig);
   }