dd-trace 5.87.0 → 5.89.0

package/packages/datadog-plugin-bullmq/src/producer.js

@@ -10,6 +10,12 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
     ctx.currentStore?.span?.finish()
   }
 
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { span } = ctx.currentStore
+    this.setProducerCheckpoint(span, ctx)
+  }
+
   bindStart (ctx) {
     const { resource, meta } = this.getSpanData(ctx)
     const span = this.startSpan({
@@ -25,10 +31,6 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
 
     this.injectTraceContext(span, ctx)
 
-    if (this.config.dsmEnabled) {
-      this.setProducerCheckpoint(span, ctx)
-    }
-
     return ctx.currentStore
   }
 
@@ -40,13 +42,24 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
     throw new Error('injectTraceContext must be implemented by subclass')
   }
 
+  _injectIntoOpts (span, opts) {
+    const carrier = {}
+    this.tracer.inject(span, 'text_map', carrier)
+    const existing = opts.telemetry?.metadata ? JSON.parse(opts.telemetry.metadata) : {}
+    existing._datadog = carrier
+    opts.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
+  }
+
   setProducerCheckpoint (span, ctx) {
-    const { queueName, payloadSize, injectTarget } = this.getDsmData(ctx)
+    const { queueName, payloadSize, optsTarget } = this.getDsmData(ctx)
     const edgeTags = ['direction:out', `topic:${queueName}`, 'type:bullmq']
     const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
-    if (injectTarget && typeof injectTarget === 'object') {
-      injectTarget._datadog = injectTarget._datadog || {}
-      DsmPathwayCodec.encode(dataStreamsContext, injectTarget._datadog)
+
+    if (optsTarget && typeof optsTarget === 'object') {
+      const existing = optsTarget.telemetry?.metadata ? JSON.parse(optsTarget.telemetry.metadata) : {}
+      DsmPathwayCodec.encode(dataStreamsContext, existing._datadog || existing)
+      if (!existing._datadog) existing._datadog = {}
+      optsTarget.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
     }
   }
 
@@ -68,12 +81,22 @@ class QueueAddPlugin extends BaseBullmqProducerPlugin {
     }
   }
 
-  injectTraceContext (span, ctx) {
-    const data = ctx.arguments?.[1]
-    if (data?.constructor?.name === 'Object') {
-      data._datadog = data._datadog || {}
-      this.tracer.inject(span, 'text_map', data._datadog)
+  #ensureOpts (ctx) {
+    let opts = ctx.arguments?.[2]
+    if (!opts || typeof opts !== 'object') {
+      opts = {}
+      if (ctx.arguments.length <= 2) {
+        Array.prototype.push.call(ctx.arguments, opts)
+      } else {
+        ctx.arguments[2] = opts
+      }
     }
+    return opts
+  }
+
+  injectTraceContext (span, ctx) {
+    const opts = this.#ensureOpts(ctx)
+    this._injectIntoOpts(span, opts)
   }
 
   getDsmData (ctx) {
@@ -81,7 +104,7 @@ class QueueAddPlugin extends BaseBullmqProducerPlugin {
     return {
       queueName: ctx.self?.name || 'bullmq',
       payloadSize: data ? getMessageSize(data) : 0,
-      injectTarget: data,
+      optsTarget: this.#ensureOpts(ctx),
     }
   }
 }
@@ -108,10 +131,11 @@ class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
   injectTraceContext (span, ctx) {
     const jobs = ctx.arguments?.[0]
     if (!Array.isArray(jobs)) return
+
     for (const job of jobs) {
-      if (job?.data?.constructor?.name !== 'Object') continue
-      job.data._datadog = job.data._datadog || {}
-      this.tracer.inject(span, 'text_map', job.data._datadog)
+      if (!job) continue
+      job.opts = job.opts || {}
+      this._injectIntoOpts(span, job.opts)
     }
   }
 
@@ -123,7 +147,7 @@ class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
     return {
       queueName: ctx.self?.name || 'bullmq',
       payloadSize,
-      injectTarget: jobs[0]?.data,
+      optsTarget: jobs[0]?.opts,
     }
   }
 
@@ -133,12 +157,14 @@ class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
     const edgeTags = ['direction:out', `topic:${queueName}`, 'type:bullmq']
 
     for (const job of jobs) {
-      if (job?.data && job.data !== null && job.data.constructor.name === 'Object') {
-        const payloadSize = getMessageSize(job.data)
-        const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
-        job.data._datadog = job.data._datadog || {}
-        DsmPathwayCodec.encode(dataStreamsContext, job.data._datadog)
-      }
+      if (!job?.data) continue
+      const payloadSize = getMessageSize(job.data)
+      const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
+      job.opts = job.opts || {}
+      const existing = job.opts.telemetry?.metadata ? JSON.parse(job.opts.telemetry.metadata) : {}
+      DsmPathwayCodec.encode(dataStreamsContext, existing._datadog || existing)
+      if (!existing._datadog) existing._datadog = {}
+      job.opts.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
     }
   }
 }
