dd-trace 6.14.0 → 6.16.0

package/packages/datadog-instrumentations/src/helpers/instrumentation-utils.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const { builtinModules } = require('node:module')
+
+const satisfies = require('../../../../vendor/dist/semifies')
+const { getValueFromEnvSources } = require('../../../dd-trace/src/config/helper')
+const { isRelativeRequire } = require('./shared-utils')
+
+/**
+ * @param {string|undefined} version
+ * @param {string[]|undefined} ranges
+ * @returns {boolean}
+ */
+function matchVersion (version, ranges) {
+  return !version || !ranges || ranges.some(range => satisfies(version, range))
+}
+
+/**
+ * @param {string} name
+ * @param {string} [file]
+ * @returns {string}
+ */
+function filename (name, file) {
+  return file ? `${name}/${file}` : name
+}
+
+/**
+ * @param {string} name
+ * @param {string|undefined} version
+ * @param {string} moduleName
+ * @param {{ file?: string, filePattern?: string, versions?: string[] }} instrumentation
+ * @returns {boolean}
+ */
+function matchesInstrumentation (name, version, moduleName, instrumentation) {
+  const { file, filePattern, versions } = instrumentation
+  let matchesFile = moduleName === filename(name, file)
+  if (!matchesFile && isRelativeRequire(name)) matchesFile = true
+  if (!matchesFile && filePattern) {
+    matchesFile = new RegExp(filename(name, filePattern)).test(moduleName)
+  }
+  return matchesFile && matchVersion(version, versions)
+}
+
+/**
+ * @returns {Set<string>}
+ */
+function getDisabledInstrumentations () {
+  const disabled = new Set(
+    getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',').filter(Boolean)
+  )
+  if (disabled.size === 0) return disabled
+
+  const expanded = new Set(disabled)
+  const builtins = new Set(builtinModules)
+
+  for (const name of disabled) {
+    const prefixed = name.startsWith('node:')
+    if (!prefixed && !builtins.has(name)) continue
+
+    const counterpart = prefixed ? name.slice(5) : `node:${name}`
+    expanded.add(counterpart)
+  }
+
+  return expanded
+}
+
+module.exports = {
+  filename,
+  getDisabledInstrumentations,
+  matchesInstrumentation,
+  matchVersion,
+}

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -1,20 +1,20 @@
 'use strict'
 
-const { builtinModules } = require('module')
 const path = require('path')
 const { channel } = require('dc-polyfill')
-const satisfies = require('../../../../vendor/dist/semifies')
 const log = require('../../../dd-trace/src/log')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { IS_SERVERLESS } = require('../../../dd-trace/src/serverless')
 const { getValueFromEnvSources } = require('../../../dd-trace/src/config/helper')
 const checkRequireCache = require('./check-require-cache')
 const Hook = require('./hook')
-const { isRelativeRequire } = require('./shared-utils')
+const {
+  filename,
+  getDisabledInstrumentations,
+  matchesInstrumentation,
+} = require('./instrumentation-utils')
 const rewriter = require('./rewriter')
 
-const DD_TRACE_DISABLED_INSTRUMENTATIONS =
-  getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')
 const DD_TRACE_DEBUG = getValueFromEnvSources('DD_TRACE_DEBUG')
 
 const hooks = require('./hooks')
@@ -22,9 +22,7 @@ const instrumentations = require('./instrumentations')
 const names = Object.keys(hooks)
 const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
 
-const disabledInstrumentations = new Set(
-  DD_TRACE_DISABLED_INSTRUMENTATIONS?.split(',')
-)
+const disabledInstrumentations = getDisabledInstrumentations()
 
 const loadChannel = channel('dd-trace:instrumentation:load')
 
@@ -54,29 +52,6 @@ const instrumentedIntegrationsSuccess = new Map()
 /** @type {Set<string>} */
 const alreadyLoggedIncompatibleIntegrations = new Set()
 
