@contrast/agent-bundle 5.40.0 → 5.42.0

package/node_modules/@contrast/sec-obs/node_modules/@contrast/core/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "@contrast/core",
-  "version": "1.53.0",
-  "description": "Preconfigured Contrast agent core services and models",
-  "license": "SEE LICENSE IN LICENSE",
-  "author": "Contrast Security <nodejs@contrastsecurity.com> (https://www.contrastsecurity.com)",
-  "files": [
-    "lib/",
-    "!*.test.*",
-    "!tsconfig.*",
-    "!*.map"
-  ],
-  "types": "lib/index.d.ts",
-  "engines": {
-    "npm": ">=6.13.7 <7 || >= 8.3.1",
-    "node": ">= 16.9.1"
-  },
-  "scripts": {
-    "test": "bash ../scripts/test.sh"
-  },
-  "dependencies": {
-    "@contrast/common": "1.33.0",
-    "@contrast/config": "1.48.0",
-    "@contrast/find-package-json": "^1.1.0",
-    "@contrast/fn-inspect": "^4.3.0",
-    "@contrast/logger": "1.26.0",
-    "@contrast/patcher": "1.25.0",
-    "@contrast/perf": "1.3.1",
-    "@tsxper/crc32": "^2.1.3",
-    "axios": "^1.7.4",
-    "semver": "^7.6.0"
-  }
-}

package/node_modules/@contrast/sec-obs/node_modules/@contrast/dep-hooks/LICENSE

@@ -1,12 +0,0 @@
-Copyright: 2025 Contrast Security, Inc
-Contact: support@contrastsecurity.com
-License: Commercial
-
-NOTICE: This Software and the patented inventions embodied within may only be
-used as part of Contrast Security’s commercial offerings. Even though it is
-made available through public repositories, use of this Software is subject to
-the applicable End User Licensing Agreement found at
-https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-between Contrast Security and the End User. The Software may not be reverse
-engineered, modified, repackaged, sold, redistributed or otherwise used in a
-way not consistent with the End User License Agreement.

package/node_modules/@contrast/sec-obs/node_modules/@contrast/dep-hooks/README.md

@@ -1,94 +0,0 @@
-# @contrast/dep-hooks
-
-Intercept calls to `require` in order to modify or replace exports.
-
-## Usage
-
-### Class: `DepHooks`
-
-#### Instantiation
-
-```javascript
-const DepHooks = require('./lib');
-const depHooks = new DepHooks();
-```
-
-The `DepHooks` constructor accepts a [`pino`](https://github.com/pinojs/pino)
-logger as an argument.
-
-#### `.resolve(descriptor, ...handlers)`
-
-Options:
-
-- `descriptor`: This can be a string or an object describing the module you want
-  to intercept. If a string is used, or if the version field of the descriptor
-  isn't set, all versions of the described module will be matched. Descriptors
-  can have a `name`, `version`, and `file` property.
-
-- `handlers`: The remaning arguments are the handlers which will be invoked when
-  the described module is `require`'d. Each handler is passed the exported
-  module and metadata including the module's root directory and its name and
-  version as seen in its `package.json` file. If a handler returns a truthy
-  value, then that value will replace the return value of `require`.
-
-_**Note:**_ Registered handlers run _once_ per unique instance of an export
-matching a descriptor.
-
-#### `.install()`
-
-This will monkey-patch `Module.prototype.require` so that exports can be
-intercepted. The monkey-patching will only happen once regardless of how many
-times this is invoked.
-
-#### `.uninstall()`
-
-This will reset `Module.prototype.require` to its value before being
-monkey-patched by the instance.
-
-## Examples
-
-**Use case:** For `express` versions greater than or equal to 4, intercept the
-export of the package's `lib/view.js` file (relative to the package's base
-directory) and apply a tag to the exported function.
-
-```javascript
-const DepHooks = require('./lib');
-const depHooks = new DepHooks();
-depHooks.resolve(
-  {
-    name: 'express',
-    version: '>=4',
-    file: 'lib/view.js',
-  },
-  (xport, metadata) => {
-    // Read from the package.json:
-    // - metadata.name
-    // - metadata.version
-    // Absolute path to file:
-    // - metadata.packageDir
-
-    // xport === function View() { /*...*/ }
-    xport['I was intercepted'] = true;
-  },
-);
-```
-
-**Use case:** Intercept all versions of `body-parser` and replace the exported
-functions.
-
-```javascript
-const DepHooks = require('./lib');
-const depHooks = new DepHooks();
-depHooks.resolve({ name: 'body-parser' }, (xport, metadata) => {
-  // Read from the package.json:
-  // - metadata.name
-  // - metadata.version
-  // Absolute path to file:
-  // - metadata.packageDir
-
-  // xport === function bodyParser() { /*...*/ }
-  return function bodyParserReplacement() {
-    /*...*/
-  };
-});
-```

