@openclaw/diagnostics-otel 2026.7.2-beta.7 → 2026.8.1-beta.2

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/lib/get-exports.mjs

@@ -1,309 +0,0 @@
-'use strict'
-
-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'
-import { fileURLToPath, pathToFileURL } from 'url'
-import { dirname, join } from 'path'
-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
-// up front so the scanner can run inside synchronous loader hooks
-// (`module.registerHooks`) as well as the off-thread loader; it is a one-time
-// cost on the first CommonJS module either way.
-function ensureParserInitialized () {
-  if (!parserInitialized) {
-    initSync()
-    parserInitialized = true
-  }
-}
-
-function addDefault (arr) {
-  return new Set(['default', ...arr])
-}
-
-// Cached exports for Node built-in modules
-const BUILT_INS = new Map()
-
-let require
-
-// Returns a builtin's exports object. `process.getBuiltinModule` (Node >=
-// 20.16 / >= 22.3) bypasses registered loader hooks; `require` does not. Under
-// the in-thread `module.registerHooks` loader a plain `require(name)` here
-// re-enters iitm's own hooks and resolves to the half-built wrapper instead of
-// the native module. The off-thread `module.register` loader runs `require` on
-// the loader thread where the hooks aren't installed, so the fallback stays
-// correct on older Node that lacks getBuiltinModule.
-function loadBuiltin (name) {
-  if (typeof process.getBuiltinModule === 'function') {
-    return process.getBuiltinModule(name)
-  }
-  if (!require) {
-    require = createRequire(import.meta.url)
-  }
-  return require(name)
-}
-
-function getExportsForNodeBuiltIn (name) {
-  let exports = BUILT_INS.get(name)
-
-  if (!exports) {
-    // get all properties both enumerable and non-enumerable
-    exports = new Set(addDefault(Object.getOwnPropertyNames(loadBuiltin(name))))
-    // added in node 23 as alias for default in cjs modules
-    if (hasModuleExportsCJSDefault) {
-      exports.add('module.exports')
-    }
-    BUILT_INS.set(name, exports)
-  }
-
-  return exports
-}
-
-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
- * @param {string} specifier The specifier that is being search for inside the imports object
- * @param {URL|string} fromUrl The url from which the search starts from
- * @returns array with url and resolvedExport
- */
-function resolvePackageImports (specifier, fromUrl) {
-  try {
-    const fromPath = fileURLToPath(fromUrl)
-    let currentDir = dirname(fromPath)
-
-    // search for package.json file which has the real url to export
-    while (currentDir !== dirname(currentDir)) {
-      const packageJsonPath = join(currentDir, 'package.json')
-
-      if (existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
-        if (packageJson.imports && packageJson.imports[specifier]) {
-          const imports = packageJson.imports[specifier]
-
-          // Look for path inside packageJson
-          let resolvedExport
-          if (imports && typeof imports === 'object') {
-            const requireExport = imports.require
-            const importExport = imports.import
-            // look for the possibility of require and import which is standard for CJS/ESM
-            if (requireExport || importExport) {
-              // trying to resolve based on order of importance
-              resolvedExport = requireExport.node || requireExport.default || importExport.node || importExport.default
-            } else if (imports.node || imports.default) {
-              resolvedExport = imports.node || imports.default
-            }
-          } else if (typeof imports === 'string') {
-            resolvedExport = imports
-          }
-
-          if (resolvedExport) {
-            const url = resolvedExport.startsWith('.')
-              ? pathToFileURL(join(currentDir, resolvedExport))
-              : fromUrl
-            return [url, resolvedExport]
-          }
-        }
-        // return if we find a package.json but did not find an import
-        return null
-      }
-
-      currentDir = dirname(currentDir)
-    }
-  } catch (cause) {
-    throw Error(`Failed to find export: ${specifier}`, { cause })
-  }
-  return null
-}
-
-function * getCjsExports (url, context, source) {
-  if (urlsBeingProcessed.has(url)) {
-    return new Set()
-  }
-  urlsBeingProcessed.add(url)
-
-  try {
-    ensureParserInitialized()
-    const result = parseCjs(source)
-    const full = addDefault(result.exports)
-
-    for (const reexport of result.reexports) {
-      if (reexport.startsWith('node:') || builtinModules.includes(reexport)) {
-        for (const each of getExportsForNodeBuiltIn(reexport)) {
-          full.add(each)
-        }
-        continue
-      }
-
-      // Resolve each re-export relative to the current module. Keep the
-      // resolution scoped to this iteration: a `#`-import rewrites both the
-      // base URL and the specifier, and that rewrite must not leak into the
-      // next re-export.
-      let reUrl = url
-      let reSpecifier = reexport === '.' ? './' : reexport
-
-      // Entries in the import field should always start with #
-      if (reSpecifier.startsWith('#')) {
-        const resolved = resolvePackageImports(reSpecifier, url)
-        if (!resolved) continue
-        ;[reUrl, reSpecifier] = resolved
-      }
-
-      if (!require) {
-        require = createRequire(import.meta.url)
-      }
-      const newUrl = pathToFileURL(
-        require.resolve(reSpecifier, { paths: [dirname(fileURLToPath(reUrl))] })
-      ).href
-
-      if (newUrl.endsWith('.node') || newUrl.endsWith('.json')) {
-        continue
-      }
-
-      for (const each of yield * getExports(newUrl, context)) {
-        full.add(each)
-      }
-    }
-
-    // added in node 23 as alias for default in cjs modules
-    if (full.has('default') && hasModuleExportsCJSDefault) {
-      full.add('module.exports')
-    }
-
-    // we know that it's commonjs at this point, because ESM failed
-    context.format = 'commonjs'
-    return full
-  } finally {
-    urlsBeingProcessed.delete(url)
-  }
-}
-
-/**
- * Inspects a module for its type (commonjs or module), obtains the source code
- * for said module from the loader API, and parses the result for the entities
- * exported from that module.
- *
- * This is a "sans-io" generator: instead of calling the loader's `load` hook
- * directly, it `yield`s `[LOAD, url, context]` and is driven by either
- * {@link driveSync} or {@link driveAsync} (see `lib/io.mjs`). The same body
- * therefore serves both the off-thread loader and `module.registerHooks`.
- *
- * @param {string} url A file URL string pointing to the module that we should
- * get the exports of.
- * @param {object} context Context object as provided by the `load` hook from
- * the loaders API.
- *
- * @returns {Generator<Array, Set<string>>} A generator that yields I/O
- * operations and ultimately returns the identifiers exported by the module.
- * Please see {@link getEsmExports} for caveats on special identifiers that may
- * 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.
-  const parentCtx = yield [LOAD, url, context]
-  let source = parentCtx.source
-  const format = parentCtx.format
-
-  // Loader hooks can return ArrayBuffer / TypedArray sources. Normalize to a
-  // string for parsing.
-  if (source && typeof source !== 'string') {
-    // Avoid copies where possible:
-    // - Buffer.from(Uint8Array) copies
-    // - Buffer.from(ArrayBuffer, offset, length) wraps the existing memory
-    if (Buffer.isBuffer(source)) {
-      source = source.toString('utf8')
-    } else if (ArrayBuffer.isView(source)) {
-      source = Buffer.from(source.buffer, source.byteOffset, source.byteLength).toString('utf8')
-    } else {
-      source = Buffer.from(source).toString('utf8')
-    }
-  }
-
-  if (!source) {
-    if (format === 'builtin') {
-      // Builtins don't give us the source property, so we're stuck
-      // just requiring it to get the exports.
-      return getExportsForNodeBuiltIn(url)
-    }
-
-    // Sometimes source is retrieved by parentLoad, CommonJs isn't.
-    source = readFileSync(fileURLToPath(url), 'utf8')
-  }
-
-  try {
-    // 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 (moduleFormat === 'commonjs') {
-      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)
-    }
-    esmExportsCache.set(url, { exportNames })
-    return exportNames
-  } catch (cause) {
-    const err = new Error(`Failed to parse '${url}'`)
-    err.cause = cause
-    throw err
-  }
-}

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/lib/io.mjs

@@ -1,78 +0,0 @@
-'use strict'
-
-// The export-collection logic (resolving star re-exports, reading source,
-// parsing exports) is identical whether `import-in-the-middle` runs as an
-// off-thread loader (`module.register`, asynchronous `nextResolve`/`nextLoad`)
-// or as an in-thread synchronous loader (`module.registerHooks`). To keep a
-// single implementation of that logic — instead of two copies that drift — it
-// is written as "sans-io" generators that `yield` the I/O they need and let a
-// driver fulfil it. The async driver awaits; the sync driver calls straight
-// through. Everything between the yields is shared.
-
-// Operation kinds a loader generator may yield. Each is `[KIND, ...args]`.
-export const LOAD = 0 // [LOAD, url, context]      -> resolves to { source, format }
-export const RESOLVE = 1 // [RESOLVE, specifier, context] -> resolves to { url, format }
-
-function runOp (op, io) {
-  if (op[0] === RESOLVE) {
-    return io.resolve(op[1], op[2])
-  }
-  return io.load(op[1], op[2])
-}
-
-/**
- * Drives a loader generator to completion, fulfilling each yielded I/O
- * operation synchronously. Used with `module.registerHooks`, whose
- * `nextResolve`/`nextLoad` return their result directly.
- *
- * Errors from I/O are thrown back into the generator (via `gen.throw`) so its
- * `try`/`finally` blocks run exactly as they would for an `await` rejection.
- *
- * @template T
- * @param {Generator<Array, T>} gen
- * @param {{ load: Function, resolve?: Function }} io
- * @returns {T}
- */
-export function driveSync (gen, io) {
-  let next = gen.next()
-  while (next.done === false) {
-    let result
-    let error
-    let threw = false
-    try {
-      result = runOp(next.value, io)
-    } catch (err) {
-      threw = true
-      error = err
-    }
-    next = threw ? gen.throw(error) : gen.next(result)
-  }
-  return next.value
-}
-
-/**
- * Drives a loader generator to completion, awaiting each yielded I/O
- * operation. Used with the off-thread `module.register` loader, whose
- * `nextResolve`/`nextLoad` are asynchronous.
- *
- * @template T
- * @param {Generator<Array, T>} gen
- * @param {{ load: Function, resolve?: Function }} io
- * @returns {Promise<T>}
- */
-export async function driveAsync (gen, io) {
-  let next = gen.next()
-  while (next.done === false) {
-    let result
-    let error
-    let threw = false
-    try {
-      result = await runOp(next.value, io)
-    } catch (err) {
-      threw = true
-      error = err
-    }
-    next = threw ? gen.throw(error) : gen.next(result)
-  }
-  return next.value
-}

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/lib/register.js

