@openclaw/diagnostics-otel 2026.7.2-beta.7 → 2026.7.34

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/README.md

@@ -117,32 +117,13 @@ node --import=./instrument.mjs ./my-app.mjs
 
 ## Synchronous loader hooks
 
-On Node.js versions that support
+On Node.js versions that provide
 [`module.registerHooks()`](https://nodejs.org/api/module.html#moduleregisterhooksoptions)
-the loader can run *synchronously*, on the application thread, instead of on the
-separate thread that `module.register()` uses. Running in-thread removes the
-message channel: `Hook()` registrations are visible to the loader directly, so
-the `createAddHookMessageChannel` / `waitForAllMessagesAcknowledged` step shown
-above is unnecessary.
-
-`module.registerHooks()` was added in 22.15.0 / 24.0.0, but its synchronous load
-hook rejected the nullish CommonJS `source` the loader returns for `require()`s
-pulled into the ESM graph until [nodejs/node#59929][]. The fix shipped in
-**22.22.3, 24.11.1, 25.1.0 and 26.0.0**; earlier versions ship
-`module.registerHooks()` but cannot run the synchronous loader. Use
-`supportsSyncHooks()` to branch on this rather than a hand-written version check:
-
-```js
-import { register, supportsSyncHooks } from 'import-in-the-middle/register-hooks.mjs'
-
-if (supportsSyncHooks()) {
-  register({ include: ['package-i-want-to-include'] })
-} else {
-  // Fall back to the asynchronous loader, e.g. module.register('import-in-the-middle/hook.mjs').
-}
-```
-
-[nodejs/node#59929]: https://github.com/nodejs/node/pull/59929
+(>= 22.15.0 / >= 24.0.0) the loader can run *synchronously*, on the application
+thread, instead of on the separate thread that `module.register()` uses. Running
+in-thread removes the message channel: `Hook()` registrations are visible to the
+loader directly, so the `createAddHookMessageChannel` /
+`waitForAllMessagesAcknowledged` step shown above is unnecessary.
 
 `instrument.mjs`
 
@@ -162,7 +143,7 @@ node --import=./instrument.mjs ./my-app.mjs
 ```
 
 `register()` accepts the same `include` / `exclude` options as the asynchronous
-loader and throws on a Node.js version where `supportsSyncHooks()` is `false`.
+loader and throws on a Node.js version without `module.registerHooks()`.
 
 ### Custom matching with `shouldInclude`
 
@@ -194,46 +175,9 @@ registration (`register-hooks.mjs`, shown above) and for predicates constructed
 the loader thread; it is not accepted through the `data` option of the asynchronous
 `module.register('import-in-the-middle/hook.mjs', ...)`.
 
-## TypeScript modules
-
-On Node.js versions that strip TypeScript types natively (those exposing
-[`module.stripTypeScriptTypes()`](https://nodejs.org/api/module.html#modulestriptypescripttypescode-options),
->= 22.13.0 / >= 23.9.0 / >= 24.0.0), `import-in-the-middle` intercepts `.ts`,
-`.mts` and `.cts` modules just like their JavaScript counterparts. The types are
-stripped before the module's exports are read, so type-only exports
-(`export type`, `export interface`) are not present on the intercepted
-namespace; value exports are.
-
-```ts
-// math.mts
-export type Op = '+' | '-'
-export function add (a: number, b: number): number {
-  return a + b
-}
-```
-
-```js
-Hook(['./math.mts'], (exported) => {
-  // `exported.add` is interceptable; the `Op` type is not part of the namespace
-})
-```
-
-On Node.js versions where type stripping is not enabled by default, run with
-`--experimental-strip-types`. Older versions that predate
-`module.stripTypeScriptTypes()` leave TypeScript modules untouched.
-
 ## Limitations
 
 * You cannot add new exports to a module. You can only modify existing ones.
 * While bindings to module exports end up being "re-bound" when modified in a
   hook, dynamically imported modules cannot be altered after they're loaded.
 * Modules loaded via `require` are not affected at all.
-* A module's set of export *names* is assumed to be stable for the lifetime of
-  the process. `import-in-the-middle` reads a module's source once to lex its
-  exports and reuses that export set on later loads of the same URL. An upstream
-  loader that returns a *different set of exports* for the same URL across calls
-  — a stateful codegen loader, or one that varies its output by `context` — is
-  not supported and will be instrumented with the export set from its first
-  load. Idempotent transforms (type stripping, AST instrumentation, minifiers)
-  are unaffected, and the actual module still executes the source its real load
-  returns; only the interceptable export *names* are memoized.

package/node_modules/@opentelemetry/sdk-node/node_modules/import-in-the-middle/create-hook.mjs

@@ -10,34 +10,42 @@ import {
   hasModuleExportsCJSDefault
 } from './lib/get-exports.mjs'
 import { RESOLVE, driveSync, driveAsync } from './lib/io.mjs'
-import { supportsSyncHooks } from './supports-sync-hooks.mjs'
-
-// Re-exported for backwards compatibility: `supportsSyncHooks` now lives in its
-// own import-free module so a CommonJS preloader can check it without loading
-// this file's acorn / cjs-module-lexer dependency graph.
-export { supportsSyncHooks }
 
+const specifiers = new Map()
 const isWin = process.platform === 'win32'
 
-// Depth at which `processModule` starts tracking visited URLs to break an
-// `export *` cycle. Real re-export chains are only a few levels deep, so this
-// is far beyond any legitimate graph yet well below the call-stack limit a
-// cycle would otherwise hit. Below it the recursion pays only an integer
-// compare per level and allocates no set.
-const STAR_CYCLE_DEPTH = 100
-
 // FIXME: Typescript extensions are added temporarily until we find a better
 // way of supporting arbitrary extensions
 const EXTENSION_RE = /\.(js|mjs|cjs|ts|mts|cts)$/
-// The `-typescript` formats are listed unconditionally; getExports strips the
-// types when the runtime supports it and otherwise falls back to onWrapFailure.
-const HANDLED_FORMATS = new Set([
-  'builtin', 'module', 'commonjs', 'module-typescript', 'commonjs-typescript'
-])
+const HANDLED_FORMATS = new Set(['builtin', 'module', 'commonjs'])
 const TRACE_WARNINGS = process.execArgv.includes('--trace-warnings')
 
-/** @typedef {import('node:module').LoadHookContext} LoadContext */
-/** @typedef {import('node:module').LoadFnOutput} LoadResult */
+// process.versions.node is always "major.minor.patch" (nightlies add a suffix
+// the regex ignores).
+const [, NODE_MAJOR, NODE_MINOR, NODE_PATCH] =
+  process.versions.node.match(/^(\d+)\.(\d+)\.(\d+)/).map(Number)
+
+/**
+ * Whether the running Node.js can correctly run the synchronous loader via
+ * `module.registerHooks`.
+ *
+ * `module.registerHooks` exists since v22.15, but its synchronous load hook
+ * rejected the nullish CommonJS `source` the loader returns for `require()`s
+ * pulled into the ESM graph (throwing `ERR_INVALID_RETURN_PROPERTY_VALUE`) until
+ * https://github.com/nodejs/node/pull/59929, released in 22.22.3, 24.11.1,
+ * 25.1.0 and 26.0.0. Earlier 24.x (<= 24.11.0) and 25.0.0 ship `registerHooks`
+ * but predate the fix, so the synchronous loader must fall back to the
+ * asynchronous one there.
+ *
+ * @returns {boolean}
+ */
+export function supportsSyncHooks () {
+  if (NODE_MAJOR >= 26) return true
+  if (NODE_MAJOR === 25) return NODE_MINOR >= 1
+  if (NODE_MAJOR === 24) return NODE_MINOR > 11 || (NODE_MINOR === 11 && NODE_PATCH >= 1)
+  if (NODE_MAJOR === 22) return NODE_MINOR > 22 || (NODE_MINOR === 22 && NODE_PATCH >= 3)
+  return false
+}
 
 function hasIitm (url) {
   // Fast path: avoid URL parsing on the hot path when there's clearly no iitm.
@@ -197,37 +205,52 @@ function emitWarning (err) {
  * of how the loader is driven, so both the synchronous and asynchronous paths
  * share it.
  *
- * The value is read from `namespaceVar`, the wrapper's namespace binding for the
- * module that *defines* the export. For a module's own exports that is the
- * wrapped module itself; for a name re-exported through `export *` it is the
- * leaf that declares it. Reading from the defining module rather than the
- * aggregating one keeps the value resolvable when the same binding reaches the
- * aggregator through more than one re-export chain — Node sees those chains as
- * distinct wrapper modules and leaves the name ambiguous (hence `undefined`) on
- * the aggregate namespace, while the defining module always holds it (#171).
- *
  * @param {string} n The exported name.
  * @param {string} srcUrl The URL of the module the export belongs to.
- * @param {string} namespaceVar The wrapper binding holding `srcUrl`'s namespace.
  * @returns {string}
  */
-function buildSetter (n, srcUrl, namespaceVar) {
+function buildSetter (n, srcUrl) {
   const variableName = `$${n.replace(/[^a-zA-Z0-9_$]/g, '_')}`
   const objectKey = JSON.stringify(n)
   const reExportedName = n === 'default' ? n : objectKey
 
-  // Fall back to namespace['default'] for the module.exports synthetic export,
-  // which builtins don't expose on the native ESM namespace.
-  const useFallback = n === 'module.exports'
+  // For the module.exports synthetic export (Node 23+), fall back to $default
+  // when namespace['module.exports'] is not exposed by the native ESM namespace
+  // (builtins don't expose it). This ensures the IITM hook proxy returns the
+  // actual CJS value (e.g. EventEmitter) when an instrumentor reads
+  // capturedExports['module.exports'], rather than undefined.
+  const moduleExportsFallback = n === 'module.exports' ? ' ?? $default' : ''
 
-  // Builtins don't expose the module.exports synthetic name, so skip its re-export.
   const reExportLine = (n === 'module.exports' && (srcUrl.startsWith('node:') || builtinModules.includes(srcUrl)))
     ? ''
     : `export { ${variableName} as ${reExportedName} }`
 
-  return `let ${variableName}
-__binder.bind(${objectKey}, ${namespaceVar}, v => { ${variableName} = v }, () => ${variableName}, ${useFallback})
-${reExportLine}`
+  return `
+      let ${variableName}
+      __overridden[${objectKey}] = false
+      let ${variableName}Defer = false
+      try {
+        ${variableName} = _[${objectKey}] = namespace[${objectKey}]${moduleExportsFallback}
+      } catch (err) {
+        if (!(err instanceof ReferenceError)) throw err
+        ${variableName}Defer = true
+      }
+
+      if (${variableName}Defer || ${variableName} === undefined) {
+        __pending.push(__makeUpdater(
+          ${objectKey},
+          () => namespace[${objectKey}]${moduleExportsFallback},
+          (v) => { ${variableName} = _[${objectKey}] = v }
+        ))
+      }
+      ${reExportLine}
+      set[${objectKey}] = (v) => {
+        __overridden[${objectKey}] = true
+        ${variableName} = v
+        return true
+      }
+      get[${objectKey}] = () => ${variableName}
+      `
 }
 
 /**
@@ -244,82 +267,37 @@ ${reExportLine}`
  * @param {string} params.srcUrl The full URL to the module to process.
  * @param {object} params.context Provided by the loaders API.
  * @param {boolean} [params.excludeDefault = false] Exclude the default export.
- * @param {number} [params.depth = 0] Star-re-export recursion depth. Used to
- * detect `export *` cycles (`a` re-exports `b`, `b` re-exports `a`) cheaply:
- * the acyclic common case pays only an integer compare per level, and the
- * cycle-tracking set is allocated only once recursion is implausibly deep.
- * @param {Set<string>} [params.seen] URLs currently on the recursion stack,
- * created lazily once `depth` crosses {@link STAR_CYCLE_DEPTH}. A URL is added
- * before descending into its subtree and removed once that subtree finishes, so
- * it tracks the active path rather than every URL ever visited.
- * @param {Map<string, string>} [params.originNamespaces] Shared registry mapping
- * a defining-module URL to the wrapper namespace alias a same-origin `export *`
- * collision must read it from. Absent until the first such collision; then
- * threaded through the recursion so one defining module yields one alias and
- * {@link buildWrapperSource} imports each once. Only `*`-collided names use it;
- * every other export reads from the wrapped module's own `namespace`.
  *
- * @returns {Generator<Array, { setters: Map<string, string>, origins: (Map<string, string> | undefined), originNamespaces: (Map<string, string> | undefined) }>}
- * A generator that yields I/O operations and ultimately returns the shimmed
- * setters for all the exports from the module and any transitive export all
- * modules. `origins` (the defining module per `*`-sourced name) is `undefined`
- * for a module with no `export *`; `originNamespaces` stays `undefined` unless a
- * same-origin `*` collision actually needed an alias.
+ * @returns {Generator<Array, Map<string, string>>} A generator that yields I/O
+ * operations and ultimately returns the shimmed setters for all the exports
+ * from the module and any transitive export all modules.
  */
-function * processModule ({ srcUrl, context, excludeDefault = false, depth = 0, seen, originNamespaces }) {
+function * processModule ({ srcUrl, context, excludeDefault = false }) {
   const exportNames = yield * getExports(srcUrl, context)
+  const starExports = new Set()
   const setters = new Map()
 
-  // Maps each live `*`-sourced name to the module that defined it. Its keys
-  // double as "this name came from a `*` re-export" (so an explicit export can
-  // override it), and its values let two `*` re-exports of the same name be told
-  // apart. Allocated on the first `export *`, never for a module without one; a
-  // single Map carries both facts so a star with no collision pays one structure
-  // and one write per name, not two.
-  let starOrigins
-
-  // A name pulled in through more than one `export *` chain that all bottom out
-  // at the same module stays exported (ECMAScript ResolveExport;
-  // tc39/ecma262#3715), but the *aggregate* namespace this wrapper imports drops
-  // it: under iitm the chains are distinct wrapped modules, so Node sees the
-  // re-export as ambiguous and the name reads back undefined. Only those names
-  // must instead read from their defining module's own namespace, which always
-  // holds the value. `originNamespaces` maps such a defining module to the alias
-  // the wrapper imports for it; it is allocated on the first surviving
-  // collision, so a module without one emits no extra import (#171).
-  const ensureOriginNamespace = (origin) => {
-    originNamespaces ??= new Map()
-    let alias = originNamespaces.get(origin)
-    if (alias === undefined) {
-      alias = `__ns${originNamespaces.size}`
-      originNamespaces.set(origin, alias)
-    }
-    return alias
-  }
-
-  const addSetter = (name, setter, isStarExport, origin) => {
+  const addSetter = (name, setter, isStarExport = false) => {
     if (setters.has(name)) {
       if (isStarExport) {
-        // `starOrigins.has(name)` means the existing entry also came from a `*`
-        // re-export (an explicit export would not be tracked here).
-        if (starOrigins.has(name)) {
-          if (starOrigins.get(name) === origin) {
-            // The same binding reached through two `*` re-export chains. It
-            // stays exported, but the aggregate namespace dropped it, so point
-            // its setter at the defining module's namespace instead.
-            setters.set(name, buildSetter(name, origin, ensureOriginNamespace(origin)))
-          } else {
-            // Genuinely ambiguous: two `*` re-exports name it from different
-            // modules. Per ResolveExport the name is excluded entirely.
-            setters.delete(name)
-            starOrigins.delete(name)
-          }
+        // If there's already a matching star export, delete it
+        if (starExports.has(name)) {
+          setters.delete(name)
         }
-        // An explicit export already shadows the `*` re-export; leave it.
+        // and return so this is excluded
+        return
+      }
+
+      // if we already have this export but it is from a * export, overwrite it
+      if (starExports.has(name)) {
+        starExports.delete(name)
+        setters.set(name, setter)
       }
     } else {
+      // Store export * exports so we know they can be overridden by explicit
+      // named exports
       if (isStarExport) {
-        starOrigins.set(name, origin)
+        starExports.add(name)
       }
 
       setters.set(name, setter)
@@ -348,56 +326,21 @@ function * processModule ({ srcUrl, context, excludeDefault = false, depth = 0,
       // parent's `format` to know if this sub-module is ESM or CJS!
       const result = yield [RESOLVE, newSpecifier, { parentURL: srcUrl }]
 
-      // First `*` re-export: allocate the origin bookkeeping lazily.
-      starOrigins ??= new Map()
-
-      // `export *` graphs are normally only a handful of levels deep. A cycle
-      // (`a` re-exports `b`, `b` re-exports `a`) instead recurses without bound
-      // and exhausts memory. Rather than track every URL on the common shallow
-      // path, only start recording once the depth is implausibly large for a
-      // real graph; from there a re-export pointing back at a module already on
-      // the recursion stack is the cycle, and is skipped (its exports are
-      // collected by the in-progress ancestor frame). `seen` mirrors the stack,
-      // not every URL visited: a module reached and fully processed through one
-      // sibling branch must stay reachable through a later, more direct branch,
-      // so it is removed again once its subtree finishes.
-      if (depth >= STAR_CYCLE_DEPTH) {
-        seen ??= new Set()
-        if (seen.has(result.url)) continue
-        seen.add(result.url)
-      }
+      const subSetters = yield * processModule({
+        srcUrl: result.url,
+        context: { ...context, format: result.format },
+        excludeDefault: true
+      })
 
-      try {
-        const sub = yield * processModule({
-          srcUrl: result.url,
-          context: { ...context, format: result.format },
-          excludeDefault: true,
-          depth: depth + 1,
-          seen,
-          originNamespaces
-        })
-
-        // Adopt any registry a nested `export *` minted before processing this
-        // child's results, so a collision detected here extends the same Map the
-        // child's setters already reference (one alias per defining module across
-        // the whole tree) rather than orphaning the child's into a second Map.
-        originNamespaces ??= sub.originNamespaces
-
-        // Star targets build their setters against `namespace` like any other
-        // module; only a surviving same-origin collision (in addSetter) rewrites
-        // the affected name to read from its defining module's alias.
-        for (const [name, setter] of sub.setters) {
-          addSetter(name, setter, true, sub.origins?.get(name) ?? result.url)
-        }
-      } finally {
-        seen?.delete(result.url)
+      for (const [name, setter] of subSetters.entries()) {
+        addSetter(name, setter, true)
       }
     } else {
-      addSetter(n, buildSetter(n, srcUrl, 'namespace'), false)
+      addSetter(n, buildSetter(n, srcUrl))
     }
   }
 
-  return { setters, origins: starOrigins, originNamespaces }
+  return setters
 }
 
 function addIitm (url) {
@@ -406,11 +349,7 @@ function addIitm (url) {
   return urlObj.href
 }
 
-/**
- * @param {{ url: string }} meta
- */
 export function createHook (meta) {
-  const specifiers = new Map()
   let cachedResolve
   const iitmURL = new URL('lib/register.js', meta.url).toString()
   let includeModules, excludeModules
@@ -643,30 +582,75 @@ export function createHook (meta) {
   // Builds the wrapper module source that re-exports the real module through
   // iitm's proxy. Pure string generation shared by the asynchronous and
   // synchronous `load` paths.
-  function buildWrapperSource (realUrl, setters, originalSpecifier, originNamespaces) {
-    // The wrapped module imports its namespace as `namespace`, which serves
-    // every export but the ones a same-origin `export *` collision forced onto
-    // their defining module (#171): the aggregate namespace drops those as
-    // ambiguous under iitm, so each such defining module gets its own alias the
-    // wrapper imports. Absent the registry (no such collision) nothing is added.
-    let originImports = ''
-    if (originNamespaces !== undefined) {
-      for (const [originUrl, alias] of originNamespaces) {
-        originImports += `import * as ${alias} from ${JSON.stringify(originUrl)}\n`
+  function buildWrapperSource (realUrl, setters, originalSpecifier) {
+    return `
+import { register } from '${iitmURL}'
+import * as namespace from ${JSON.stringify(realUrl)}
+
+// Mimic a Module object (https://tc39.es/ecma262/#sec-module-namespace-objects).
+const _ = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } })
+const set = {}
+const get = {}
+const __overridden = Object.create(null)
+let __pending = []
+
+function __makeUpdater (key, read, assign) {
+  return () => {
+    if (__overridden[key] === true) return true
+    try {
+      const v = read()
+      if (v !== undefined) {
+        assign(v)
+        return true
       }
+      return false
+    } catch (err) {
+      if (err instanceof ReferenceError) return false
+      throw err
     }
+  }
+}
 
-    return `
-import { register, ModuleBinder } from ${JSON.stringify(iitmURL)}
-import * as namespace from ${JSON.stringify(realUrl)}
-${originImports}
-const __binder = new ModuleBinder()
+function __flushPendingOnce () {
+  if (__pending.length === 0) return
+  const next = []
+  for (const fn of __pending) {
+    // If it still throws ReferenceError, keep it for the (single) next attempt.
+    if (fn() !== true) next.push(fn)
+  }
+  __pending = next
+}
 
 ${Array.from(setters.values()).join('\n')}
 
-__binder.flush()
+if (__pending.length > 0) {
+  queueMicrotask(() => {
+    __flushPendingOnce()
+
+    if (__pending.length > 0) {
+      const __retryDelays = [0, 10, 50]
+      const __schedulePending = (i) => {
+        if (__pending.length === 0) return
+        if (i >= __retryDelays.length) {
+          // Give up: leave exports as-is to avoid unbounded retries.
+          __pending = []
+          return
+        }
+
+        const t = setTimeout(() => {
+          __flushPendingOnce()
+          __schedulePending(i + 1)
+        }, __retryDelays[i])
+        // Don't keep the process alive just for best-effort retries.
+        if (t && typeof t.unref === 'function') t.unref()
+      }
+
+      __schedulePending(0)
+    }
+  })
+}
 
-register(${JSON.stringify(realUrl)}, __binder.namespace, __binder.set, __binder.get, ${JSON.stringify(originalSpecifier)})
+register(${JSON.stringify(realUrl)}, _, set, get, ${JSON.stringify(originalSpecifier)})
 `
   }
 
@@ -674,13 +658,13 @@ register(${JSON.stringify(realUrl)}, __binder.namespace, __binder.set, __binder.
   // succeeds: free the specifier entry early, and remember CJS modules so their
   // transitive require() chain bypasses iitm (see `load`). Returns the wrapper
   // module source.
-  function onWrapSuccess (realUrl, context, originalSpecifier, setters, originNamespaces) {
+  function onWrapSuccess (realUrl, context, originalSpecifier, setters) {
     specifiers.delete(realUrl)
     // context.format is set to 'commonjs' by getCjsExports during processModule.
     if (context.format === 'commonjs') {
       cjsInIitmChain.add(realUrl)
     }
-    return buildWrapperSource(realUrl, setters, originalSpecifier, originNamespaces)
+    return buildWrapperSource(realUrl, setters, originalSpecifier)
   }
 
   // Bookkeeping shared by the async and sync wrap paths when `processModule`
@@ -695,26 +679,17 @@ register(${JSON.stringify(realUrl)}, __binder.namespace, __binder.set, __binder.
     emitWarning(err)
   }
 
-  /**
-   * @param {string} url
-   * @param {LoadContext} context
-   * @param {(url: string, context?: Partial<LoadContext>) => LoadResult | Promise<LoadResult>} parentGetSource
-   */
   async function getSource (url, context, parentGetSource) {
     if (hasIitm(url)) {
       const realUrl = deleteIitm(url)
       const originalSpecifier = specifiers.get(realUrl)
-      if (originalSpecifier === undefined) {
-        specifiers.delete(url)
-        return parentGetSource(url, context)
-      }
 
       try {
-        const { setters, originNamespaces } = await driveAsync(
+        const setters = await driveAsync(
           processModule({ srcUrl: realUrl, context }),
           { resolve: cachedResolve, load: parentGetSource }
         )
-        return { source: onWrapSuccess(realUrl, context, originalSpecifier, setters, originNamespaces) }
+        return { source: onWrapSuccess(realUrl, context, originalSpecifier, setters) }
       } catch (cause) {
         onWrapFailure(realUrl, cause)
         // Revert back to the non-iitm URL
@@ -728,26 +703,17 @@ register(${JSON.stringify(realUrl)}, __binder.namespace, __binder.set, __binder.
   // Synchronous counterpart to `getSource`, for `module.registerHooks`. Drives
   // `processModule` straight through; all bookkeeping and source generation is
   // shared with `getSource`.
-  /**
-   * @param {string} url
-   * @param {LoadContext} context
-   * @param {(url: string, context?: Partial<LoadContext>) => LoadResult} nextLoad
-   */
   function getSourceSync (url, context, nextLoad) {
     if (hasIitm(url)) {
       const realUrl = deleteIitm(url)
       const originalSpecifier = specifiers.get(realUrl)
-      if (originalSpecifier === undefined) {
-        specifiers.delete(url)
-        return nextLoad(url, context)
-      }
 
       try {
-        const { setters, originNamespaces } = driveSync(
+        const setters = driveSync(
           processModule({ srcUrl: realUrl, context }),
           { resolve: cachedResolve, load: nextLoad }
         )
-        return { source: onWrapSuccess(realUrl, context, originalSpecifier, setters, originNamespaces) }
+        return { source: onWrapSuccess(realUrl, context, originalSpecifier, setters) }
       } catch (cause) {
         onWrapFailure(realUrl, cause)
         url = realUrl