package/node_modules/@contrast/sec-obs/node_modules/@contrast/dep-hooks/lib/export-handler-registry.d.ts

@@ -1,121 +0,0 @@
-export = ExportHandlerRegistry;
-/**
- * @template {Object} T
- * @typedef {import('./export-hook-descriptor')<T>} ExportHookDescriptor
- */
-/**
- * @template {Object} T
- * @typedef {import('./export-hook-descriptor').Handler<T>} Handler
- */
-/**
- * @template {Object} T
- * @typedef {Object} HandlerData
- * @property {Handler<T>[]} handlers
- * @property {PackageFinder.Metadata} metadata
- */
-declare class ExportHandlerRegistry {
-    /**
-     * @param {Object} core
-     * @param {import('pino').Logger} core.logger
-     * @param {import('@contrast/common').Messages} core.messages
-     */
-    constructor({ logger, messages }: {
-        logger: import('pino').Logger;
-        messages: import('@contrast/common').Messages;
-    });
-    /** @type {import('pino').Logger} */
-    logger: import('pino').Logger;
-    /** @type {import('@contrast/common').Messages} */
-    messages: import('@contrast/common').Messages;
-    /**
-     * Contains all registered hooks that have been added by `.update()`
-     * Keyed by `shortname`.
-     * @type {Record<string, ExportHookDescriptor<any>[]>}
-     */
-    registered: Record<string, ExportHookDescriptor<any>[]>;
-    /**
-     * Contains all modules that have been resolved and are in require cache
-     * Keyed by absolute filename.
-     * @type {Record<string, HandlerData<any>>}
-     */
-    resolved: Record<string, HandlerData<any>>;
-    /**
-     * Keep track of package versions targeted by registered hooks.
-     * This is used to help to detect when unsupported package versions are loaded.
-     * ```
-     * Map(1) { '@some/lib' => Set(3) { '2', '3', '>=5 <9' } }
-     * ```
-     * @type {Map<string, Set<string>>}
-     */
-    hookedLibVersions: Map<string, Set<string>>;
-    /**
-     * Keep track of which unspported libs we've logged/reported.
-     * ```
-     * Set(2) { 'mongodb@45.67.89', 'express@0.0.1' }
-     * ```
-     * @type {Set<string>}
-     */
-    unsupportedLibsDetected: Set<string>;
-    /**
-     * Update the registry with the handler info for the given module name.
-     * This gets called when an agent registers a handler for a given module.
-     * @template {Object} T
-     * @param {ExportHookDescriptor<T>} info
-     * @returns {ExportHookDescriptor<T>[]}
-     */
-    update<T extends Object>(info: import("./export-hook-descriptor")<T>): import("./export-hook-descriptor")<T>[];
-    /**
-     * Defined as a class method to allow easy stubbing in tests.
-     * @param {string} request the string passed to require()
-     * @param {Module} parent the module executing require()
-     * @param {boolean} isMain indicates whether the module executing require() is the entry point
-     * @returns {string} fully resolved filename of the required module
-     */
-    resolveFilename(request: string, parent: Module, isMain: boolean): string;
-    /**
-     * Defined as a class method to allow easy stubbing in tests.
-     * @param {string} filename fully resolved filename of the required module
-     * @returns {PackageFinder.Metadata?}
-     */
-    resolveMetadata(filename: string): PackageFinder.Metadata | null;
-    /**
-     * Iterates all descriptors pertaining to the currently-loading export. It
-     * builds into the set of resolved paths the metadata and handlers for each
-     * handler that is applicable to the export.
-     * @template {Object} T
-     * @param {PackageFinder.Metadata} metadata module metadata
-     * @param {ExportHookDescriptor<T>[]} registered list of registered hooks
-     */
-    buildFromRegistry<T_1 extends Object>(metadata: PackageFinder.Metadata, registered: import("./export-hook-descriptor")<T_1>[]): void;
-    /**
-     * Returns registered handlers and the module metadata for a module that has
-     * registration for the version that is being required.
-     * @template {Object} T
-     * @param {PackageFinder.Metadata} metadata module metadata
-     * @return {HandlerData<T>=}
-     */
-    findModuleHandlerData<T_2 extends Object>(metadata: PackageFinder.Metadata): HandlerData<T_2> | undefined;
-    /**
-     * When an export is returned from a `require`, we want to resolve the name
-     * used as the param, e.g. "http" in `require('http')`, to a set of
-     * metadata and handlers that have been registered for exports by that name.
-     * @template {Object} T
-     * @param {string} request the string passed to require()
-     * @param {Module} parent the module executing require()
-     * @param {boolean} isMain indicates whether the module executing require() is the entry point
-     * @return {HandlerData<T>=}
-     */
-    query<T_3 extends Object>(request: string, parent: Module, isMain: boolean): HandlerData<T_3> | undefined;
-}
-declare namespace ExportHandlerRegistry {
-    export { ExportHookDescriptor, Handler, HandlerData };
-}
-type ExportHookDescriptor<T extends Object> = import('./export-hook-descriptor')<T>;
-type HandlerData<T extends Object> = {
-    handlers: Handler<T>[];
-    metadata: PackageFinder.Metadata;
-};
-import Module = require("module");
-import PackageFinder = require("./package-finder");
-type Handler<T extends Object> = import('./export-hook-descriptor').Handler<T>;
-//# sourceMappingURL=export-handler-registry.d.ts.map