@@ -1,197 +0,0 @@
-// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2.0 License.
-//
-// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
-
-const importHooks = [] // TODO should this be a Set?
-const setters = new WeakMap()
-const getters = new WeakMap()
-const specifiers = new Map()
-const toHook = []
-
-const proxyHandler = {
-  set (target, name, value) {
-    const set = setters.get(target)
-    const setter = set && set[name]
-    if (typeof setter === 'function') {
-      return setter(value)
-    }
-    // If a module doesn't export the property being assigned (e.g. no default
-    // export), there is no setter to call. Don't crash userland code.
-    return true
-  },
-
-  get (target, name) {
-    if (name === Symbol.toStringTag) {
-      return 'Module'
-    }
-
-    const getter = getters.get(target)[name]
-
-    if (typeof getter === 'function') {
-      return getter()
-    }
-  },
-
-  defineProperty (target, property, descriptor) {
-    if ((!('value' in descriptor))) {
-      throw new Error('Getters/setters are not supported for exports property descriptors.')
-    }
-
-    const set = setters.get(target)
-    const setter = set && set[property]
-    if (typeof setter === 'function') {
-      return setter(descriptor.value)
-    }
-    return true
-  }
-}
-
-function register (name, namespace, set, get, specifier) {
-  specifiers.set(name, specifier)
-  setters.set(namespace, set)
-  getters.set(namespace, get)
-  const proxy = new Proxy(namespace, proxyHandler)
-  importHooks.forEach(hook => hook(name, proxy, 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/@opentelemetry/sdk-node/node_modules/import-in-the-middle/package.json

@@ -1,66 +0,0 @@
-{
-  "name": "import-in-the-middle",
-  "version": "3.3.2",
-  "description": "Intercept imports in Node.js",
-  "engines": {
-    "node": ">=18"
-  },
-  "main": "index.js",
-  "scripts": {
-    "test": "c8 --reporter lcov --check-coverage --lines 45 imhotap --files test/{hook,low-level,other,get-esm-exports,register}/*",
-    "test:e2e": "node test/check-exports/test.mjs && node test/integration-tests/turbopack-dev.mjs && node test/integration-tests/turbopack-build-start.mjs",
-    "test:ts": "c8 --reporter lcov imhotap --files test/typescript/*.test.mts",
-    "coverage": "c8 --reporter html imhotap --files test/{hook,low-level,other,get-esm-exports,register}/* && echo \"\nNow open coverage/index.html\n\"",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/nodejs/import-in-the-middle.git"
-  },
-  "keywords": [
-    "import",
-    "ritm",
-    "iitm",
-    "loader",
-    "hook",
-    "hooks"
-  ],
-  "author": "Bryan English <bryan.english@datadoghq.com>",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/nodejs/import-in-the-middle/issues"
-  },
-  "homepage": "https://github.com/nodejs/import-in-the-middle#readme",
-  "imhotap": {
-    "runner": "node",
-    "test-env": "NODE_OPTIONS=--no-warnings --require ./test/version-check.js --experimental-loader ./test/generic-loader.mjs"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.28.5",
-    "@babel/eslint-parser": "^7.28.5",
-    "@babel/plugin-syntax-import-assertions": "^7.27.1",
-    "@node-rs/crc32": "^1.10.6",
-    "@react-email/components": "^0.0.19",
-    "@types/node": "^18.0.6",
-    "c8": "^7.14.0",
-    "date-fns": "^3.6.0",
-    "eslint": "^8.57.1",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.6.0",
-    "got": "^14.6.6",
-    "imhotap": "^2.2.0",
-    "openai": "4.47.2",
-    "ts-node": "^10.9.2",
-    "typescript": "^4.9.5",
-    "vue": "^3.5.26"
-  },
-  "dependencies": {
-    "cjs-module-lexer": "^2.2.0",
-    "es-module-lexer": "^2.2.0",
-    "module-details-from-path": "^1.0.4"
-  }
-}

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/register-hooks.d.ts

@@ -1,44 +0,0 @@
-/**
- * Options for {@link register}. `include`/`exclude` accept bare specifiers,
- * `file:` URLs or regular expressions, matched against the module being
- * resolved.
- */
-export type RegisterHooksOptions = {
-  include?: Array<string | RegExp>
-  exclude?: Array<string | RegExp>
-}
-
-/**
- * Registers `import-in-the-middle` as a *synchronous*, in-thread loader hook via
- * [`module.registerHooks()`](https://nodejs.org/api/module.html#moduleregisterhooksoptions).
- *
- * Unlike `module.register('import-in-the-middle/hook.mjs', ...)`, which runs the
- * loader on a separate thread and pays an IPC round-trip per resolved module,
- * 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 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'
- * import { Hook } from 'import-in-the-middle'
- *
- * register({ include: ['package-i-want-to-include'] })
- *
- * Hook(['package-i-want-to-include'], (exported, name, baseDir) => {
- *   // Instrument the module
- * })
- * ```
- *
- * @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