@contrast/agent 5.0.8 → 5.2.0

package/lib/check-flag-vs-node-version.mjs

@@ -21,13 +21,19 @@ export default function checkImportVsLoaderVsNodeVersion() {
   // allow testing to ignore these restrictions
   const noValidate = process.env.CSI_EXPOSE_CORE === 'no-validate';
   let flag;
+  const { execArgv, version, env: { NODE_OPTIONS } } = process;
 
-  const { execArgv, version } = process;
   // eslint-disable-next-line newline-per-chained-call
   const [major, minor] = version.slice(1).split('.').map(Number);
-  for (let i = 0; i < execArgv.length; i++) {
-    const loader = execArgv[i];
-    const agent = execArgv[i + 1];
+
+  const _execArgs = [
+    ...(NODE_OPTIONS?.split?.(/\s+/).map((v) => v.trim()) || []),
+    ...execArgv,
+  ]
+
+  for (let i = 0; i < _execArgs.length; i++) {
+    const loader = _execArgs[i];
+    const agent = _execArgs[i + 1];
     if (['--import', '--loader', '--experimental-loader'].includes(loader) && agent?.startsWith('@contrast/agent')) {
       flag = loader;
       if (noValidate) {

package/lib/esm-hooks.mjs

@@ -28,229 +28,233 @@ if (process.env.CSI_HOOKS_LOG) {
 const [major, minor] = process.versions.node.split('.').map(it => +it);
 const isLT16_12 = major < 16 || (major === 16 && minor < 12);
 
+
+// from esmock: git@github.com:iambumblehead/esmock.git
+//
+// new versions of node: when multiple loaders are used and context
+// is passed to nextResolve, the process crashes in a recursive call
+// see: /esmock/issues/#48
+//
+// old versions of node: if context.parentURL is defined, and context
+// is not passed to nextResolve, the tests fail
+//
+// later versions of node v16 include 'node-addons'
+async function protectedNextResolve(nextResolve, specifier, context) {
+  if (context.parentURL) {
+    if (context.conditions.at(-1) === 'node-addons' || context.importAssertions || isLT16_12) {
+      return nextResolve(specifier, context);
+    }
+  }
+
+  return nextResolve(specifier);
+}
+
 // import.meta.resolve('node-fetch') v20 became synchronous. not all that useful for now because
 // of the significant break in behavior. but the function is great - it resolves a specifier to the
 // file that would be loaded.
 // file:///home/bruce/github/csi/rasp-v3/node_modules/node-fetch/src/index.js
 
 const { default: core } = await import('./initialize.mjs');
-const { esmHooks: { mappings, fixPath, getFileType } } = core;
-
-const initialize = Module.register && async function(data) {
-  if (data?.port) {
-    data.port.on('message', _msg => {
-      // we don't currently send messages to the loader thread but when we do,
-      // this is where they will show up.
-      //console.log('ESM HOOK -> INIT -> MESSAGE', _msg);
-    });
-    data.port.postMessage({ type: 'keep-alive', data: 'hello from esm-hooks' });
-    data.port.unref();
-    // this is running in the loader thread. save thread info because it can't
-    // be set from the main thread.
-    if (W.isMainThread) {
-      throw new Error('initialize() called from main thread.');
+let load, resolve, initialize;
+
+if (core) {
+  const { esmHooks: { mappings, fixPath, getFileType } } = core;
+  initialize = Module.register && async function(data) {
+    if (data?.port) {
+      data.port.on('message', _msg => {
+        // we don't currently send messages to the loader thread but when we do,
+        // this is where they will show up.
+        //console.log('ESM HOOK -> INIT -> MESSAGE', _msg);
+      });
+      data.port.postMessage({ type: 'keep-alive', data: 'hello from esm-hooks' });
+      data.port.unref();
+      // this is running in the loader thread. save thread info because it can't
+      // be set from the main thread.
+      if (W.isMainThread) {
+        throw new Error('initialize() called from main thread.');
+      }
+      core.threadInfo.isMainThread = false;
+      core.threadInfo.threadId = W.threadId;
+      core.threadInfo.port = data.port;
+      // the loader thread's post() sends via the port.
+      core.threadInfo.post = (type, data) => {
+        core.threadInfo.port.postMessage({ type, data });
+      };
     }
-    core.threadInfo.isMainThread = false;
-    core.threadInfo.threadId = W.threadId;
-    core.threadInfo.port = data.port;
-    // the loader thread's post() sends via the port.
-    core.threadInfo.post = (type, data) => {
-      core.threadInfo.port.postMessage({ type, data });
-    };
-  }
 
-  log && console.log('ESM HOOK -> INIT');
-  // it's not clear to me why Module is present when initialize() is being
-  // executed in the loader thread. but it is. (code here originally loaded
-  // Module via createRequire(), but that is not necessary.)
-  const originalRequire = Module.prototype.require;
-  const originalCompile = Module.prototype._compile;
-  const originalExtensions = Module._extensions['.js'];
-  const originalLoad = Module._load;
-
-  // Module needs to be patched in the loader thread too. initialize() runs in
-  // that context.
-  Module.prototype.require = function(moduleId) {
-    (log & logRequireAll) && console.log(`CJS(init ${W.threadId}) -> require(${moduleId})`);
-    return originalRequire.call(this, moduleId);
-  };
+    log && console.log('ESM HOOK -> INIT');
+    // it's not clear to me why Module is present when initialize() is being
+    // executed in the loader thread. but it is. (code here originally loaded
+    // Module via createRequire(), but that is not necessary.)
+    const originalRequire = Module.prototype.require;
+    const originalCompile = Module.prototype._compile;
+    const originalExtensions = Module._extensions['.js'];
+    const originalLoad = Module._load;
+
+    // Module needs to be patched in the loader thread too. initialize() runs in
+    // that context.
+    Module.prototype.require = function(moduleId) {
+      (log & logRequireAll) && console.log(`CJS(init ${W.threadId}) -> require(${moduleId})`);
+      return originalRequire.call(this, moduleId);
+    };
 
-  Module.prototype._compile = function(code, filename) {
-    (log & logRequireAll) && console.log(`CJS(init ${W.threadId}) -> _compile(${filename})`);
-    return originalCompile.call(this, code, filename);
-  };
+    Module.prototype._compile = function(code, filename) {
+      (log & logRequireAll) && console.log(`CJS(init ${W.threadId}) -> _compile(${filename})`);
+      return originalCompile.call(this, code, filename);
+    };
 
-  Module._extensions['.js'] = function(module, filename) {
-    (log & logRequireAll) && console.log(`CJS(init ${W.threadId}) -> _extensions[".js"]: ${filename}`);
-    return originalExtensions.call(this, module, filename);
-  };
+    Module._extensions['.js'] = function(module, filename) {
+      (log & logRequireAll) && console.log(`CJS(init ${W.threadId}) -> _extensions[".js"]: ${filename}`);
+      return originalExtensions.call(this, module, filename);
+    };
 
-  Module._load = function(request, parent, isMain) {
-    (log & logLoad) && console.log(`CJS(init ${W.threadId}) -> _load(${request})`);
-    return originalLoad.call(this, request, parent, isMain);
+    Module._load = function(request, parent, isMain) {
+      (log & logLoad) && console.log(`CJS(init ${W.threadId}) -> _load(${request})`);
+      return originalLoad.call(this, request, parent, isMain);
+    };
   };
-};
 
-const resolve = async function(specifier, context, nextResolve) {
-  (log & logResolve) && console.log(`ESM HOOK(${W.threadId}) -> RESOLVE -> ${specifier}`);
-  let isFlaggedToPatch = false;
-  if (context.parentURL) {
-    isFlaggedToPatch = context.parentURL.endsWith('csi-flag=', context.parentURL.length - 1);
-  }
+  resolve = async function(specifier, context, nextResolve) {
+    (log & logResolve) && console.log(`ESM HOOK(${W.threadId}) -> RESOLVE -> ${specifier}`);
+    let isFlaggedToPatch = false;
+    if (context.parentURL) {
+      isFlaggedToPatch = context.parentURL.endsWith('csi-flag=', context.parentURL.length - 1);
+    }
 
-  // this needs to be generalized so it uses the execArgv value. the idea is to
-  // capture when the application actually starts. is this needed? i don't think so
-  // because the loaders aren't instantiated until esm-loader.mjs returns/register()s
-  // the hooks. i am leaving the comment here as a breadcrumb in case we need to
-  // capture the application start time. but we could 1) look at process.argv, 2)
-  // find the first argument, and 3) notice when that's loaded and capture that
-  // "now we are in the user's application".
-  //
-  //if (false) debugger;
-  //if (log & logApplication) {
-  //  const RE = /test-integration-servers\/express.m?js(\?.+)?$/;
-  //  if (specifier.match(RE) || context.parentURL?.match(RE)) {
-  //    console.log(`ESM HOOK(${W.threadId}) -> RESOLVE -> ${specifier} from ${context.parentURL}`);
-  //  }
-  //}
-
-  // this works for most of what we need to patch because they are not esm-native
-  // modules. but for esm-native modules, e.g., node-fetch, this won't work. they
-  // will need to be patched in the loader thread.
-  //
-  // We could walk up the parent chain to see if we should interpret this specifier
-  // as a module or commonjs, but it seems more straightforward to just always
-  // redirect. walking up the parent chain would let us avoid redirecting commonjs
-  // files. we could also call nextResolve() and let node tell us type of the file
-  // is but that would potentially create problems when other hooks, e.g., datadog,
-  // are in place.
-  //
-  // also we could check to see if this module's already been patched and skip this.
-  // not sure of that though; it might get loaded as a module, not a commonjs file,
-  // and that would be a problem. so when we start patching esm-native modules, we'll
-  // need a second "already patched" weakmap.
-  if (!isFlaggedToPatch && specifier in mappings) {
-    // eslint-disable-next-line prefer-const
-    let { url, format, target } = mappings[specifier];
-    // set flag to module or commonjs. i'm not sure this is needed but am keeping it
-    // in place until we have to implement esm-native module rewrites/wrapping. this
-    // is the point at which resolve() communicates to load().
+    // this needs to be generalized so it uses the execArgv value. the idea is to
+    // capture when the application actually starts. is this needed? i don't think so
+    // because the loaders aren't instantiated until esm-loader.mjs returns/register()s
+    // the hooks. i am leaving the comment here as a breadcrumb in case we need to
+    // capture the application start time. but we could 1) look at process.argv, 2)
+    // find the first argument, and 3) notice when that's loaded and capture that
+    // "now we are in the user's application".
+    //
+    //if (false) debugger;
+    //if (log & logApplication) {
+    //  const RE = /test-integration-servers\/express.m?js(\?.+)?$/;
+    //  if (specifier.match(RE) || context.parentURL?.match(RE)) {
+    //    console.log(`ESM HOOK(${W.threadId}) -> RESOLVE -> ${specifier} from ${context.parentURL}`);
+    //  }
+    //}
+
+    // this works for most of what we need to patch because they are not esm-native
+    // modules. but for esm-native modules, e.g., node-fetch, this won't work. they
+    // will need to be patched in the loader thread.
     //
-    // builtin's are probably the most likely to be loaded, so they're first.
-    // some tweaks might be needed when we start to patch esm-native modules
-    // in esm-native-code:
-    // https://nodejs.org/docs/latest-v20.x/api/esm.html#builtin-modules
-    // https://nodejs.org/docs/latest-v20.x/api/module.html#modulesyncbuiltinesmexports
-    if (target === 'builtin') {
-      url = `${url.href}?csi-flag=m`;
-      format = 'module';
-    } else if (target === 'commonjs') {
-      url = `${url.href}?csi-flag=c`;
-      format = getFileType(url) || format || 'commonjs';
-    } else if (target === 'module') {
-      url = `${url.href}?csi-flag=m`;
-      format = getFileType(url) || format || 'module';
-    } else {
-      throw new Error(`unexpected target ${target} for ${specifier}`);
+    // We could walk up the parent chain to see if we should interpret this specifier
+    // as a module or commonjs, but it seems more straightforward to just always
+    // redirect. walking up the parent chain would let us avoid redirecting commonjs
+    // files. we could also call nextResolve() and let node tell us type of the file
+    // is but that would potentially create problems when other hooks, e.g., datadog,
+    // are in place.
+    //
+    // also we could check to see if this module's already been patched and skip this.
+    // not sure of that though; it might get loaded as a module, not a commonjs file,
+    // and that would be a problem. so when we start patching esm-native modules, we'll
+    // need a second "already patched" weakmap.
+    if (!isFlaggedToPatch && specifier in mappings) {
+      // eslint-disable-next-line prefer-const
+      let { url, format, target } = mappings[specifier];
+      // set flag to module or commonjs. i'm not sure this is needed but am keeping it
+      // in place until we have to implement esm-native module rewrites/wrapping. this
+      // is the point at which resolve() communicates to load().
+      //
+      // builtin's are probably the most likely to be loaded, so they're first.
+      // some tweaks might be needed when we start to patch esm-native modules
+      // in esm-native-code:
+      // https://nodejs.org/docs/latest-v20.x/api/esm.html#builtin-modules
+      // https://nodejs.org/docs/latest-v20.x/api/module.html#modulesyncbuiltinesmexports
+      if (target === 'builtin') {
+        url = `${url.href}?csi-flag=m`;
+        format = 'module';
+      } else if (target === 'commonjs') {
+        url = `${url.href}?csi-flag=c`;
+        format = getFileType(url) || format || 'commonjs';
+      } else if (target === 'module') {
+        url = `${url.href}?csi-flag=m`;
+        format = getFileType(url) || format || 'module';
+      } else {
+        throw new Error(`unexpected target ${target} for ${specifier}`);
+      }
+
+      return {
+        url,
+        format,
+        shortCircuit: true,
+      };
     }
 
-    return {
-      url,
-      format,
-      shortCircuit: true,
-    };
-  }
-
-  return protectedNextResolve(nextResolve, specifier, context);
-};
-
-// readFile is a live binding. we need to capture it so it won't be
-// altered by any patching later.
-const readFile = rf;
-
-const load = async function(url, context, nextLoad) {
-  (log & logLoad) && console.log(`ESM HOOK(${W.threadId}) -> LOAD ${url}`);
+    return protectedNextResolve(nextResolve, specifier, context);
+  };
 
-  const urlObject = new URL(url);
+  // readFile is a live binding. we need to capture it so it won't be
+  // altered by any patching later.
+  const readFile = rf;
 
-  if (urlObject.searchParams.has('csi-flag')) {
-    // target type will, i think, be used to determine if this will require extra
-    // processing of some sort for esm-native modules.
-    // eslint-disable-next-line no-unused-vars
-    const targetType = urlObject.searchParams.get('csi-flag');
-    const { pathname } = urlObject;
+  load = async function(url, context, nextLoad) {
+    (log & logLoad) && console.log(`ESM HOOK(${W.threadId}) -> LOAD ${url}`);
 
-    (log & logLoad) && console.log(`ESM HOOK(${W.threadId}) -> LOAD -> CSI FLAG ${pathname}`);
+    const urlObject = new URL(url);
 
-    const source = await readFile(fixPath(pathname), 'utf8');
-    return {
-      source,
-      format: 'module',
-      shortCircuit: true,
-    };
-  }
+    if (urlObject.searchParams.has('csi-flag')) {
+      // target type will, i think, be used to determine if this will require extra
+      // processing of some sort for esm-native modules.
+      // eslint-disable-next-line no-unused-vars
+      const targetType = urlObject.searchParams.get('csi-flag');
+      const { pathname } = urlObject;
 
-  if (urlObject.pathname.endsWith('.node')) {
-    const metaUrl = JSON.stringify(url);
-    const addon = urlObject.pathname;
-    return {
-      source: `require("node:module").createRequire(${metaUrl})("${addon}")`,
-      format: 'commonjs',
-      shortCircuit: true,
-    };
-  }
+      (log & logLoad) && console.log(`ESM HOOK(${W.threadId}) -> LOAD -> CSI FLAG ${pathname}`);
 
-  // if it's not a builtin, a .node addon, or a flagged file, it needs to be
-  // rewritten if it's a module.
-  if (urlObject.pathname.match(/(.js|.mjs|.cjs)$/)) {
-    // if it's not a module it will be rewritten by the require hooks.
-    const type = getFileType(urlObject);
-    if (type !== 'module') {
-      return nextLoad(url, context);
+      const source = await readFile(fixPath(pathname), 'utf8');
+      return {
+        source,
+        format: 'module',
+        shortCircuit: true,
+      };
     }
 
-    const filename = fixPath(urlObject.pathname);
-    const source = await readFile(filename, 'utf8');
-
-    const rewriteOptions = {
-      filename,
-      isModule: type === 'module',
-      inject: true,
-      wrap: type !== 'module', // cannot wrap modules
-    };
-
-    core.threadInfo.post('rewrite', rewriteOptions);
-
-    const result = core.rewriter.rewrite(source, rewriteOptions);
-
-    return {
-      source: result.code,
-      format: type || 'commonjs', // don't know what else to do here. log?
-      shortCircuit: true,
-    };
-  }
-  // this never gets called, so hmmm.
-  return nextLoad(url, context);
-};
-
-// from esmock: git@github.com:iambumblehead/esmock.git
-//
-// new versions of node: when multiple loaders are used and context
-// is passed to nextResolve, the process crashes in a recursive call
-// see: /esmock/issues/#48
-//
-// old versions of node: if context.parentURL is defined, and context
-// is not passed to nextResolve, the tests fail
-//
-// later versions of node v16 include 'node-addons'
-async function protectedNextResolve(nextResolve, specifier, context) {
-  if (context.parentURL) {
-    if (context.conditions.at(-1) === 'node-addons' || context.importAssertions || isLT16_12) {
-      return nextResolve(specifier, context);
+    if (urlObject.pathname.endsWith('.node')) {
+      const metaUrl = JSON.stringify(url);
+      const addon = urlObject.pathname;
+      return {
+        source: `require("node:module").createRequire(${metaUrl})("${addon}")`,
+        format: 'commonjs',
+        shortCircuit: true,
+      };
     }
-  }
 
-  return nextResolve(specifier);
+    // if it's not a builtin, a .node addon, or a flagged file, it needs to be
+    // rewritten if it's a module.
+    if (urlObject.pathname.match(/(.js|.mjs|.cjs)$/)) {
+      // if it's not a module it will be rewritten by the require hooks.
+      const type = getFileType(urlObject);
+      if (type !== 'module') {
+        return nextLoad(url, context);
+      }
+
+      const filename = fixPath(urlObject.pathname);
+      const source = await readFile(filename, 'utf8');
+
+      const rewriteOptions = {
+        filename,
+        isModule: type === 'module',
+        inject: true,
+        wrap: type !== 'module', // cannot wrap modules
+      };
+
+      core.threadInfo.post('rewrite', rewriteOptions);
+
+      const result = core.rewriter.rewrite(source, rewriteOptions);
+
+      return {
+        source: result.code,
+        format: type || 'commonjs', // don't know what else to do here. log?
+        shortCircuit: true,
+      };
+    }
+    // this never gets called, so hmmm.
+    return nextLoad(url, context);
+  };
 }
 
 export {

package/lib/esm-loader.mjs

@@ -16,7 +16,7 @@
 import Module from 'node:module';
 import W from 'node:worker_threads';
 import EventEmitter from 'node:events';
-
+import * as hooks from './esm-hooks.mjs';
 import checkImportVsLoaderVsNodeVersion from './check-flag-vs-node-version.mjs';
 
 // might need to get exclude function here as opposed to deep within initialize
@@ -37,6 +37,7 @@ if (process.env.CSI_HOOKS_LOG) {
 
 // verify that we're running with the correct flag for the version of node.
 const { flag, msg } = checkImportVsLoaderVsNodeVersion();
+
 if (msg) {
   console.error(msg);
   throw new Error(msg);
@@ -50,11 +51,11 @@ if (msg) {
 // Module. I don't think this will be called more than once, but the flag is
 // in place just in case.
 //
-let core;
 
-if (!core) {
-  core = (await import('./initialize.mjs')).default;
+const core = (await import('./initialize.mjs')).default;
+let load, resolve;
 
+if (core) {
   // most of this can be removed; it's here for debugging. but considering the relatively
   // low cost compared with loading a module, i'm leaving it in.
   (log & logRequireAll) && console.log('ESM-LOADER executing CJS Module patching');
@@ -85,75 +86,76 @@ if (!core) {
     (log & logLoad) && console.log(`CJS(${W.threadId}) -> _load() ${request}`);
     return originalLoad.call(this, request, parent, isMain);
   };
-}
 
-core.threadInfo.syncEmitter = new EventEmitter();
-// abstract how notifications are posted so that the non-loader
-// code is not coupled to the implementation. the loader-thread
-// complement of this is in esm-hooks.
-//
-// specifically, this is the main thread and post() directly emits
-// the event while in the loader thread post() uses post.postMessage()
-// to communicate back to this (the main) thread.
-core.threadInfo.post = (type, data) => {
-  core.threadInfo.syncEmitter.emit(type, data);
-};
+  core.threadInfo.syncEmitter = new EventEmitter();
+  // abstract how notifications are posted so that the non-loader
+  // code is not coupled to the implementation. the loader-thread
+  // complement of this is in esm-hooks.
+  //
+  // specifically, this is the main thread and post() directly emits
+  // the event while in the loader thread post() uses post.postMessage()
+  // to communicate back to this (the main) thread.
+  core.threadInfo.post = (type, data) => {
+    core.threadInfo.syncEmitter.emit(type, data);
+  };
 
-//
-// setup ESM hooks
-//
-// if register exists this is 20.6.0 or later. we do not support
-// node 20 prior to 20.6.0 (or 20.9.0 when 20 became LTS).
-// news flash: backported register to node 18.19.0, so checking register
-// is no longer enough.
-//
-if (Module.register && flag === '--import') {
-  // this file should never be executed in the loader thread; this file creates
-  // the loader thread by calling register(). the loader thread must create its
-  // own copy of threadInfo and insert it into core.
-  if (!core.threadInfo.isMainThread) {
-    // only get an error in CI on node v18.
-    throw new Error('esm-loader.mjs should not be executed in the loader thread');
-  }
-  const { MessageChannel } = await import('node:worker_threads');
-  const { port1, port2 } = new MessageChannel();
-
-
-  core.threadInfo.port = port1;
-  // messages received on the port are re-emitted as standard node events. the
-  // body must contain the type; data can be undefined.
-  core.threadInfo.missingTypeCount = 0;
-  core.threadInfo.port.on('message', (body) => {
-    const { type, data } = body;
-    if (type) {
-      core.threadInfo.syncEmitter.emit(type, data);
-    } else {
-      core.threadInfo.missingTypeCount += 1;
+  //
+  // setup ESM hooks
+  //
+  // if register exists this is 20.6.0 or later. we do not support
+  // node 20 prior to 20.6.0 (or 20.9.0 when 20 became LTS).
+  // news flash: backported register to node 18.19.0, so checking register
+  // is no longer enough.
+  //
+  if (Module.register && flag === '--import') {
+    // this file should never be executed in the loader thread; this file creates
+    // the loader thread by calling register(). the loader thread must create its
+    // own copy of threadInfo and insert it into core.
+    if (!core.threadInfo.isMainThread) {
+      // only get an error in CI on node v18.
+      throw new Error('esm-loader.mjs should not be executed in the loader thread');
     }
-  });
-  core.threadInfo.port.unref();
-
-  // record the URL of the entry point.
-  core.threadInfo.url = import.meta.url;
-
-  // get relative URL
-  const url = new URL('./esm-hooks.mjs', import.meta.url);
-  await Module.register(url.href, import.meta.url, { data: { port: port2 }, transferList: [port2] });
-
-  // we only need to do this if there is a background thread.
-  // The esmHooks component of the main agent will send TS settings update to the loader agent via the port.
-  // To get the loader agent components to update we just need to forward the settings using `.messages` emitter.
-  core.messages.on(Event.SERVER_SETTINGS_UPDATE, (msg) => {
-    core.threadInfo.port.postMessage({
-      type: Event.SERVER_SETTINGS_UPDATE,
-      ...msg,
+    const { MessageChannel } = await import('node:worker_threads');
+    const { port1, port2 } = new MessageChannel();
+
+
+    core.threadInfo.port = port1;
+    // messages received on the port are re-emitted as standard node events. the
+    // body must contain the type; data can be undefined.
+    core.threadInfo.missingTypeCount = 0;
+    core.threadInfo.port.on('message', (body) => {
+      const { type, data } = body;
+      if (type) {
+        core.threadInfo.syncEmitter.emit(type, data);
+      } else {
+        core.threadInfo.missingTypeCount += 1;
+      }
     });
-  });
+    core.threadInfo.port.unref();
+
+    // record the URL of the entry point.
+    core.threadInfo.url = import.meta.url;
+
+    // get relative URL
+    const url = new URL('./esm-hooks.mjs', import.meta.url);
+    await Module.register(url.href, import.meta.url, { data: { port: port2 }, transferList: [port2] });
+
+    // we only need to do this if there is a background thread.
+    // The esmHooks component of the main agent will send TS settings update to the loader agent via the port.
+    // To get the loader agent components to update we just need to forward the settings using `.messages` emitter.
+    core.messages.on(Event.SERVER_SETTINGS_UPDATE, (msg) => {
+      core.threadInfo.port.postMessage({
+        type: Event.SERVER_SETTINGS_UPDATE,
+        ...msg,
+      });
+    });
+  }
+  // it's not possible to conditionally export, but exporting undefined
+  // values is close.
+
+
+  const finalHooks = (Module.register && flag === '--import') ? {} : hooks;
+  ({ load, resolve } = finalHooks);
 }
 
-// it's not possible to conditionally export, but exporting undefined
-// values is close.
-import * as hooks from './esm-hooks.mjs';
-const finalHooks = (Module.register && flag === '--import') ? {} : hooks;
-const { load, resolve } = finalHooks;
 export { load, resolve };

package/lib/initialize.mjs

@@ -74,11 +74,11 @@ if (!core) {
 
   core = await loadModules({ core, options: {} });
 
-  core = await startAgent({ core, options: { executor, installOrder } });
+  if (core) core = await startAgent({ core, options: { executor, installOrder } });
 
   // self identification
   // for communications between the main and loader thread (if present)
-  core.threadInfo = {
+  if (core) core.threadInfo = {
     isMainThread,
     threadId,
     port: undefined, // filled in if there's a loader thread
@@ -89,10 +89,8 @@ if (!core) {
     const coreKey = Symbol.for('contrast:core');
     global[coreKey] = core;
   }
-
 }
 
-
 export default core;
 
 async function executor(core) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrast/agent",
-  "version": "5.0.8",
+  "version": "5.2.0",
   "description": "Assess and Protect agents for Node.js",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Contrast Security <nodejs@contrastsecurity.com> (https://www.contrastsecurity.com)",
@@ -21,13 +21,13 @@
     "test": "../scripts/test.sh"
   },
   "dependencies": {
-    "@contrast/agentify": "1.19.2",
-    "@contrast/architecture-components": "1.15.0",
-    "@contrast/assess": "1.22.0",
-    "@contrast/library-analysis": "1.16.0",
-    "@contrast/protect": "1.31.1",
-    "@contrast/route-coverage": "1.15.1",
-    "@contrast/telemetry": "1.3.1",
+    "@contrast/agentify": "1.20.0",
+    "@contrast/architecture-components": "1.16.0",
+    "@contrast/assess": "1.24.0",
+    "@contrast/library-analysis": "1.17.0",
+    "@contrast/protect": "1.32.0",
+    "@contrast/route-coverage": "1.16.0",
+    "@contrast/telemetry": "1.4.0",
     "semver": "^7.3.7"
   }
 }