package/node_modules/@contrast/sec-obs/node_modules/@contrast/dep-hooks/lib/export-handler-registry.js

@@ -1,206 +0,0 @@
-/*
- * Copyright: 2025 Contrast Security, Inc
- * Contact: support@contrastsecurity.com
- * License: Commercial
-
- * NOTICE: This Software and the patented inventions embodied within may only be
- * used as part of Contrast Security’s commercial offerings. Even though it is
- * made available through public repositories, use of this Software is subject to
- * the applicable End User Licensing Agreement found at
- * https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
- * between Contrast Security and the End User. The Software may not be reverse
- * engineered, modified, repackaged, sold, redistributed or otherwise used in a
- * way not consistent with the End User License Agreement.
- */
-// @ts-check
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-const Module = require('node:module');
-const semver = require('semver');
-const { Event } = require('@contrast/common');
-const PackageFinder = require('./package-finder');
-/**
- * @template {Object} T
- * @typedef {import('./export-hook-descriptor')<T>} ExportHookDescriptor
- */
-/**
- * @template {Object} T
- * @typedef {import('./export-hook-descriptor').Handler<T>} Handler
- */
-/**
- * @template {Object} T
- * @typedef {Object} HandlerData
- * @property {Handler<T>[]} handlers
- * @property {PackageFinder.Metadata} metadata
- */
-class ExportHandlerRegistry {
-    /**
-     * @param {Object} core
-     * @param {import('pino').Logger} core.logger
-     * @param {import('@contrast/common').Messages} core.messages
-     */
-    constructor({ logger, messages }) {
-        /** @type {import('pino').Logger} */
-        this.logger = logger;
-        /** @type {import('@contrast/common').Messages} */
-        this.messages = messages;
-        /**
-         * Contains all registered hooks that have been added by `.update()`
-         * Keyed by `shortname`.
-         * @type {Record<string, ExportHookDescriptor<any>[]>}
-         */
-        this.registered = {};
-        /**
-         * Contains all modules that have been resolved and are in require cache
-         * Keyed by absolute filename.
-         * @type {Record<string, HandlerData<any>>}
-         */
-        this.resolved = {};
-        /**
-         * Keep track of package versions targeted by registered hooks.
-         * This is used to help to detect when unsupported package versions are loaded.
-         * ```
-         * Map(1) { '@some/lib' => Set(3) { '2', '3', '>=5 <9' } }
-         * ```
-         * @type {Map<string, Set<string>>}
-         */
-        this.hookedLibVersions = new Map();
-        /**
-         * Keep track of which unspported libs we've logged/reported.
-         * ```
-         * Set(2) { 'mongodb@45.67.89', 'express@0.0.1' }
-         * ```
-         * @type {Set<string>}
-         */
-        this.unsupportedLibsDetected = new Set();
-    }
-    /**
-     * Update the registry with the handler info for the given module name.
-     * This gets called when an agent registers a handler for a given module.
-     * @template {Object} T
-     * @param {ExportHookDescriptor<T>} info
-     * @returns {ExportHookDescriptor<T>[]}
-     */
-    update(info) {
-        if (!this.registered[info.shortname]) {
-            this.registered[info.shortname] = [info];
-        }
-        else {
-            this.registered[info.shortname].push(info);
-        }
-        if (!this.hookedLibVersions.has(info.name)) {
-            this.hookedLibVersions.set(info.name, new Set([info.version]));
-        }
-        else {
-            // @ts-expect-error we've validated this above
-            this.hookedLibVersions.get(info.name).add(info.version);
-        }
-        return this.registered[info.shortname];
-    }
-    /**
-     * Defined as a class method to allow easy stubbing in tests.
-     * @param {string} request the string passed to require()
-     * @param {Module} parent the module executing require()
-     * @param {boolean} isMain indicates whether the module executing require() is the entry point
-     * @returns {string} fully resolved filename of the required module
-     */
-    resolveFilename(request, parent, isMain) {
-        return Reflect.get(Module, '_resolveFilename').apply(Module, [
-            request,
-            parent,
-            isMain,
-        ]);
-    }
-    /**
-     * Defined as a class method to allow easy stubbing in tests.
-     * @param {string} filename fully resolved filename of the required module
-     * @returns {PackageFinder.Metadata?}
-     */
-    resolveMetadata(filename) {
-        return PackageFinder.resolveMetadata(filename, this.logger);
-    }
-    /**
-     * Iterates all descriptors pertaining to the currently-loading export. It
-     * builds into the set of resolved paths the metadata and handlers for each
-     * handler that is applicable to the export.
-     * @template {Object} T
-     * @param {PackageFinder.Metadata} metadata module metadata
-     * @param {ExportHookDescriptor<T>[]} registered list of registered hooks
-     */
-    buildFromRegistry(metadata, registered) {
-        for (const descriptor of registered) {
-            const satisfies = semver.satisfies(metadata.version, descriptor.version, {
-                includePrerelease: true,
-            });
-            if (!satisfies)
-                continue;
-            const { handlers } = descriptor;
-            if (!this.resolved[metadata.file]) {
-                this.resolved[metadata.file] = { metadata, handlers };
-            }
-            else {
-                handlers.forEach((handler) => {
-                    if (this.resolved[metadata.file].handlers.indexOf(handler) < 0) {
-                        this.resolved[metadata.file].handlers.push(handler);
-                    }
-                });
-            }
-        }
-    }
-    /**
-     * Returns registered handlers and the module metadata for a module that has
-     * registration for the version that is being required.
-     * @template {Object} T
-     * @param {PackageFinder.Metadata} metadata module metadata
-     * @return {HandlerData<T>=}
-     */
-    findModuleHandlerData(metadata) {
-        const data = this.resolved[metadata.file];
-        // Need to check the version of the instrumentation handler to the one getting required
-        // to decide if we need they are version applicable
-        if (metadata.version === data?.metadata.version) {
-            return data;
-        }
-    }
-    /**
-     * When an export is returned from a `require`, we want to resolve the name
-     * used as the param, e.g. "http" in `require('http')`, to a set of
-     * metadata and handlers that have been registered for exports by that name.
-     * @template {Object} T
-     * @param {string} request the string passed to require()
-     * @param {Module} parent the module executing require()
-     * @param {boolean} isMain indicates whether the module executing require() is the entry point
-     * @return {HandlerData<T>=}
-     */
-    query(request, parent, isMain) {
-        const filename = this.resolveFilename(request, parent, isMain);
-        const metadata = this.resolveMetadata(filename);
-        if (!metadata)
-            return;
-        const versions = this.hookedLibVersions.get(metadata.name);
-        // no hooks registred for this package - exit early
-        if (!versions)
-            return;
-        const pkgKey = `${metadata.name}@${metadata.version}`;
-        let supported = false;
-        for (const version of versions) {
-            if (semver.satisfies(metadata.version, version)) {
-                supported = true;
-                break;
-            }
-        }
-        // make sure we only log/report once
-        if (!supported && !this.unsupportedLibsDetected.has(pkgKey)) {
-            this.unsupportedLibsDetected.add(pkgKey);
-            this.logger.trace({ metadata }, 'skipping handlers since package %s does not match any registered versions', pkgKey);
-            this.messages.emit(Event.UNSUPPORTED_LIBRARY, metadata);
-        }
-        const registered = this.registered[metadata.shortname];
-        if (!registered)
-            return;
-        this.buildFromRegistry(metadata, registered);
-        return this.findModuleHandlerData(metadata);
-    }
-}
-module.exports = ExportHandlerRegistry;
-//# sourceMappingURL=export-handler-registry.js.map