@@ -159,18 +185,21 @@ class FlowProducerAddPlugin extends BaseBullmqProducerPlugin {
 
   injectTraceContext (span, ctx) {
     const flow = ctx.arguments?.[0]
-    if (flow?.data?.constructor?.name === 'Object') {
-      flow.data._datadog = flow.data._datadog || {}
-      this.tracer.inject(span, 'text_map', flow.data._datadog)
-    }
+    if (!flow) return
+    flow.opts = flow.opts || {}
+    this._injectIntoOpts(span, flow.opts)
   }
 
   getDsmData (ctx) {
     const flow = ctx.arguments?.[0]
+    if (!flow) {
+      return { queueName: 'bullmq', payloadSize: 0, optsTarget: undefined }
+    }
+    flow.opts = flow.opts || {}
     return {
-      queueName: flow?.queueName || 'bullmq',
-      payloadSize: flow?.data ? getMessageSize(flow.data) : 0,
-      injectTarget: flow?.data,
+      queueName: flow.queueName || 'bullmq',
+      payloadSize: flow.data ? getMessageSize(flow.data) : 0,
+      optsTarget: flow.opts,
     }
   }
 }

package/packages/datadog-plugin-cucumber/src/index.js

@@ -128,12 +128,15 @@ class CucumberPlugin extends CiPlugin {
       const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
       const testSourceFile = getTestSuitePath(testFileAbsolutePath, this.repositoryRoot)
 
-      const testSuiteMetadata = getTestSuiteCommonTags(
-        this.command,
-        this.frameworkVersion,
-        testSuitePath,
-        'cucumber'
-      )
+      const testSuiteMetadata = {
+        ...getTestSuiteCommonTags(
+          this.command,
+          this.frameworkVersion,
+          testSuitePath,
+          'cucumber'
+        ),
+        ...this.getSessionRequestErrorTags(),
+      }
       if (isUnskippable) {
         this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -46,6 +46,8 @@ const {
   TEST_RETRY_REASON_TYPES,
   getPullRequestDiff,
   getModifiedFilesFromDiff,
+  getSessionRequestErrorTags,
+  DD_CI_LIBRARY_CONFIGURATION_ERROR,
   TEST_IS_MODIFIED,
   getPullRequestBaseBranch,
 } = require('../../dd-trace/src/plugins/util/test')
@@ -89,6 +91,11 @@ const {
   RUNTIME_VERSION,
 } = require('../../dd-trace/src/plugins/util/env')
 const { DD_MAJOR } = require('../../../version')
+const {
+  resolveOriginalSourcePosition,
+  resolveSourceLineForTest,
+  shouldTrustInvocationDetailsLine,
+} = require('./source-map-utils')
 
 const TEST_FRAMEWORK_NAME = 'cypress'
 
@@ -236,7 +243,6 @@ class CypressPlugin {
 
   finishedTestsByFile = {}
   testStatuses = {}
-
   isTestsSkipped = false
   isSuitesSkippingEnabled = false
   isCodeCoverageEnabled = false
@@ -306,6 +312,9 @@ class CypressPlugin {
 
     this.isTestIsolationEnabled = getIsTestIsolationEnabled(cypressConfig)
 
+    const envFlushWait = Number(getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS'))
+    this.rumFlushWaitMillis = Number.isFinite(envFlushWait) ? envFlushWait : undefined
+
     if (!this.isTestIsolationEnabled) {
       log.warn('Test isolation is disabled, retries will not be enabled')
     }
@@ -314,10 +323,15 @@ class CypressPlugin {
     this.testEnvironmentMetadata[DD_TEST_IS_USER_PROVIDED_SERVICE] =
       tracer._tracer._config.isServiceUserProvided ? 'true' : 'false'
 
+    this._pendingRequestErrorTags = []
     this.libraryConfigurationPromise = getLibraryConfiguration(this.tracer, this.testConfiguration)
       .then((libraryConfigurationResponse) => {
         if (libraryConfigurationResponse.err) {
           log.error('Cypress plugin library config response error', libraryConfigurationResponse.err)
+          this._pendingRequestErrorTags.push({
+            tag: DD_CI_LIBRARY_CONFIGURATION_ERROR,
+            value: 'true',
+          })
         } else {
           const {
             libraryConfig: {
@@ -381,7 +395,9 @@ class CypressPlugin {
     this.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
 
     if (testSuiteAbsolutePath) {
-      const testSourceFile = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const resolvedSuitePosition = resolveOriginalSourcePosition(testSuiteAbsolutePath, 1)
+      const resolvedSuiteAbsolutePath = resolvedSuitePosition ? resolvedSuitePosition.sourceFile : testSuiteAbsolutePath
+      const testSourceFile = getTestSuitePath(resolvedSuiteAbsolutePath, this.repositoryRoot)
       testSuiteSpanMetadata[TEST_SOURCE_FILE] = testSourceFile
       testSuiteSpanMetadata[TEST_SOURCE_START] = 1
       const codeOwners = this.getTestCodeOwners({ testSuite, testSourceFile })
@@ -412,6 +428,7 @@ class CypressPlugin {
     if (this.testSessionSpan && this.testModuleSpan) {
       testSuiteTags[TEST_SESSION_ID] = this.testSessionSpan.context().toTraceId()
       testSuiteTags[TEST_MODULE_ID] = this.testModuleSpan.context().toSpanId()
+      Object.assign(testSuiteTags, this.getSessionRequestErrorTags())
       // If testSuiteSpan couldn't be created, we'll use the testModuleSpan as the parent
       if (!this.testSuiteSpan) {
         testSuiteTags[TEST_SUITE_ID] = this.testModuleSpan.context().toSpanId()
@@ -468,6 +485,14 @@ class CypressPlugin {
     })
   }
 
+  /**
+   * Returns request error tags from the test session span for propagation to test spans.
+   * @returns {Record<string, string>}
+   */
+  getSessionRequestErrorTags () {
+    return getSessionRequestErrorTags(this.testSessionSpan)
+  }
+
   ciVisEvent (name, testLevel, tags = {}) {
     incrementCountMetric(name, {
       testLevel,
@@ -596,14 +621,20 @@ class CypressPlugin {
       },
       integrationName: TEST_FRAMEWORK_NAME,
     })
+    for (const { tag, value } of this._pendingRequestErrorTags) {
+      this.testSessionSpan.setTag(tag, value)
+    }
+    this._pendingRequestErrorTags = []
     this.ciVisEvent(TELEMETRY_EVENT_CREATED, 'session')
 
+    const sessionRequestErrorTags = getSessionRequestErrorTags(this.testSessionSpan)
     this.testModuleSpan = this.tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_module`, {
       childOf: this.testSessionSpan,
       tags: {
         [COMPONENT]: TEST_FRAMEWORK_NAME,
         ...this.testEnvironmentMetadata,
         ...testModuleSpanMetadata,
+        ...sessionRequestErrorTags,
       },
       integrationName: TEST_FRAMEWORK_NAME,
     })
@@ -779,8 +810,10 @@ class CypressPlugin {
         if (this.itrCorrelationId) {
           finishedTest.testSpan.setTag(ITR_CORRELATION_ID, this.itrCorrelationId)
         }
-        const testSourceFile = spec.absolute && this.repositoryRoot
-          ? getTestSuitePath(spec.absolute, this.repositoryRoot)
+        const resolvedSpecPosition = spec.absolute ? resolveOriginalSourcePosition(spec.absolute, 1) : null
+        const resolvedSpecAbsolutePath = resolvedSpecPosition ? resolvedSpecPosition.sourceFile : spec.absolute
+        const testSourceFile = resolvedSpecAbsolutePath && this.repositoryRoot
+          ? getTestSuitePath(resolvedSpecAbsolutePath, this.repositoryRoot)
           : spec.relative
         if (testSourceFile) {
           finishedTest.testSpan.setTag(TEST_SOURCE_FILE, testSourceFile)
@@ -823,6 +856,7 @@ class CypressPlugin {
           isModifiedTest: this.getIsTestModified(testSuiteAbsolutePath),
           repositoryRoot: this.repositoryRoot,
           isTestIsolationEnabled: this.isTestIsolationEnabled,
+          rumFlushWaitMillis: this.rumFlushWaitMillis,
         }
 
         if (this.testSuiteSpan) {
@@ -876,9 +910,11 @@ class CypressPlugin {
           error,
           isRUMActive,
           testSourceLine,
+          testSourceStack,
           testSuite,
           testSuiteAbsolutePath,
           testName,
+          testItTitle,
           isNew,
           isEfdRetry,
           isAttemptToFix,
@@ -920,8 +956,29 @@ class CypressPlugin {
         if (isRUMActive) {
           this.activeTestSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
         }
+        // Source-line resolution strategy:
+        // 1. If plain JS and no source map, trust invocationDetails.line directly.
+        // 2. Otherwise, try invocationDetails.stack line mapped through source map.
+        // 3. If that fails, scan generated file for it/test/specify declaration by test name.
+        // 4. If declaration found:
+        //    - .ts file: use declaration line directly.
+        //    - .js file: map declaration line through source map.
+        // 5. If all fail, keep original invocationDetails.line.
         if (testSourceLine) {
-          this.activeTestSpan.setTag(TEST_SOURCE_START, testSourceLine)
+          let resolvedLine = testSourceLine
+          if (testSuiteAbsolutePath && testItTitle) {
+            // Use invocationDetails directly only for plain JS specs without source maps.
+            // Otherwise, resolve from the test declaration in the spec and map via source map.
+            const shouldTrustInvocationDetails = shouldTrustInvocationDetailsLine(testSuiteAbsolutePath, testSourceLine)
+            if (!shouldTrustInvocationDetails) {
+              resolvedLine = resolveSourceLineForTest(
+                testSuiteAbsolutePath,
+                testItTitle,
+                testSourceStack
+              ) ?? testSourceLine
+            }
+          }
+          this.activeTestSpan.setTag(TEST_SOURCE_START, resolvedLine)
         }
         if (isNew) {
           this.activeTestSpan.setTag(TEST_IS_NEW, 'true')

package/packages/datadog-plugin-cypress/src/source-map-utils.js

@@ -0,0 +1,297 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+// Base64 lookup table for source map VLQ decoding
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+const BASE64_DECODE = new Uint8Array(128)
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+  BASE64_DECODE[BASE64_CHARS.charCodeAt(i)] = i
+}
+const TEST_DECLARATION_RE = /(?:it|test|specify)\s*\(\s*(?:'((?:[^'\\]|\\.)*)'|"((?:[^"\\]|\\.)*)"|`((?:[^`\\]|\\[\s\S])*)`)\s*,/g
+const SOURCE_MAP_CACHE = new Map()
+
+/**
+ * Whether a file path references JavaScript.
+ * @param {string} absoluteFilePath
+ * @returns {boolean}
+ */
+function isJavaScriptFile (absoluteFilePath) {
+  return absoluteFilePath.endsWith('.js') || absoluteFilePath.endsWith('.cjs') || absoluteFilePath.endsWith('.mjs')
+}
+
+/**
+ * Decide whether invocationDetails line can be trusted as final source line.
+ * @param {string} absoluteFilePath
+ * @param {number} testSourceLine
+ * @returns {boolean}
+ */
+function shouldTrustInvocationDetailsLine (absoluteFilePath, testSourceLine) {
+  if (!Number.isInteger(testSourceLine) || testSourceLine < 1) return false
+  if (!isJavaScriptFile(absoluteFilePath)) return false
+
+  return getCachedSourceMap(absoluteFilePath) === null
+}
+
+/**
+ * Decode one VLQ-encoded integer from `str` at `cursor.pos`, advancing the cursor in place.
+ * @param {string} str
+ * @param {{ pos: number }} cursor
+ * @returns {number}
+ */
+function decodeVLQ (str, cursor) {
+  let result = 0
+  let shift = 0
+  let digit
+  do {
+    digit = BASE64_DECODE[str.charCodeAt(cursor.pos++)]
+    result |= (digit & 0x1F) << shift
+    shift += 5
+  } while (digit & 0x20)
+  return (result & 1) ? -(result >>> 1) : result >>> 1
+}
+
+/**
+ * Resolve a source path from a source map entry to an absolute file path.
+ * Handles regular relative paths and virtual URL-like source paths.
+ * @param {string} mapDir - Directory of the source map (or the file containing the inline source map)
+ * @param {string} sourceRoot - The `sourceRoot` field from the source map
+ * @param {string} sourcePath - A single entry from the source map's `sources` array
+ * @returns {string | null}
+ */
+function resolveSourcePath (mapDir, sourceRoot, sourcePath) {
+  const cleanSourcePath = sourcePath.replace(/[?#].*$/, '')
+  if (/^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(cleanSourcePath)) {
+    // Virtual sources may use URL-like schemes (e.g. file://, webpack://, vite://).
+    // If they encode an absolute local path in the URL pathname, use it.
+    try {
+      const pathname = new URL(cleanSourcePath).pathname
+      return pathname && path.isAbsolute(pathname) ? pathname : null
+    } catch {
+      return null
+    }
+  }
+  if (sourceRoot && /^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(sourceRoot)) {
+    // URL-like sourceRoot values are virtual; resolve relative entries from mapDir.
+    return path.resolve(mapDir, sourcePath)
+  }
+  return path.resolve(mapDir, sourceRoot || '', sourcePath)
+}
+
+/**
+ * Read a source map for a file. Tries:
+ *  1. An adjacent `.map` file (`absoluteFilePath + '.map'`)
+ *  2. An inline `data:` URI in the file's last line (`//# sourceMappingURL=data:…`)
+ * Returns null when neither source is available or parseable.
+ * @param {string} absoluteFilePath
+ * @returns {object | null}
+ */
+function readSourceMap (absoluteFilePath) {
+  try {
+    return JSON.parse(fs.readFileSync(absoluteFilePath + '.map', 'utf8'))
+  } catch {}
+  try {
+    const content = fs.readFileSync(absoluteFilePath, 'utf8')
+    const match = content.match(
+      /\/\/# sourceMappingURL=data:application\/json;(?:charset=utf-8;)?base64,([\w+/=\s]+)/
+    )
+    if (match) {
+      return JSON.parse(Buffer.from(match[1].replaceAll(/\s/g, ''), 'base64').toString('utf8'))
+    }
+  } catch {}
+  return null
+}
+
+/**
+ * Read and cache source maps per file path. Cache stores parse result or null.
+ * @param {string} absoluteFilePath
+ * @returns {object | null}
+ */
+function getCachedSourceMap (absoluteFilePath) {
+  if (SOURCE_MAP_CACHE.has(absoluteFilePath)) {
+    return SOURCE_MAP_CACHE.get(absoluteFilePath)
+  }
+  const sourceMap = readSourceMap(absoluteFilePath)
+  SOURCE_MAP_CACHE.set(absoluteFilePath, sourceMap)
+  return sourceMap
+}
+
+/**
+ * Given a generated file's absolute path and a generated line number, returns the
+ * original source file path and line by reading the adjacent .map file or an inline
+ * source map embedded in the file. Returns null when no source map is found or the
+ * mapping cannot be resolved.
+ * @param {string} absoluteFilePath - Absolute path to the generated (compiled or bundled) file
+ * @param {number} generatedLine - 1-indexed line number in the generated file
+ * @returns {{ sourceFile: string, line: number } | null}
+ */
+function resolveOriginalSourcePosition (absoluteFilePath, generatedLine) {
+  const sourceMap = getCachedSourceMap(absoluteFilePath)
+  if (!sourceMap) return null
+  const { mappings, sources, sourceRoot } = sourceMap
+  if (!mappings || !sources?.length) return null
+
+  const mapDir = path.dirname(absoluteFilePath)
+  const cursor = { pos: 0 }
+  let srcFile = 0
+  let srcLine = 0
+
+  const lines = mappings.split(';')
+  for (let li = 0; li < lines.length; li++) {
+    const line = lines[li]
+    if (!line) continue
+    cursor.pos = 0
+    while (cursor.pos < line.length) {
+      decodeVLQ(line, cursor) // genCol — not needed
+      if (cursor.pos < line.length && line[cursor.pos] !== ',') {
+        // Segment has source info: srcFileIndex (delta), srcLine (delta), srcCol, [namesIndex]
+        srcFile += decodeVLQ(line, cursor)
+        srcLine += decodeVLQ(line, cursor)
+        decodeVLQ(line, cursor) // srcCol — not needed
+        if (cursor.pos < line.length && line[cursor.pos] !== ',') {
+          decodeVLQ(line, cursor) // namesIndex — not needed
+        }
+        if (li === generatedLine - 1) {
+          const sourcePath = sources[srcFile]
+          if (!sourcePath) return null
+          const sourceFile = resolveSourcePath(mapDir, sourceRoot, sourcePath)
+          return sourceFile ? { sourceFile, line: srcLine + 1 } : null
+        }
+      }
+      if (cursor.pos < line.length && line[cursor.pos] === ',') cursor.pos++
+    }
+  }
+  return null
+}
+
+/**
+ * Convert a template literal body (the text between backticks, with `${…}` interpolations)
+ * into a regex that matches the runtime-evaluated string. Each `${…}` expression is replaced
+ * with `.*?` so the pattern matches whatever value the expression produced at runtime.
+ * @param {string} templateBody - Raw template literal content (the text between the backticks)
+ * @returns {RegExp}
+ */
+function templateBodyToRegExp (templateBody) {
+  // Split on ${...} expressions, escaping the literal parts and replacing interpolations
+  // with .*? wildcards. We handle basic nesting of braces inside ${} to avoid false splits.
+  let pattern = ''
+  let i = 0
+  while (i < templateBody.length) {
+    const dollarIdx = templateBody.indexOf('${', i)
+    if (dollarIdx === -1) {
+      pattern += templateBody.slice(i).replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+      break
+    }
+    pattern += templateBody.slice(i, dollarIdx).replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+    pattern += '.*?'
+    // skip past the matching closing brace, counting nested braces
+    let depth = 1
+    i = dollarIdx + 2
+    while (i < templateBody.length && depth > 0) {
+      if (templateBody[i] === '{') depth++
+      else if (templateBody[i] === '}') depth--
+      i++
+    }
+  }
+  return new RegExp(`^${pattern}$`)
+}
+
+/**
+ * Count 1-indexed line number for a character index in `content`.
+ * @param {string} content
+ * @param {number} endIndex
+ * @returns {number}
+ */
+function lineNumberForIndex (content, endIndex) {
+  let line = 1
+  for (let i = 0; i < endIndex; i++) {
+    if (content.charCodeAt(i) === 10) line++
+  }
+  return line
+}
+
+/**
+ * Extract the first stack frame line number from an invocation stack.
+ * Supports Chromium-style ("at fn (file:line:col)") and Firefox-style ("fn@file:line:col").
+ * @param {string} stack
+ * @returns {number | null}
+ */
+function firstGeneratedLineFromStack (stack) {
+  if (typeof stack !== 'string' || stack.length === 0) return null
+  const lines = stack.split('\n')
+  for (const line of lines) {
+    const match = line.match(/:(\d+):\d+\)?\s*$/)
+    if (match) {
+      const parsed = Number(match[1])
+      if (Number.isInteger(parsed) && parsed > 0) {
+        return parsed
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Find the declaration line for a test name by scanning it()/test()/specify() calls.
+ * For template literals, `${...}` placeholders are fuzzy-matched against runtime values.
+ * @param {string} content
+ * @param {string} testName
+ * @returns {number | null}
+ */
+function findTestDeclarationLine (content, testName) {
+  TEST_DECLARATION_RE.lastIndex = 0
+  let match
+  while ((match = TEST_DECLARATION_RE.exec(content)) !== null) {
+    const singleQuoted = match[1]
+    const doubleQuoted = match[2]
+    const templateQuoted = match[3]
+    const isTemplate = templateQuoted !== undefined
+    const candidateName = singleQuoted ?? doubleQuoted ?? templateQuoted
+    if (!candidateName) continue
+
+    const doesMatch = isTemplate
+      ? templateBodyToRegExp(candidateName).test(testName)
+      : candidateName === testName
+    if (doesMatch) {
+      return lineNumberForIndex(content, match.index)
+    }
+  }
+  return null
+}
+
+/**
+ * Find the original source line for a test.
+ * It first tries mapping a generated line extracted from invocation stack.
+ * If that fails, it scans declaration name and maps the matched generated line
+ * through a source map when available.
+ * For `.ts` specs, the matched line is already the source line.
+ * @param {string} absoluteFilePath - Absolute path to the spec file (compiled JS or .ts)
+ * @param {string} testName - The test name passed to `it()`, `test()`, or `specify()`
+ * @param {string} invocationStack - Raw invocationDetails stack for the test
+ * @returns {number | null} The resolved source line (1-indexed), or null
+ */
+function resolveSourceLineForTest (absoluteFilePath, testName, invocationStack) {
+  const generatedLineFromStack = firstGeneratedLineFromStack(invocationStack)
+  if (generatedLineFromStack && !absoluteFilePath.endsWith('.ts')) {
+    const stackResolved = resolveOriginalSourcePosition(absoluteFilePath, generatedLineFromStack)
+    if (stackResolved) return stackResolved.line
+  }
+
+  let content
+  try {
+    content = fs.readFileSync(absoluteFilePath, 'utf8')
+  } catch {
+    return null
+  }
+
+  const foundLine = findTestDeclarationLine(content, testName)
+  if (!foundLine) return null
+
+  if (absoluteFilePath.endsWith('.ts')) return foundLine
+  const resolved = resolveOriginalSourcePosition(absoluteFilePath, foundLine)
+  if (resolved) return resolved.line
+  return null
+}
+
+module.exports = { resolveOriginalSourcePosition, resolveSourceLineForTest, shouldTrustInvocationDetailsLine }