@openclaw/diagnostics-otel 2026.7.2-beta.3 → 2026.7.2-beta.5

package/node_modules/import-in-the-middle/lib/get-esm-exports.mjs

@@ -1,116 +1,151 @@
 'use strict'
 
-import { Parser } from 'acorn'
-import { importAttributesOrAssertions } from 'acorn-import-attributes'
+import { readFileSync } from 'fs'
+import { createRequire, Module } from 'module'
+import { initSync, parse as parseWasm } from 'es-module-lexer'
 
-const acornOpts = {
-  ecmaVersion: 'latest',
-  sourceType: 'module'
-}
+const require = createRequire(import.meta.url)
+
+// The default es-module-lexer build is WebAssembly backed and decodes string
+// literals (import specifiers, quoted export names) with an internal `eval`.
+// Under `--disallow-code-generation-from-strings` that `eval` silently no-ops,
+// so specifiers and quoted names come back undecoded (`* from undefined`,
+// `"string name"` with the quotes still attached). The eval-free asm.js build
+// (`es-module-lexer/js`) does the same work, so fall back to it when code
+// generation from strings is disallowed. Resolve the parser once at load time
+// so the per-module path stays a bare `parse(source)` call.
+const flag = '--disallow-code-generation-from-strings'
+// Node.js versions with broken maglev compiler
+const hasBrokenMaglev = process.version.startsWith('v20.') &&
+  process.version[5] === '.' &&
+  Number(process.version[4]) < 9
+const disallowCodegen = process.execArgv.includes(flag) ||
+  (process.env.NODE_OPTIONS?.includes(flag) ?? false) ||
+  hasBrokenMaglev
 
-const parser = Parser.extend(importAttributesOrAssertions)
+// initSync compiles the Wasm module up front so `parse` can run inside
+// synchronous loader hooks (`module.registerHooks`) as well as the off-thread
+// loader; it is a one-time cost on the first ESM module either way. It stays the
+// default and remains callable even under the flag, so a parse before the asm.js
+// swap still works (with the flag's known specifier-decoding limitation) rather
+// than throwing.
+initSync()
 