package/node_modules/@contrast/sec-obs/node_modules/@contrast/dep-hooks/lib/export-hook-descriptor.d.ts

@@ -1,72 +0,0 @@
-export = ExportHookDescriptor;
-/** @typedef {import('./package-finder').Metadata} Metadata */
-/**
- * @typedef {Object} HookControls
- * @property {() => void} rerun
- */
-/**
- * @template {Object} T
- * @callback Handler
- * @param {T} mod
- * @param {Metadata & HookControls} metadata
- * @returns {T | void}
- */
-/**
- * @typedef {Object} Descriptor
- * @property {string} name module name, as passed to `require`, to handle.
- * @property {string=} file if provided, the file under the module's root that we want to hook. otherwise, the module's `main` will be hooked.
- * @property {string} version if provided, hooks will only execute against an installed module that matches the semver version range
- */
-/**
- * Export information and function handlers that should be invoked on require
- * for a given module.
- * @template {Object} [T=any]
- */
-declare class ExportHookDescriptor<T extends Object = any> {
-    /**
-     * A static factory function for creating descriptors with different params.
-     * @template {Object} T
-     * @param {Descriptor | string} descriptor export info and handlers
-     * @param {Handler<T>[]=} handlers
-     * @returns {ExportHookDescriptor<T>}
-     */
-    static create<T_1 extends Object>(descriptor: Descriptor | string, handlers?: Handler<T_1>[] | undefined): ExportHookDescriptor<T_1>;
-    /**
-     * @param {Descriptor} options
-     * @param {Handler<T>[]} handlers
-     */
-    constructor({ name, file, version }: Descriptor, handlers: Handler<T>[]);
-    /** @type {string} */
-    name: string;
-    /** @type {string=} */
-    file: string | undefined;
-    /** @type {string} */
-    shortname: string;
-    /** @type {string} */
-    version: string;
-    /** @type {Handler<T>[]} */
-    handlers: Handler<T>[];
-}
-declare namespace ExportHookDescriptor {
-    export { Metadata, HookControls, Handler, Descriptor };
-}
-type Handler<T extends Object> = (mod: T, metadata: Metadata & HookControls) => T | void;
-type Metadata = import('./package-finder').Metadata;
-type HookControls = {
-    rerun: () => void;
-};
-type Descriptor = {
-    /**
-     * module name, as passed to `require`, to handle.
-     */
-    name: string;
-    /**
-     * if provided, the file under the module's root that we want to hook. otherwise, the module's `main` will be hooked.
-     */
-    file?: string | undefined;
-    /**
-     * if provided, hooks will only execute against an installed module that matches the semver version range
-     */
-    version: string;
-};
-//# sourceMappingURL=export-hook-descriptor.d.ts.map