-// Always disable prefixed and unprefixed node modules if one is disabled.
-if (disabledInstrumentations.size) {
-  const builtinsSet = new Set(builtinModules)
-  const disabledBuiltinCounterparts = []
-  for (const name of disabledInstrumentations) {
-    const hasPrefix = name.startsWith('node:')
-    if (hasPrefix || builtinsSet.has(name)) {
-      if (hasPrefix) {
-        const unprefixedName = name.slice(5)
-        if (!disabledInstrumentations.has(unprefixedName)) {
-          disabledBuiltinCounterparts.push(unprefixedName)
-        }
-      } else if (!disabledInstrumentations.has(`node:${name}`)) {
-        disabledBuiltinCounterparts.push(`node:${name}`)
-      }
-    }
-  }
-  for (const name of disabledBuiltinCounterparts) {
-    disabledInstrumentations.add(name)
-  }
-  builtinsSet.clear()
-}
-
 for (const name of names) {
   if (disabledInstrumentations.has(name)) continue
 
@@ -111,21 +86,9 @@ for (const name of names) {
       instrumentedNodeModules.set(name, moduleExports)
     }
 
-    for (const { file, versions, hook, filePattern, patchDefault } of instrumentations[name]) {
-      const fullFilename = filename(name, file)
-
-      let matchesFile = moduleName === fullFilename
-
-      if (!matchesFile && isRelativeRequire(name)) matchesFile = true
-
-      const fullFilePattern = filePattern && filename(name, filePattern)
-      if (fullFilePattern) {
-        // Some libraries include a hash in their filenames when installed,
-        // so our instrumentation has to include a '.*' to match them for more than a single version.
-        matchesFile ||= new RegExp(fullFilePattern).test(moduleName)
-      }
-
-      if (matchesFile && matchVersion(moduleVersion, versions)) {
+    for (const instrumentation of instrumentations[name]) {
+      if (matchesInstrumentation(name, moduleVersion, moduleName, instrumentation)) {
+        const { hook, patchDefault } = instrumentation
         // IITM invokes this callback for every module in the package. Only unwrap the namespace after its file and
         // version match, otherwise a default export from an unrelated internal module can replace that module.
         if (isIitm && patchDefault === !!moduleExports.default) {
@@ -188,26 +151,8 @@ function logAbortedIntegrations () {
   instrumentedIntegrationsSuccess.clear()
 }
 
-/**
- * @param {string|undefined} version
- * @param {string[]|undefined} ranges
- */
-function matchVersion (version, ranges) {
-  return !version || !ranges || ranges.some(range => satisfies(version, range))
-}
-
-/**
- * @param {string} name
- * @param {string} [file]
- * @returns {string}
- */
-function filename (name, file) {
-  return file ? `${name}/${file}` : name
-}
-
 module.exports = {
   filename,
   pathSepExpr,
   loadChannel,
-  matchVersion,
 }

package/packages/datadog-instrumentations/src/helpers/rewriter/index.js

@@ -1,8 +1,9 @@
 'use strict'
 
-const { readFileSync } = require('fs')
-const { join } = require('path')
-const { pathToFileURL } = require('url')
+const { readFileSync } = require('node:fs')
+const { join } = require('node:path')
+const { pathToFileURL } = require('node:url')
+
 const log = require('../../../../dd-trace/src/log')
 const instrumentations = require('./instrumentations')
 const { getRewriteTarget } = require('./targets')
@@ -13,7 +14,12 @@ const { getRewriteTarget } = require('./targets')
  * @property {(moduleName: string, version: string|undefined, filePath: string) => Transformer|undefined} getTransformer
  *
  * @typedef {object} Transformer
- * @property {(source: string, moduleType: 'cjs'|'esm') => { code: string, map?: string }} transform
+ * @property {(source: string, moduleType: 'cjs'|'esm', sourceMap?: string|object) =>
+ *   { code: string, map?: string|object }} transform
+ *
+ * @typedef {(content: string|Buffer|ArrayBuffer|Uint8Array, filename: string, format?: string,
+ *   target?: { moduleName: string, filePath: string }, sourceMap?: string|object) =>
+ *   { code: string|Buffer|ArrayBuffer|Uint8Array, map?: string|object }} BundlerRewriter
  */
 
 /**
@@ -79,46 +85,71 @@ function rewrite (content, filename, format, target) {
   return content
 }
 
+/**
+ * @param {string} dcModule
+ * @returns {BundlerRewriter}
+ */
+function createBundlerRewriter (dcModule) {
+  const matcher = createMatcher(dcModule)
+
+  return function rewriteBundled (content, filename, format, target, sourceMap) {
+    if (!content) return { code: content, map: sourceMap }
+
+    target ||= getRewriteTarget(filename)
+    if (!target) return { code: content, map: sourceMap }
+
+    filename = filename.replace('file://', '')
+    const moduleType = format === 'module' ? 'esm' : 'cjs'
+    const { moduleName, filePath } = target
+    const transformer = matcher.getTransformer(moduleName, getVersion(filename, filePath), filePath)
+    if (!transformer) return { code: content, map: sourceMap }
+
+    try {
+      return transformer.transform(getSourceText(content), moduleType, sourceMap)
+    } catch (error) {
+      log.error(error)
+      return { code: content, map: sourceMap }
+    }
+  }
+}
+
 /**
  * @param {'cjs'|'esm'} moduleType
  * @returns {InstrumentationMatcher}
  */
 function getMatcher (moduleType) {
   if (moduleType === 'esm') {
-    matcherEsm ??= createMatcher(moduleType)
+    matcherEsm ??= createMatcher(getDcPolyfillSpecifier(moduleType))
 
     return matcherEsm
   }
 
-  matcherCjs ??= createMatcher(moduleType)
+  matcherCjs ??= createMatcher(getDcPolyfillSpecifier(moduleType))
 
   return matcherCjs
 }
 
 /**
- * @param {'cjs'|'esm'} moduleType
+ * @param {string|undefined} dcModule
  * @returns {InstrumentationMatcher}
  */
-function createMatcher (moduleType) {
+function createMatcher (dcModule) {
   const { create } = require('../../../../../vendor/dist/@apm-js-collab/code-transformer')
   const {
     awaitContextCallback,
-    awaitContextCallbackAtFunctionStart,
-    awaitContextCallbackAtTryStart,
     configureGraphqlFastPath,
     configureGraphqlJitCompileObject,
     configureGraphqlJitDeferredField,
     configureGraphqlJitExecute,
     configureGraphqlJitRuntime,
     configureMercuriusRequest,
+    publishDurableOrchestrationFailure,
     waitForAsyncEnd,
   } = require('./transforms')
 
-  const matcher = create(instrumentations, getDcPolyfillSpecifier(moduleType))
+  const matcher = create(instrumentations, dcModule)
 
   matcher.addTransform('awaitContextCallback', awaitContextCallback)
-  matcher.addTransform('awaitContextCallbackAtFunctionStart', awaitContextCallbackAtFunctionStart)
-  matcher.addTransform('awaitContextCallbackAtTryStart', awaitContextCallbackAtTryStart)
   matcher.addTransform('waitForAsyncEnd', waitForAsyncEnd)
   matcher.addTransform('configureGraphqlFastPath', configureGraphqlFastPath)
   matcher.addTransform('configureGraphqlJitCompileObject', configureGraphqlJitCompileObject)
@@ -126,6 +157,7 @@ function createMatcher (moduleType) {
   matcher.addTransform('configureGraphqlJitExecute', configureGraphqlJitExecute)
   matcher.addTransform('configureGraphqlJitRuntime', configureGraphqlJitRuntime)
   matcher.addTransform('configureMercuriusRequest', configureMercuriusRequest)
+  matcher.addTransform('publishDurableOrchestrationFailure', publishDurableOrchestrationFailure)
 
   return matcher
 }
@@ -189,4 +221,4 @@ function getVersion (filename, filePath) {
   return moduleVersions[basename]
 }
 
-module.exports = { rewrite, disable }
+module.exports = { createBundlerRewriter, disable, rewrite }

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/azure-durable-functions.js

@@ -0,0 +1,17 @@
+'use strict'
+
+module.exports = [
+  {
+    module: {
+      name: 'durable-functions',
+      versionRange: '>=3 <4',
+      filePath: 'lib/src/orchestrations/TaskOrchestrationExecutor.js',
+    },
+    functionQuery: {
+      className: 'TaskOrchestrationExecutor',
+      methodName: 'execute',
+    },
+    transform: 'publishDurableOrchestrationFailure',
+    channelName: 'TaskOrchestrationExecutor_failure',
+  },
+]

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/index.js

@@ -3,6 +3,7 @@
 module.exports = [
   ...require('./ai'),
   ...require('./azure-cosmos'),
+  ...require('./azure-durable-functions'),
   ...require('./bullmq'),
   ...require('./claude-agent-sdk'),
   ...require('./graphql'),

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/playwright.js

@@ -99,11 +99,7 @@ module.exports = [
       versionRange: '>=1.60.0',
       filePath: 'lib/coreBundle.js',
     },
-    astQuery: 'AssignmentExpression[left.name="Page2"] > ClassExpression > ClassBody > ' +
-      'MethodDefinition[kind="method"][key.name="goto"] > FunctionExpression[async], ' +
-      'VariableDeclarator[id.name="Page2"] > ClassExpression > ClassBody > ' +
-      'MethodDefinition[kind="method"][key.name="goto"] > FunctionExpression[async], ' +
-      'ClassDeclaration[id.name="Page2"] > ClassBody > ' +
+    astQuery: 'ClassExpression[id.name="_Page"] > ClassBody > ' +
       'MethodDefinition[kind="method"][key.name="goto"] > FunctionExpression[async]',
     functionQuery: {
       methodName: 'goto',

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/webdriverio.js

@@ -428,9 +428,9 @@ module.exports = [
       versionRange: '>=9.0.0',
       filePath: 'build/index.js',
     },
-    astQuery: 'VariableDeclarator[id.name="testFrameworkFnWrapper"] > FunctionExpression TryStatement',
+    astQuery: 'VariableDeclarator[id.name="testFrameworkFnWrapper"] > FunctionExpression',
     channelName: 'testFrameworkFnWrapper',
-    transform: 'awaitContextCallbackAtFunctionStart',
+    transform: 'awaitContextCallback',
     transformOptions: {
       callbackName: 'rumCleanupCallback',
     },
@@ -453,12 +453,11 @@ module.exports = [
       versionRange: '>=9.0.0',
       filePath: 'build/index.js',
     },
-    astQuery: 'FunctionDeclaration[id.name="executeAsync"] CatchClause ' +
-      'IfStatement[test.operator=">"][test.left.object.name="retries"]' +
-      '[test.left.property.name="limit"][test.right.object.name="retries"]' +
-      '[test.right.property.name="attempts"]',
+    astQuery: 'TryStatement:has(CatchClause IfStatement[test.operator=">"]' +
+      '[test.left.object.name="retries"][test.left.property.name="limit"]' +
+      '[test.right.object.name="retries"][test.right.property.name="attempts"]) > BlockStatement',
     channelName: 'executeAsync',
-    transform: 'awaitContextCallbackAtTryStart',
+    transform: 'awaitContextCallback',
     transformOptions: {
       callbackName: 'rumStartCallback',
     },

package/packages/datadog-instrumentations/src/helpers/rewriter/targets.json

@@ -43,6 +43,7 @@
   "bullmq/dist/esm/classes/flow-producer.js": "bullmq",
   "bullmq/dist/esm/classes/queue.js": "bullmq",
   "bullmq/dist/esm/classes/worker.js": "bullmq",
+  "durable-functions/lib/src/orchestrations/TaskOrchestrationExecutor.js": "durable-functions",
   "graphql-jit/dist/cjs/execution.js": "graphql-jit",
   "graphql-jit/dist/esm/execution.js": "graphql-jit",
   "graphql-jit/dist/execution.js": "graphql-jit",

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -20,67 +20,77 @@ const identifierPattern = /^[$A-Z_a-z][$\w]*$/
 
 module.exports = {
   awaitContextCallback,
-  awaitContextCallbackAtFunctionStart,
-  awaitContextCallbackAtTryStart,
   configureGraphqlJitCompileObject,
   configureGraphqlJitDeferredField,
   configureGraphqlJitExecute,
   configureGraphqlJitRuntime,
   configureGraphqlFastPath,
   configureMercuriusRequest,
+  publishDurableOrchestrationFailure,
   waitForAsyncEnd,
 }
 
 /**
- * Awaits an optional context callback at the start of the matched node's enclosing async function.
+ * Publishes the error captured by Durable Functions immediately before its
+ * executor converts that error into a serialized failed orchestration state.
  *
- * @param {Parameters<typeof awaitContextCallback>[0]} state
- * @param {import('estree').Node} node
+ * @param {{
+ *   channelName: string,
+ *   transforms: { tracingChannelDeclaration: Function }
+ * }} state
+ * @param {import('estree').FunctionExpression} node
  * @param {import('estree').Node} _parent
  * @param {import('estree').Node[]} ancestry
  * @returns {void}
  */
-function awaitContextCallbackAtFunctionStart (state, node, _parent, ancestry) {
-  let enclosingFunction = functionTypes.has(node.type)
-    ? node
-    : ancestry.find(ancestor => functionTypes.has(ancestor.type))
-  let callbackAncestry = ancestry
-
-  if (enclosingFunction === node) {
-    callbackAncestry = [node, ...ancestry]
-    if (!node.async) {
-      // Function queries create a synchronous trace wrapper before custom transforms run.
-      const [wrappedFunction] = query(node,
-        'VariableDeclarator[id.name="__apm$traced"] > ArrowFunctionExpression > BlockStatement > ' +
-        'VariableDeclaration > VariableDeclarator[id.name="__apm$wrapped"] > ' +
-        ':matches(FunctionDeclaration, FunctionExpression)[async=true]')
-      if (wrappedFunction) {
-        enclosingFunction = wrappedFunction
-        callbackAncestry.unshift(wrappedFunction)
-      }
-    }
-  }
-  assert(enclosingFunction?.async && enclosingFunction.body?.type === 'BlockStatement',
-    'awaitContextCallbackAtFunctionStart: expected an enclosing async function with a block body')
+function publishDurableOrchestrationFailure (state, node, _parent, ancestry) {
+  // Class queries also visit the owning ClassDeclaration so Orchestrion can
+  // synthesize missing methods. This transform targets the concrete method only.
+  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') return
+
+  const failureBranches = query(node, 'IfStatement').filter(({ test }) =>
+    test.type === 'BinaryExpression' &&
+    test.operator === '!==' &&
+    test.left?.type === 'MemberExpression' &&
+    test.left.object?.type === 'ThisExpression' &&
+    test.left.property?.name === 'exception' &&
+    test.right?.type === 'Identifier' &&
+    test.right.name === 'undefined'
+  )
 
-  const generatedCallback = createAwaitedContextCallback(
-    state,
-    enclosingFunction.body,
-    callbackAncestry,
-    'awaitContextCallbackAtFunctionStart'
+  assert.strictEqual(
+    failureBranches.length,
+    1,
+    'publishDurableOrchestrationFailure: executor failure branch not found'
   )
-  if (!generatedCallback) return
+  assert.strictEqual(
+    failureBranches[0].consequent.type,
+    'BlockStatement',
+    'publishDurableOrchestrationFailure: expected a block failure branch'
+  )
+
+  const program = ancestry.at(-1)
+  state.transforms.tracingChannelDeclaration(state, program)
 
-  let insertionIndex = 0
-  while (typeof enclosingFunction.body.body[insertionIndex]?.directive === 'string') insertionIndex++
-  enclosingFunction.body.body.splice(insertionIndex, 0, ...generatedCallback.callbackStatements)
+  const channelVariable = `tr_ch_apm$${state.channelName.replaceAll(/[^\w]/g, '_')}`
+  const publishStatements = parse(`
+    if (${channelVariable}.end.hasSubscribers) {
+      ${channelVariable}.end.publish({
+        arguments: [context, history],
+        error: this.exception
+      })
+    }
+  `).body
+
+  failureBranches[0].consequent.body.unshift(...publishStatements)
 }
 
 /**
- * Awaits an optional context callback before continuing through a matched conditional branch.
+ * Awaits an optional context callback at the start of a matched function or block, or before continuing through a
+ * matched conditional branch.
  *
- * The branch condition is checked again after the callback settles so the
- * original body does not run against state that changed while awaiting.
+ * A matched conditional branch is checked again after the callback settles so its original body does not run
+ * against state that changed while awaiting.
  *
  * @param {{
  *   transformOptions?: {
@@ -89,14 +99,62 @@ function awaitContextCallbackAtFunctionStart (state, node, _parent, ancestry) {
  *     callbackThis?: boolean
  *   }
  * }} state
- * @param {import('estree').IfStatement} node
+ * @param {
+ *   import('estree').ArrowFunctionExpression|
+ *   import('estree').BlockStatement|
+ *   import('estree').FunctionDeclaration|
+ *   import('estree').FunctionExpression|
+ *   import('estree').IfStatement
+ * } node
  * @param {import('estree').Node} _parent
  * @param {import('estree').Node[]} ancestry
  * @returns {void}
  */
 function awaitContextCallback (state, node, _parent, ancestry) {
+  let insertionTarget
+  let callbackAncestry = ancestry
+
+  if (node.type === 'BlockStatement') {
+    insertionTarget = node
+  } else if (functionTypes.has(node.type)) {
+    let callbackFunction = node
+    callbackAncestry = [node, ...ancestry]
+
+    if (!node.async) {
+      // Built-in function transforms run before later custom transforms. Keep knowledge of their generated wrapper
+      // here so instrumentation queries can continue to target the original function.
+      const [wrappedFunction] = query(node,
+        'VariableDeclarator[id.name="__apm$traced"] > ArrowFunctionExpression > BlockStatement > ' +
+        'VariableDeclaration > VariableDeclarator[id.name="__apm$wrapped"] > ' +
+        ':matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression)[async=true]')
+      if (wrappedFunction) {
+        callbackFunction = wrappedFunction
+        callbackAncestry.unshift(wrappedFunction)
+      }
+    }
+
+    assert(callbackFunction.async && callbackFunction.body?.type === 'BlockStatement',
+      'awaitContextCallback: expected an async function with a block body')
+    insertionTarget = callbackFunction.body
+  }
+
+  if (insertionTarget) {
+    const generatedCallback = createAwaitedContextCallback(
+      state,
+      insertionTarget,
+      callbackAncestry,
+      'awaitContextCallback'
+    )
+    if (!generatedCallback) return
+
+    let insertionIndex = 0
+    while (typeof insertionTarget.body[insertionIndex]?.directive === 'string') insertionIndex++
+    insertionTarget.body.splice(insertionIndex, 0, ...generatedCallback.callbackStatements)
+    return
+  }
+
   assert(node.type === 'IfStatement' && node.consequent?.type === 'BlockStatement',
-    'awaitContextCallback: expected an if statement with a block body')
+    'awaitContextCallback: expected a function, a block, or an if statement with a block body')
 
   const originalStatements = node.consequent.body
   const generatedCallback = createAwaitedContextCallback(
@@ -121,35 +179,6 @@ function awaitContextCallback (state, node, _parent, ancestry) {
   node.consequent.body = [...callbackStatements, callbackBranch]
 }
 
-/**
- * Awaits an optional context callback before entering the matched node's enclosing try block.
- *
- * @param {Parameters<typeof awaitContextCallback>[0]} state
- * @param {import('estree').Node} node
- * @param {import('estree').Node} _parent
- * @param {import('estree').Node[]} ancestry
- * @returns {void}
- */
-function awaitContextCallbackAtTryStart (state, node, _parent, ancestry) {
-  let tryStatement = node.type === 'TryStatement' ? node : undefined
-  for (const ancestor of ancestry) {
-    if (tryStatement || functionTypes.has(ancestor.type)) break
-    if (ancestor.type === 'TryStatement') tryStatement = ancestor
-  }
-  assert(tryStatement?.block?.type === 'BlockStatement',
-    'awaitContextCallbackAtTryStart: expected an enclosing try statement with a block body')
-
-  const generatedCallback = createAwaitedContextCallback(
-    state,
-    tryStatement.block,
-    ancestry,
-    'awaitContextCallbackAtTryStart'
-  )
-  if (!generatedCallback) return
-
-  tryStatement.block.body.unshift(...generatedCallback.callbackStatements)
-}
-
 /**
  * @param {Parameters<typeof awaitContextCallback>[0]} state
  * @param {import('estree').BlockStatement} insertionTarget