-function warn (txt) {
-  process.emitWarning(txt, 'get-esm-exports')
+let parse = parseWasm
+
+if (disallowCodegen) {
+  parse = loadAsmParse()
 }
 
 /**
- * Utilizes an AST parser to interpret ESM source code and build a list of
- * exported identifiers. In the baseline case, the list of identifiers will be
- * the simple identifier names as written in the source code of the module.
- * However, there is a special case:
+ * Loads the eval-free asm.js parser synchronously, on every Node version.
  *
- * When an `export * from './foo.js'` line is encountered it is rewritten
- * as `* from ./foo.js`. This allows the interpreting code to recognize a
- * transitive export and recursively parse the indicated module. The returned
- * identifier list will have "* from ./foo.js" as an item.
+ * The asm.js build (`es-module-lexer/js`) is ESM-only with no CommonJS variant,
+ * and its only export is a top-level `parse` (no async wasm `init` to await).
+ * `require`-ing it is not portable: before require(esm) (Node < 20.19 / < 22.12)
+ * it throws `ERR_REQUIRE_ESM`, and `import()`-ing it from inside a loader hook
+ * deadlocks the loader on itself. Compiling the source as CommonJS sidesteps
+ * both: it runs synchronously, keeps this module require()-able for the
+ * synchronous `module.registerHooks` path, and never re-enters the ESM loader.
  *
- * @param {object} params
- * @param {string} params.moduleSource The source code of the module to parse
- * and interpret.
+ * `Module._compile` uses V8's script compiler, not `eval`, so it is unaffected
+ * by `--disallow-code-generation-from-strings` — the same reason the asm.js
+ * build itself decodes specifiers under the flag. The only export is rewritten
+ * to a CommonJS one; the source is a vendored build we control.
  *
- * @returns {Set<string>} The identifiers exported by the module along with any
- * custom directives.
+ * @returns {typeof parseWasm} The asm.js parse function.
  */
-export default function getEsmExports (moduleSource) {
-  const exportedNames = new Set()
-  const tree = parser.parse(moduleSource, acornOpts)
-  for (const node of tree.body) {
-    if (!node.type.startsWith('Export')) continue
-    switch (node.type) {
-      case 'ExportNamedDeclaration':
-        if (node.declaration) {
-          parseDeclaration(node, exportedNames)
-        } else {
-          parseSpecifiers(node, exportedNames)
-        }
-        break
-
-      case 'ExportDefaultDeclaration': {
-        exportedNames.add('default')
-        break
-      }
+function loadAsmParse () {
+  const asmPath = require.resolve('es-module-lexer/js')
+  const source = readFileSync(asmPath, 'utf8')
+    .replace('export function parse', 'function parse') +
+    '\nmodule.exports = { parse }\n'
+  const mod = new Module(asmPath)
+  mod.filename = asmPath
+  mod._compile(source, asmPath)
+  return mod.exports.parse
+}
 
-      case 'ExportAllDeclaration':
-        if (node.exported) {
-          exportedNames.add(node.exported.name)
-        } else {
-          exportedNames.add(`* from ${node.source.value}`)
-        }
-        break
-      default:
-        warn('unrecognized export type: ' + node.type)
-    }
+/**
+ * Decodes an exported identifier the way the JS engine would. es-module-lexer
+ * leaves Unicode escapes in bare identifier exports (`export const \u0061 = 1`)
+ * as their raw spelling, while the module namespace exposes the cooked name
+ * (`a`). Quoted export names are already decoded by the lexer and start with a
+ * quote in the source, so the cheap quote check keeps them on the fast path;
+ * only a bare identifier carrying a backslash needs cooking. A malformed escape
+ * falls back to the raw name rather than throwing inside the loader.
+ *
+ * @param {string} name The export name as reported by the lexer.
+ * @returns {string} The cooked export name.
+ */
+function decodeExportName (name) {
+  const first = name.charCodeAt(0)
+  if (first === 0x22 /* " */ || first === 0x27 /* ' */ || !name.includes('\\')) {
+    return name
+  }
+  try {
+    return JSON.parse(`"${name}"`)
+  } catch {
+    return name
   }
-  return exportedNames
 }
 
-function parseDeclaration (node, exportedNames) {
-  switch (node.declaration.type) {
-    case 'FunctionDeclaration':
-      exportedNames.add(node.declaration.id.name)
-      break
-    case 'VariableDeclaration':
-      for (const varDecl of node.declaration.declarations) {
-        parseVariableDeclaration(varDecl, exportedNames)
-      }
-      break
-    case 'ClassDeclaration':
-      exportedNames.add(node.declaration.id.name)
-      break
-    default:
-      warn('unknown declaration type: ' + node.delcaration.type)
-  }
+// es-module-lexer reports a bare `export * from <mod>` only as an import with no
+// matching export entry, indistinguishable from `import <mod>` except by the
+// statement text. This matches that text to rewrite it as the transitive
+// `* from <specifier>` marker the interpreting code recognizes. `export * as ns
+// from` binds a real name and is reported as a normal export, so it must not
+// match here. `GAP` allows whitespace and comments between the tokens, the way
+// the parser does (e.g. `export /* c */ * from`).
+const GAP = '(?:\\s|/\\*[^]*?\\*/|//[^\\n]*\\n)*'
+const STAR_REEXPORT = new RegExp(`^export${GAP}\\*${GAP}from`)
+
+/**
+ * Lexes ESM source code with es-module-lexer and builds a list of exported
+ * identifiers. In the baseline case the list is the simple identifier names as
+ * written in the source. There is one special case:
+ *
+ * When an `export * from './foo.js'` line is encountered it is rewritten as
+ * `* from ./foo.js`. This lets the interpreting code recognize a transitive
+ * export and recursively parse the indicated module. The returned identifier
+ * list will have "* from ./foo.js" as an item.
+ *
+ * @param {string} moduleSource The source code of the module to lex.
+ * @returns {Set<string>} The identifiers exported by the module along with any
+ * custom directives.
+ */
+export default function getEsmExports (moduleSource) {
+  return lexEsm(moduleSource).exportNames
 }
 
-function parseVariableDeclaration (node, exportedNames) {
-  switch (node.id.type) {
-    case 'Identifier':
-      exportedNames.add(node.id.name)
-      break
-    case 'ObjectPattern':
-      for (const prop of node.id.properties) {
-        exportedNames.add(prop.value.name)
-      }
-      break
-    case 'ArrayPattern':
-      for (const elem of node.id.elements) {
-        exportedNames.add(elem.name)
-      }
-      break
-    default:
-      warn('unknown variable declaration type: ' + node.id.type)
+/**
+ * Lexes ESM source code once and reports both the exported identifiers and
+ * whether the source uses ESM syntax. Sharing a single `parse` lets the
+ * unknown-format path in `getExports` decide between ESM and CommonJS without a
+ * second pass over the source.
+ *
+ * `hasModuleSyntax` is es-module-lexer's own signal: static `import`/`export`
+ * and `import.meta` set it, while a lone dynamic `import(...)` (valid in CJS)
+ * does not.
+ *
+ * @param {string} moduleSource The source code of the module to lex.
+ * @returns {{ exportNames: Set<string>, hasModuleSyntax: boolean }}
+ */
+export function lexEsm (moduleSource) {
+  const exportNames = new Set()
+  const [imports, exports, , hasModuleSyntax] = parse(moduleSource)
+
+  for (const exported of exports) {
+    exportNames.add(decodeExportName(exported.n))
   }
-}
 
-function parseSpecifiers (node, exportedNames) {
-  for (const specifier of node.specifiers) {
-    if (specifier.exported.type === 'Identifier') {
-      exportedNames.add(specifier.exported.name)
-    } else if (specifier.exported.type === 'Literal') {
-      exportedNames.add(specifier.exported.value)
-    } else {
-      warn('unrecognized specifier type: ' + specifier.exported.type)
+  // Bare `export * from <mod>` re-exports report no export name; reconstruct
+  // the transitive marker from the import statement that carries the specifier.
+  for (const imported of imports) {
+    if (STAR_REEXPORT.test(moduleSource.slice(imported.ss, imported.se))) {
+      exportNames.add(`* from ${imported.n}`)
     }
   }
+
+  return { exportNames, hasModuleSyntax }
 }

package/node_modules/import-in-the-middle/lib/get-exports.mjs

@@ -1,6 +1,6 @@
 'use strict'
 
-import getEsmExports from './get-esm-exports.mjs'
+import { lexEsm } from './get-esm-exports.mjs'
 import { parse as parseCjs, initSync } from 'cjs-module-lexer'
 import { readFileSync, existsSync } from 'fs'
 import { builtinModules, createRequire } from 'module'
@@ -11,6 +11,11 @@ import { LOAD } from './io.mjs'
 const nodeMajor = Number(process.versions.node.split('.')[0])
 export const hasModuleExportsCJSDefault = nodeMajor >= 23
 
+// Resolve `stripTypeScriptTypes` (Node >= 22.13) via `getBuiltinModule` rather
+// than a static named import (throws on older runtimes) or `require` (re-enters
+// iitm's own loader hooks). `undefined` on runtimes that lack it.
+const stripTypeScriptTypes = process.getBuiltinModule?.('module')?.stripTypeScriptTypes
+
 let parserInitialized = false
 
 // The CJS export scanner is backed by WebAssembly. `initSync` compiles it
@@ -28,127 +33,6 @@ function addDefault (arr) {
   return new Set(['default', ...arr])
 }
 
-function hasEsmSyntax (source) {
-  // Lightweight scan (no full parse) to determine if the *source code*
-  // contains ESM-specific syntax. This is used only when:
-  // - the loader chain didn't tell us a `format`, and
-  // - `getEsmExports()` found no exports.
-  //
-  // Notes:
-  // - We ignore comments and strings to reduce false positives.
-  // - We treat `import.meta` and static `import ...` as ESM.
-  // - We do NOT treat `import(` (dynamic import) as ESM because it is allowed
-  //   in CJS as an expression.
-  if (source.indexOf('import') === -1) return false
-
-  const isIdentCharCode = (code) => (
-    (code >= 48 && code <= 57) || // 0-9
-    (code >= 65 && code <= 90) || // A-Z
-    (code >= 97 && code <= 122) || // a-z
-    code === 95 || // _
-    code === 36 // $
-  )
-
-  const skipWhitespace = (idx) => {
-    while (idx < source.length) {
-      const c = source.charCodeAt(idx)
-      // space, tab, cr, lf
-      if (c !== 32 && c !== 9 && c !== 13 && c !== 10) break
-      idx++
-    }
-    return idx
-  }
-
-  let i = 0
-  while (i < source.length) {
-    const ch = source[i]
-
-    // Line comment
-    if (ch === '/' && source[i + 1] === '/') {
-      i += 2
-      while (i < source.length && source[i] !== '\n') i++
-      continue
-    }
-
-    // Block comment
-    if (ch === '/' && source[i + 1] === '*') {
-      i += 2
-      while (i < source.length && !(source[i] === '*' && source[i + 1] === '/')) i++
-      i += 2
-      continue
-    }
-
-    // Strings: '...' or "..."
-    if (ch === '\'' || ch === '"') {
-      const quote = ch
-      i++
-      while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-          i += 2
-          continue
-        }
-        if (c === quote) {
-          i++
-          break
-        }
-        i++
-      }
-      continue
-    }
-
-    // Template strings: `...`
-    if (ch === '`') {
-      i++
-      while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-          i += 2
-          continue
-        }
-        if (c === '`') {
-          i++
-          break
-        }
-        i++
-      }
-      continue
-    }
-
-    // Keyword scan (word-boundary): import
-    if (ch === 'i') {
-      const prev = source.charCodeAt(i - 1)
-      if (i > 0 && isIdentCharCode(prev)) {
-        i++
-        continue
-      }
-
-      if (source.startsWith('import', i)) {
-        const next = source.charCodeAt(i + 6)
-        if (isIdentCharCode(next)) {
-          i++
-          continue
-        }
-
-        const j = skipWhitespace(i + 6)
-        // `import.meta` is ESM-only
-        if (source[j] === '.') return true
-        // `import(` is dynamic import, allowed in CJS
-        if (source[j] === '(') {
-          i = j + 1
-          continue
-        }
-        // Otherwise assume it's a static import form
-        return true
-      }
-    }
-
-    i++
-  }
-
-  return false
-}
-
 // Cached exports for Node built-in modules
 const BUILT_INS = new Map()
 
@@ -189,6 +73,24 @@ function getExportsForNodeBuiltIn (name) {
 
 const urlsBeingProcessed = new Set() // Guard against circular imports.
 
+// Memoizes an ESM module's export names by URL. A leaf reached from several
+// barrels (`export *`) would otherwise be read and lexed once per barrel, and
+// the same URL reached from separate top-level wraps would be lexed once per
+// wrap; the first lex serves every later one.
+//
+// This assumes a module's export names are stable for the process: the memo
+// serves a later, independent scan without re-running the loader chain's
+// `load()`, so a loader that returns a *different export set* for the same URL
+// across calls (a stateful codegen loader, or one keyed off `context`) is a
+// deliberately unsupported case — it would be served the first scan's names.
+// Idempotent transforms (type stripping, AST instrumentation such as
+// OrchestrionJS, minifiers) are stable and unaffected; the wrapper's real
+// namespace `load()` still runs every time, so per-load source differences in
+// the *executed* module are preserved (see the wrapper's `import * as
+// namespace`). Only the pure ESM result is cached: the CommonJS path mutates
+// `context.format` and resolves re-exports, and builtins memoize via BUILT_INS.
+const esmExportsCache = new Map()
+
 /**
  * This function looks for the package.json which contains the specifier trying to resolve.
  * Once the package.json file has been found, we extract the file path from the specifier
@@ -328,6 +230,11 @@ function * getCjsExports (url, context, source) {
  * be included in the result set.
  */
 export function * getExports (url, context) {
+  const cached = esmExportsCache.get(url)
+  if (cached !== undefined) {
+    return cached.exportNames
+  }
+
   // `[LOAD, ...]` gives us the possibility of getting the source from an
   // upstream loader. This doesn't always work though, so later on we fall back
   // to reading it from disk.
@@ -362,28 +269,38 @@ export function * getExports (url, context) {
   }
 
   try {
-    if (format === 'module') {
-      return getEsmExports(source)
+    // Node hands the load hook the original TypeScript source, so strip the
+    // types before the JS parsers run, then treat the module as the JS it
+    // compiles to. Early type-stripping releases tag the format but lack the
+    // API; the un-stripped parse then fails cleanly into onWrapFailure.
+    let moduleFormat = format
+    if (format === 'module-typescript' || format === 'commonjs-typescript') {
+      if (stripTypeScriptTypes !== undefined) {
+        source = stripTypeScriptTypes(source, { mode: 'strip' })
+      }
+      moduleFormat = format === 'module-typescript' ? 'module' : 'commonjs'
     }
 
-    if (format === 'commonjs') {
+    if (moduleFormat === 'commonjs') {
       return yield * getCjsExports(url, context, source)
     }
 
-    // At this point our `format` is either undefined or not known by us. Fall
-    // back to parsing as ESM/CJS.
-    const esmExports = getEsmExports(source)
-    if (!esmExports.size) {
-      // If there's strong evidence this is ESM (static import/import.meta),
-      // prefer returning the empty ESM export set over incorrectly treating it
-      // as CJS.
-      if (!hasEsmSyntax(source)) {
-        // It might be possible to get here if the format
-        // isn't set at first and yet we have an ESM module with no exports.
-        return yield * getCjsExports(url, context, source)
-      }
+    const { exportNames, hasModuleSyntax } = lexEsm(source)
+
+    if (moduleFormat === 'module') {
+      esmExportsCache.set(url, { exportNames })
+      return exportNames
+    }
+
+    // At this point our `format` is either undefined or not known by us. When
+    // there are no exports and no ESM syntax, fall back to CommonJS detection.
+    // Strong evidence of ESM (static import/import.meta) keeps the empty ESM
+    // export set rather than incorrectly treating the module as CJS.
+    if (!exportNames.size && !hasModuleSyntax) {
+      return yield * getCjsExports(url, context, source)
     }
-    return esmExports
+    esmExportsCache.set(url, { exportNames })
+    return exportNames
   } catch (cause) {
     const err = new Error(`Failed to parse '${url}'`)
     err.cause = cause

package/node_modules/import-in-the-middle/lib/register.js

@@ -55,7 +55,143 @@ function register (name, namespace, set, get, specifier) {
   toHook.push([name, proxy, specifier])
 }
 
+// Delays (ms) for re-reading exports that were still in their temporal dead zone
+// when the wrapper first ran (circular imports). Retried on a microtask first,
+// then at these intervals; unref'd so best-effort retries never hold the process
+// open. Frozen once at module load rather than rebuilt per wrapper.
+const RETRY_DELAYS = [0, 10, 50]
+
+/**
+ * Per-wrapped-module state a generated wrapper builds once to expose its exports
+ * through iitm's proxy. Each wrapper holds a local binding per export plus
+ * `write`/`read` closures over it; `bind` seeds that binding from the real
+ * module and installs the proxy's `set`/`get` for the name, and `flush` resolves
+ * any export that was undefined (circular import) once it becomes available.
+ *
+ * This is the boilerplate the wrapper used to inline in full per module. Hoisting
+ * it here compiles it once instead of once per wrapped module and keeps the
+ * per-export bind call site monomorphic.
+ */
+class ModuleBinder {
+  // Mimics a Module namespace object (https://tc39.es/ecma262/#sec-module-namespace-objects).
+  namespace = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } })
+  set = {}
+  get = {}
+  #overridden = Object.create(null)
+  #pending = []
+
+  /**
+   * Seeds `key` from `source` and installs its proxy accessors. A value that is
+   * undefined or throws `ReferenceError` (temporal dead zone during a circular
+   * import) is deferred to `flush`; any other throw propagates.
+   *
+   * @param {string} key The export name.
+   * @param {object} source The real module namespace to read the value from.
+   * @param {(value: unknown) => void} write Assigns the wrapper's local binding.
+   * @param {() => unknown} read Reads the wrapper's local binding.
+   * @param {boolean} useFallback Fall back to `source.default` (the synthetic
+   * `module.exports` name a builtin does not expose on its ESM namespace).
+   * @returns {void}
+   */
+  bind (key, source, write, read, useFallback) {
+    const readSource = useFallback
+      ? () => source[key] ?? source.default
+      : () => source[key]
+    this.#overridden[key] = false
+    let deferred = false
+    try {
+      const value = readSource()
+      write(value)
+      this.namespace[key] = value
+    } catch (error) {
+      if (!(error instanceof ReferenceError)) throw error
+      deferred = true
+    }
+    if (deferred || read() === undefined) {
+      this.#pending.push(this.#makeUpdater(key, readSource, write))
+    }
+    this.set[key] = (value) => {
+      this.#overridden[key] = true
+      write(value)
+      return true
+    }
+    this.get[key] = read
+  }
+
+  /**
+   * @param {string} key The export name to update.
+   * @param {() => unknown} readSource Reads the current value from the real module.
+   * @param {(value: unknown) => void} write Assigns the wrapper's local binding.
+   * @returns {() => boolean} Updater returning whether the value is now settled.
+   */
+  #makeUpdater (key, readSource, write) {
+    return () => {
+      if (this.#overridden[key] === true) return true
+      try {
+        const value = readSource()
+        if (value !== undefined) {
+          write(value)
+          this.namespace[key] = value
+          return true
+        }
+        return false
+      } catch (error) {
+        if (error instanceof ReferenceError) return false
+        // Only reached if a getter starts throwing a non-ReferenceError after the
+        // initial bind read already succeeded or deferred; surfaces in flush's
+        // microtask. Kept as-is from the inline wrapper.
+        /* c8 ignore next */
+        throw error
+      }
+    }
+  }
+
+  #flushOnce () {
+    const next = []
+    for (const updater of this.#pending) {
+      // If it still throws ReferenceError, keep it for the (single) next attempt.
+      if (updater() !== true) next.push(updater)
+    }
+    this.#pending = next
+  }
+
+  /**
+   * Resolves exports deferred by `bind` (undefined or TDZ at wrapper-eval time).
+   * Retries on a microtask, then at `RETRY_DELAYS`, giving up afterwards to avoid
+   * unbounded retries. A no-op when nothing was deferred.
+   *
+   * @returns {void}
+   */
+  flush () {
+    if (this.#pending.length === 0) return
+    queueMicrotask(() => {
+      this.#flushOnce()
+      this.#scheduleRetry(0)
+    })
+  }
+
+  /**
+   * @param {number} attempt Index into `RETRY_DELAYS` for the next retry.
+   * @returns {void}
+   */
+  #scheduleRetry (attempt) {
+    if (this.#pending.length === 0) return
+    if (attempt >= RETRY_DELAYS.length) {
+      // Give up: leave exports as-is to avoid unbounded retries.
+      this.#pending = []
+      return
+    }
+    const timer = setTimeout(() => {
+      this.#flushOnce()
+      this.#scheduleRetry(attempt + 1)
+    }, RETRY_DELAYS[attempt])
+    // Don't keep the process alive just for best-effort retries.
+    if (timer && typeof timer.unref === 'function') timer.unref()
+  }
+}
+
 exports.register = register
+exports.ModuleBinder = ModuleBinder
 exports.importHooks = importHooks
 exports.specifiers = specifiers
 exports.toHook = toHook

package/node_modules/import-in-the-middle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "import-in-the-middle",
-  "version": "3.2.0",
+  "version": "3.3.2",
   "description": "Intercept imports in Node.js",
   "engines": {
     "node": ">=18"
@@ -59,9 +59,8 @@
     "vue": "^3.5.26"
   },
   "dependencies": {
-    "acorn": "^8.15.0",
-    "acorn-import-attributes": "^1.9.5",
     "cjs-module-lexer": "^2.2.0",
+    "es-module-lexer": "^2.2.0",
     "module-details-from-path": "^1.0.4"
   }
 }

package/node_modules/import-in-the-middle/register-hooks.d.ts

@@ -17,7 +17,8 @@ export type RegisterHooksOptions = {
  * synchronous hooks run on the application thread, so `Hook()` registrations are
  * visible to the loader directly and no acknowledgement step is required.
  *
- * Requires a Node.js version with `module.registerHooks()` (>= 22.15.0 / >= 24).
+ * Requires a Node.js version where {@link supportsSyncHooks} is `true`
+ * (>= 22.22.3, >= 24.11.1, >= 25.1.0, or >= 26.0.0).
  *
  * ```ts
  * import { register } from 'import-in-the-middle/register-hooks.mjs'
@@ -30,6 +31,14 @@ export type RegisterHooksOptions = {
  * })
  * ```
  *
- * @throws If `module.registerHooks()` is unavailable in the running Node.js.
+ * @throws If {@link supportsSyncHooks} is `false` in the running Node.js.
  */
 export declare function register(options?: RegisterHooksOptions): void
+
+/**
+ * Whether the running Node.js can correctly run the synchronous loader via
+ * `module.registerHooks()`. `false` on versions that ship `module.registerHooks()`
+ * but predate the nullish-CommonJS-`source` fix (nodejs/node#59929); branch on it
+ * to fall back to the asynchronous `module.register()` loader.
+ */
+export declare function supportsSyncHooks(): boolean