package/node_modules/@contrast/sec-obs/node_modules/@contrast/dep-hooks/lib/export-hook-descriptor.js

@@ -1,88 +0,0 @@
-/*
- * Copyright: 2025 Contrast Security, Inc
- * Contact: support@contrastsecurity.com
- * License: Commercial
-
- * NOTICE: This Software and the patented inventions embodied within may only be
- * used as part of Contrast Security’s commercial offerings. Even though it is
- * made available through public repositories, use of this Software is subject to
- * the applicable End User Licensing Agreement found at
- * https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
- * between Contrast Security and the End User. The Software may not be reverse
- * engineered, modified, repackaged, sold, redistributed or otherwise used in a
- * way not consistent with the End User License Agreement.
- */
-// @ts-check
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require('node:path');
-const semver = require('semver');
-const { isBuiltin } = require('./helpers');
-const { primordials: { StringPrototypeReplace } } = require('@contrast/common');
-/** @typedef {import('./package-finder').Metadata} Metadata */
-/**
- * @typedef {Object} HookControls
- * @property {() => void} rerun
- */
-/**
- * @template {Object} T
- * @callback Handler
- * @param {T} mod
- * @param {Metadata & HookControls} metadata
- * @returns {T | void}
- */
-/**
- * @typedef {Object} Descriptor
- * @property {string} name module name, as passed to `require`, to handle.
- * @property {string=} file if provided, the file under the module's root that we want to hook. otherwise, the module's `main` will be hooked.
- * @property {string} version if provided, hooks will only execute against an installed module that matches the semver version range
- */
-/**
- * Export information and function handlers that should be invoked on require
- * for a given module.
- * @template {Object} [T=any]
- */
-class ExportHookDescriptor {
-    /**
-     * @param {Descriptor} options
-     * @param {Handler<T>[]} handlers
-     */
-    constructor({ name, file, version }, handlers) {
-        /** @type {string} */
-        // @ts-ignore ts does not handle method overloads well
-        this.name = isBuiltin(name) ? StringPrototypeReplace.call(name, /^(node:)?/, 'node:') : name;
-        /** @type {string=} */
-        // @ts-ignore ts does not handle method overloads well
-        this.file = file ? StringPrototypeReplace.call(file, /\/?(index)?(\.js)?$/, '') : undefined;
-        /** @type {string} */
-        this.shortname = this.file ? path.posix.join(this.name, this.file) : this.name;
-        /** @type {string} */
-        this.version = version;
-        /** @type {Handler<T>[]} */
-        this.handlers = handlers;
-    }
-    /**
-     * A static factory function for creating descriptors with different params.
-     * @template {Object} T
-     * @param {Descriptor | string} descriptor export info and handlers
-     * @param {Handler<T>[]=} handlers
-     * @returns {ExportHookDescriptor<T>}
-     */
-    static create(descriptor, handlers = []) {
-        if (!descriptor) {
-            throw new Error('Required option missing: `name`');
-        }
-        if (typeof descriptor === 'string') {
-            descriptor = { name: descriptor, version: '*' };
-        }
-        if (!descriptor.name) {
-            throw new Error('Required option missing: `name`');
-        }
-        if (!semver.validRange(descriptor.version)) {
-            throw new Error(`Invalid version range provided: "${descriptor.version}"`);
-        }
-        return Reflect.construct(ExportHookDescriptor, [descriptor, handlers]);
-    }
-}
-module.exports = ExportHookDescriptor;
-//# sourceMappingURL=export-hook-descriptor.js.map

