test(utils): add unit coverage for trace.js + safeStringify extensions + truncateString

49 new test cases across two files:

- `test/unit/utils/trace_test.js` (new, 37 cases) — direct coverage of
  every export from `lib/utils/trace.js`:
  - `pickActingHelper` (all 3 paths)
  - `traceDirFor` (determinism, uniqueness, sanitization, missing args)
  - `snapshotDirFor` (uniqueness, embedded timestamp)
  - `artifactLinks` (each artifact, console-count override, storage
    counts, custom indent, empty input, ordering invariant)
  - `fileToUrl` / `artifactsToFileUrls`
  - `writeTraceMarkdown` (golden output, error block, optional commands,
    default `file`)
  - `captureSnapshot` (default options, full opt-out matrix, fullPage,
    formatHtml integration, ConsoleMessage normalization, Playwright
    grabStorageState path, Puppeteer/WebDriver fallback path, empty
    storage handled, missing helper methods, error swallowing, default
    prefix)

- `test/unit/circular_reference_test.js` (extended, 12 new cases):
  - `safeStringify` Function/BigInt/Symbol/Error coercions including
    nested mixed types (BigInt was a real bug; JSON.stringify(BigInt)
    used to throw and trigger the legacy fallback path)
  - `truncateString` under / equal / over maxBytes, non-string coercion,
    empty string

Total unit suite: 121 passing (was 72).

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

Author: DavertMik

test/unit/circular_reference_test.js

@@ -1,5 +1,5 @@
 import { expect } from 'chai'
-import { safeStringify } from '../../lib/utils.js'
+import { safeStringify, truncateString } from '../../lib/utils.js'
 import { createTest } from '../../lib/mocha/test.js'
 import { createSuite } from '../../lib/mocha/suite.js'
 import MochaSuite from 'mocha/lib/suite.js'
@@ -160,6 +160,103 @@ describe('Circular Reference Handling', function () {
     })
   })
 
+  describe('safeStringify type coercions', function () {
+    it('coerces functions to "[Function: name]"', function () {
+      const obj = { fn: function namedFn() {}, anon: () => {} }
+      const parsed = JSON.parse(safeStringify(obj))
+      expect(parsed.fn).to.equal('[Function: namedFn]')
+      expect(parsed.anon).to.match(/^\[Function: .*\]$/)
+    })
+
+    it('coerces BigInt values (which JSON.stringify cannot natively handle)', function () {
+      const result = safeStringify({ big: 12345678901234567890n })
+      expect(result).to.contain('12345678901234567890n')
+      // Verify the legacy fallback path is NOT triggered
+      expect(result).to.not.contain('Failed to serialize')
+    })
+
+    it('coerces Symbol to its toString()', function () {
+      const obj = { s: Symbol('marker') }
+      const parsed = JSON.parse(safeStringify(obj))
+      expect(parsed.s).to.equal('Symbol(marker)')
+    })
+
+    it('coerces Error to {name, message, stack}', function () {
+      const obj = { err: new Error('boom') }
+      const parsed = JSON.parse(safeStringify(obj))
+      expect(parsed.err).to.have.property('name', 'Error')
+      expect(parsed.err).to.have.property('message', 'boom')
+      expect(parsed.err).to.have.property('stack')
+      expect(parsed.err.stack).to.be.a('string').and.include('boom')
+    })
+
+    it('coerces an Error at the top level', function () {
+      const result = safeStringify(new TypeError('bad arg'))
+      const parsed = JSON.parse(result)
+      expect(parsed.name).to.equal('TypeError')
+      expect(parsed.message).to.equal('bad arg')
+    })
+
+    it('handles nested mixed types together', function () {
+      const obj = {
+        regular: 1,
+        fn: function n() {},
+        big: 1n,
+        sym: Symbol('s'),
+        err: new RangeError('range'),
+        nested: { again: { fn: () => {} } },
+      }
+      const parsed = JSON.parse(safeStringify(obj))
+      expect(parsed.regular).to.equal(1)
+      expect(parsed.fn).to.equal('[Function: n]')
+      expect(parsed.big).to.equal('1n')
+      expect(parsed.sym).to.equal('Symbol(s)')
+      expect(parsed.err.name).to.equal('RangeError')
+      expect(parsed.nested.again.fn).to.match(/^\[Function:/)
+    })
+
+    it('preserves indentation when space arg is provided', function () {
+      const result = safeStringify({ a: 1 }, [], 2)
+      expect(result).to.contain('\n  "a": 1')
+    })
+  })
+
+  describe('truncateString', function () {
+    it('returns input as-is when under maxBytes', function () {
+      const result = truncateString('hello', 100)
+      expect(result.value).to.equal('hello')
+      expect(result.truncated).to.be.false
+      expect(result.fullLength).to.equal(5)
+    })
+
+    it('returns input as-is when exactly equal to maxBytes', function () {
+      const result = truncateString('xxxxx', 5)
+      expect(result.truncated).to.be.false
+      expect(result.value).to.equal('xxxxx')
+    })
+
+    it('truncates and appends marker when over maxBytes', function () {
+      const result = truncateString('x'.repeat(50), 10)
+      expect(result.truncated).to.be.true
+      expect(result.fullLength).to.equal(50)
+      expect(result.value.startsWith('xxxxxxxxxx')).to.be.true
+      expect(result.value).to.contain('truncated 40 more chars')
+    })
+
+    it('coerces non-string inputs via String()', function () {
+      const result = truncateString(12345, 100)
+      expect(result.value).to.equal('12345')
+      expect(result.truncated).to.be.false
+    })
+
+    it('handles empty string', function () {
+      const result = truncateString('', 10)
+      expect(result.value).to.equal('')
+      expect(result.truncated).to.be.false
+      expect(result.fullLength).to.equal(0)
+    })
+  })
+
   describe('Integration with existing serialization', function () {
     it('should work with serializeTest function', function () {
       const test = createTest('Integration Test', () => {})