package/node_modules/@contrast/sec-obs/node_modules/@contrast/dep-hooks/lib/handler-invoker.d.ts

@@ -1,46 +0,0 @@
-export = HandlerInvoker;
-/**
- * @template {Object} T
- * @typedef {import('./export-hook-descriptor').Handler<T>} Handler
- */
-/** @typedef {import('./package-finder').Metadata} Metadata */
-declare class HandlerInvoker {
-    /**
-     * @param {import('pino').Logger} logger
-     */
-    constructor(logger: import('pino').Logger);
-    /** @type {import('pino').Logger} */
-    logger: import('pino').Logger;
-    /** @type {WeakMap<Object, WeakSet<Handler<any>>>} */
-    seen: WeakMap<Object, WeakSet<Handler<any>>>;
-    /**
-     * Filters a collection of handlers to those which have not run for the
-     * provided export.
-     * @template {Object} T
-     * @param {T} xport The exported module
-     * @param {Handler<T>[]} handlers Collection of handlers
-     * @returns {Handler<T>[]}
-     */
-    filter<T extends Object>(xport: T, handlers: Handler<T>[]): Handler<T>[];
-    /**
-     * Invoke all handlers in the provided collection that have not yet been run
-     * for the provided export value.
-     * @template {Object} T
-     * @param {T} xport The exported module
-     * @param {Handler<T>[]} handlers The handlers to invoke
-     * @param {Metadata} metadata Export metadata to pass to the handlers
-     * @returns {T}
-     */
-    invoke<T_1 extends Object>(xport: T_1, handlers: Handler<T_1>[], metadata: Metadata): T_1;
-    /**
-     * @template {Object} T
-     * @param {T} xport The exported module
-     */
-    reset<T_2 extends Object>(xport: T_2): void;
-}
-declare namespace HandlerInvoker {
-    export { Handler, Metadata };
-}
-type Handler<T extends Object> = import('./export-hook-descriptor').Handler<T>;
-type Metadata = import('./package-finder').Metadata;
-//# sourceMappingURL=handler-invoker.d.ts.map