@harness-engineering/cli 1.1.1 → 1.2.0

package/dist/agents/skills/node_modules/vitest/dist/chunks/worker.d.Dyxm8DEL.d.ts

@@ -1,255 +0,0 @@
-import { FileSpecification, Task, CancelReason } from '@vitest/runner';
-import { EvaluatedModules } from 'vite/module-runner';
-import { S as SerializedConfig } from './config.d.Cy95HiCx.js';
-import { E as Environment } from './environment.d.CrsxCzP1.js';
-import { R as RuntimeRPC, a as RunnerRPC } from './rpc.d.RH3apGEf.js';
-
-//#region src/messages.d.ts
-declare const TYPE_REQUEST: "q";
-interface RpcRequest {
-  /**
-   * Type
-   */
-  t: typeof TYPE_REQUEST;
-  /**
-   * ID
-   */
-  i?: string;
-  /**
-   * Method
-   */
-  m: string;
-  /**
-   * Arguments
-   */
-  a: any[];
-  /**
-   * Optional
-   */
-  o?: boolean;
-}
-//#endregion
-//#region src/utils.d.ts
-type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
-type ReturnType<T> = T extends ((...args: any) => infer R) ? R : never;
-type Thenable<T> = T | PromiseLike<T>;
-//#endregion
-//#region src/main.d.ts
-type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
-type BirpcResolver<This> = (this: This, name: string, resolved: (...args: unknown[]) => unknown) => Thenable<((...args: any[]) => any) | undefined>;
-interface ChannelOptions {
-  /**
-   * Function to post raw message
-   */
-  post: (data: any, ...extras: any[]) => Thenable<any>;
-  /**
-   * Listener to receive raw message
-   */
-  on: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
-  /**
-   * Clear the listener when `$close` is called
-   */
-  off?: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
-  /**
-   * Custom function to serialize data
-   *
-   * by default it passes the data as-is
-   */
-  serialize?: (data: any) => any;
-  /**
-   * Custom function to deserialize data
-   *
-   * by default it passes the data as-is
-   */
-  deserialize?: (data: any) => any;
-  /**
-   * Call the methods with the RPC context or the original functions object
-   */
-  bind?: 'rpc' | 'functions';
-  /**
-   * Custom meta data to attached to the RPC instance's `$meta` property
-   */
-  meta?: any;
-}
-interface EventOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> {
-  /**
-   * Names of remote functions that do not need response.
-   */
-  eventNames?: (keyof RemoteFunctions)[];
-  /**
-   * Maximum timeout for waiting for response, in milliseconds.
-   *
-   * @default 60_000
-   */
-  timeout?: number;
-  /**
-   * Whether to proxy the remote functions.
-   *
-   * When `proxify` is false, calling the remote function
-   * with `rpc.$call('method', ...args)` instead of `rpc.method(...args)`
-   * explicitly is required.
-   *
-   * @default true
-   */
-  proxify?: Proxify;
-  /**
-   * Custom resolver to resolve function to be called
-   *
-   * For advanced use cases only
-   */
-  resolver?: BirpcResolver<BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>>;
-  /**
-   * Hook triggered before an event is sent to the remote
-   *
-   * @param req - Request parameters
-   * @param next - Function to continue the request
-   * @param resolve - Function to resolve the response directly
-   */
-  onRequest?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, req: RpcRequest, next: (req?: RpcRequest) => Promise<any>, resolve: (res: any) => void) => void | Promise<void>;
-  /**
-   * Custom error handler for errors occurred in local functions being called
-   *
-   * @returns `true` to prevent the error from being thrown
-   */
-  onFunctionError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName: string, args: any[]) => boolean | void;
-  /**
-   * Custom error handler for errors occurred during serialization or messsaging
-   *
-   * @returns `true` to prevent the error from being thrown
-   */
-  onGeneralError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName?: string, args?: any[]) => boolean | void;
-  /**
-   * Custom error handler for timeouts
-   *
-   * @returns `true` to prevent the error from being thrown
-   */
-  onTimeoutError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, functionName: string, args: any[]) => boolean | void;
-}
-type BirpcOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = EventOptions<RemoteFunctions, LocalFunctions, Proxify> & ChannelOptions;
-type BirpcFn<T> = PromisifyFn<T> & {
-  /**
-   * Send event without asking for response
-   */
-  asEvent: (...args: ArgumentsType<T>) => Promise<void>;
-};
-interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, unknown>> {
-  /**
-   * Raw functions object
-   */
-  $functions: LocalFunctions;
-  /**
-   * Whether the RPC is closed
-   */
-  readonly $closed: boolean;
-  /**
-   * Custom meta data attached to the RPC instance
-   */
-  readonly $meta: any;
-  /**
-   * Close the RPC connection
-   */
-  $close: (error?: Error) => void;
-  /**
-   * Reject pending calls
-   */
-  $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
-  /**
-   * Call the remote function and wait for the result.
-   * An alternative to directly calling the function
-   */
-  $call: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]>>>;
-  /**
-   * Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
-   */
-  $callOptional: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]> | undefined>>;
-  /**
-   * Send event without asking for response
-   */
-  $callEvent: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<void>;
-  /**
-   * Call the remote function with the raw options.
-   */
-  $callRaw: (options: {
-    method: string;
-    args: unknown[];
-    event?: boolean;
-    optional?: boolean;
-  }) => Promise<Awaited<ReturnType<any>>[]>;
-}
-type ProxifiedRemoteFunctions<RemoteFunctions extends object = Record<string, unknown>> = { [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]> };
-type BirpcReturn<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = Proxify extends true ? ProxifiedRemoteFunctions<RemoteFunctions> & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions> : BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
-type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
-interface PromiseEntry {
-  resolve: (arg: any) => void;
-  reject: (error: any) => void;
-  method: string;
-  timeoutId?: ReturnType<typeof setTimeout>;
-}
-declare const setTimeout: typeof globalThis.setTimeout;
-
-type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
-interface ContextTestEnvironment {
-	name: string;
-	options: Record<string, any> | null;
-}
-interface WorkerTestEnvironment {
-	name: string;
-	options: Record<string, any> | null;
-}
-type TestExecutionMethod = "run" | "collect";
-interface WorkerExecuteContext {
-	files: FileSpecification[];
-	providedContext: Record<string, any>;
-	invalidates?: string[];
-	environment: ContextTestEnvironment;
-	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
-	workerId: number;
-}
-interface ContextRPC {
-	pool: string;
-	config: SerializedConfig;
-	projectName: string;
-	environment: WorkerTestEnvironment;
-	rpc: WorkerRPC;
-	files: FileSpecification[];
-	providedContext: Record<string, any>;
-	invalidates?: string[];
-	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
-	workerId: number;
-}
-interface WorkerSetupContext {
-	environment: WorkerTestEnvironment;
-	pool: string;
-	config: SerializedConfig;
-	projectName: string;
-	rpc: WorkerRPC;
-}
-interface WorkerGlobalState {
-	ctx: ContextRPC;
-	config: SerializedConfig;
-	rpc: WorkerRPC;
-	current?: Task;
-	filepath?: string;
-	metaEnv: {
-		[key: string]: any;
-		BASE_URL: string;
-		MODE: string;
-		DEV: boolean;
-		PROD: boolean;
-		SSR: boolean;
-	};
-	environment: Environment;
-	evaluatedModules: EvaluatedModules;
-	resolvingModules: Set<string>;
-	moduleExecutionInfo: Map<string, any>;
-	onCancel: (listener: (reason: CancelReason) => unknown) => void;
-	onCleanup: (listener: () => unknown) => void;
-	providedContext: Record<string, any>;
-	durations: {
-		environment: number;
-		prepare: number;
-	};
-	onFilterStackTrace?: (trace: string) => string;
-}
-
-export type { BirpcOptions as B, ContextRPC as C, TestExecutionMethod as T, WorkerGlobalState as W, WorkerSetupContext as a, BirpcReturn as b, ContextTestEnvironment as c, WorkerExecuteContext as d, WorkerTestEnvironment as e };

package/dist/agents/skills/node_modules/vitest/dist/cli.js

@@ -1,28 +0,0 @@
-import { c as createCLI } from './chunks/cac.DVeoLl0M.js';
-import '@vitest/utils/helpers';
-import 'events';
-import 'pathe';
-import 'tinyrainbow';
-import './chunks/constants.D_Q9UYh-.js';
-import './chunks/index.M8mOzt4Y.js';
-import 'node:fs';
-import 'node:fs/promises';
-import 'node:perf_hooks';
-import '@vitest/runner/utils';
-import '@vitest/utils/source-map';
-import './chunks/env.D4Lgay0q.js';
-import 'std-env';
-import 'node:util';
-import 'node:console';
-import 'node:stream';
-import '@vitest/utils/display';
-import 'node:os';
-import 'tinyexec';
-import './path.js';
-import 'node:path';
-import 'node:url';
-import 'vite';
-import '@vitest/utils/offset';
-import 'node:module';
-
-createCLI().parse();

package/dist/agents/skills/node_modules/vitest/dist/config.cjs

@@ -1,94 +0,0 @@
-'use strict';
-
-var os = require('node:os');
-var stdEnv = require('std-env');
-var vite = require('vite');
-
-const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
-const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
-(isNode || isDeno) && process.platform === "win32";
-(isNode || isDeno) && process.stdout?.isTTY && !stdEnv.isCI;
-
-// if changed, update also jsdocs and docs
-const defaultBrowserPort = 63315;
-
-const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
-const defaultExclude = ["**/node_modules/**", "**/.git/**"];
-// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
-const coverageConfigDefaults = {
-	provider: "v8",
-	enabled: false,
-	clean: true,
-	cleanOnRerun: true,
-	reportsDirectory: "./coverage",
-	exclude: [],
-	reportOnFailure: false,
-	reporter: [
-		["text", {}],
-		["html", {}],
-		["clover", {}],
-		["json", {}]
-	],
-	allowExternal: false,
-	excludeAfterRemap: false,
-	processingConcurrency: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
-};
-const fakeTimersDefaults = {
-	loopLimit: 1e4,
-	shouldClearNativeTimers: true
-};
-const configDefaults = Object.freeze({
-	allowOnly: !stdEnv.isCI,
-	isolate: true,
-	watch: !stdEnv.isCI && process.stdin.isTTY,
-	globals: false,
-	environment: "node",
-	clearMocks: false,
-	restoreMocks: false,
-	mockReset: false,
-	unstubGlobals: false,
-	unstubEnvs: false,
-	include: defaultInclude,
-	exclude: defaultExclude,
-	teardownTimeout: 1e4,
-	forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
-	update: false,
-	reporters: [],
-	silent: false,
-	hideSkippedTests: false,
-	api: false,
-	ui: false,
-	uiBase: "/__vitest__/",
-	open: !stdEnv.isCI,
-	css: { include: [] },
-	coverage: coverageConfigDefaults,
-	fakeTimers: fakeTimersDefaults,
-	maxConcurrency: 5,
-	dangerouslyIgnoreUnhandledErrors: false,
-	typecheck: {
-		checker: "tsc",
-		include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
-		exclude: defaultExclude
-	},
-	slowTestThreshold: 300,
-	disableConsoleIntercept: false
-});
-
-function defineConfig(config) {
-	return config;
-}
-function defineProject(config) {
-	return config;
-}
-
-Object.defineProperty(exports, "mergeConfig", {
-  enumerable: true,
-  get: function () { return vite.mergeConfig; }
-});
-exports.configDefaults = configDefaults;
-exports.coverageConfigDefaults = coverageConfigDefaults;
-exports.defaultBrowserPort = defaultBrowserPort;
-exports.defaultExclude = defaultExclude;
-exports.defaultInclude = defaultInclude;
-exports.defineConfig = defineConfig;
-exports.defineProject = defineProject;

package/dist/agents/skills/node_modules/vitest/dist/config.d.ts

@@ -1,104 +0,0 @@
-import { HookHandler, ConfigEnv, UserConfig } from 'vite';
-export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.CWXNI2jG.js';
-export { b as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.CWXNI2jG.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.CtqpEehP.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.Cy95HiCx.js';
-import '@vitest/runner';
-import '@vitest/utils';
-import './chunks/rpc.d.RH3apGEf.js';
-import '@vitest/snapshot';
-import 'vite/module-runner';
-import './chunks/traces.d.402V_yFI.js';
-import 'node:stream';
-import './chunks/browser.d.ChKACdzH.js';
-import './chunks/worker.d.Dyxm8DEL.js';
-import './chunks/environment.d.CrsxCzP1.js';
-import '@vitest/mocker';
-import '@vitest/utils/source-map';
-import 'vitest/browser';
-import '@vitest/pretty-format';
-import '@vitest/utils/diff';
-import '@vitest/expect';
-import 'vitest/optional-types.js';
-import './chunks/benchmark.d.DAaHLpsq.js';
-import '@vitest/runner/utils';
-import 'tinybench';
-import './chunks/coverage.d.BZtK59WP.js';
-import '@vitest/snapshot/manager';
-import 'node:console';
-import 'node:fs';
-
-type VitestInlineConfig = InlineConfig;
-declare module "vite" {
-	interface UserConfig {
-		/**
-		* Options for Vitest
-		*/
-		test?: VitestInlineConfig;
-	}
-	interface Plugin<A = any> {
-		configureVitest?: HookHandler<(context: VitestPluginContext) => void>;
-	}
-}
-
-declare const defaultBrowserPort = 63315;
-
-declare const defaultInclude: string[];
-declare const defaultExclude: string[];
-declare const coverageConfigDefaults: ResolvedCoverageOptions;
-declare const configDefaults: Readonly<{
-	allowOnly: boolean;
-	isolate: boolean;
-	watch: boolean;
-	globals: boolean;
-	environment: "node";
-	clearMocks: boolean;
-	restoreMocks: boolean;
-	mockReset: boolean;
-	unstubGlobals: boolean;
-	unstubEnvs: boolean;
-	include: string[];
-	exclude: string[];
-	teardownTimeout: number;
-	forceRerunTriggers: string[];
-	update: boolean;
-	reporters: never[];
-	silent: boolean;
-	hideSkippedTests: boolean;
-	api: boolean;
-	ui: boolean;
-	uiBase: string;
-	open: boolean;
-	css: {
-		include: never[];
-	};
-	coverage: CoverageV8Options;
-	fakeTimers: FakeTimerInstallOpts;
-	maxConcurrency: number;
-	dangerouslyIgnoreUnhandledErrors: boolean;
-	typecheck: {
-		checker: "tsc";
-		include: string[];
-		exclude: string[];
-	};
-	slowTestThreshold: number;
-	disableConsoleIntercept: boolean;
-}>;
-
-type ViteUserConfigFnObject = (env: ConfigEnv) => UserConfig;
-type ViteUserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
-type ViteUserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
-type ViteUserConfigExport = UserConfig | Promise<UserConfig> | ViteUserConfigFnObject | ViteUserConfigFnPromise | ViteUserConfigFn;
-declare function defineConfig(config: UserConfig): UserConfig;
-declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
-declare function defineConfig(config: ViteUserConfigFnObject): ViteUserConfigFnObject;
-declare function defineConfig(config: ViteUserConfigFnPromise): ViteUserConfigFnPromise;
-declare function defineConfig(config: ViteUserConfigExport): ViteUserConfigExport;
-declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
-declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<UserWorkspaceConfig>;
-declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
-declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
-
-export { UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject };
-export type { ViteUserConfigExport, ViteUserConfigFn, ViteUserConfigFnObject, ViteUserConfigFnPromise };

package/dist/agents/skills/node_modules/vitest/dist/config.js

@@ -1,15 +0,0 @@
-export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.BOqNVLsY.js';
-export { mergeConfig } from 'vite';
-export { d as defaultBrowserPort } from './chunks/constants.D_Q9UYh-.js';
-import 'node:os';
-import './chunks/env.D4Lgay0q.js';
-import 'std-env';
-
-function defineConfig(config) {
-	return config;
-}
-function defineProject(config) {
-	return config;
-}
-
-export { defineConfig, defineProject };

package/dist/agents/skills/node_modules/vitest/dist/coverage.d.ts

@@ -1,118 +0,0 @@
-import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, a as ReportContext } from './chunks/reporters.d.CWXNI2jG.js';
-import { TransformResult } from 'vite';
-import { A as AfterSuiteRunMeta } from './chunks/rpc.d.RH3apGEf.js';
-import '@vitest/runner';
-import '@vitest/utils';
-import 'node:stream';
-import './chunks/browser.d.ChKACdzH.js';
-import './chunks/traces.d.402V_yFI.js';
-import './chunks/worker.d.Dyxm8DEL.js';
-import 'vite/module-runner';
-import './chunks/config.d.Cy95HiCx.js';
-import '@vitest/pretty-format';
-import '@vitest/snapshot';
-import '@vitest/utils/diff';
-import './chunks/environment.d.CrsxCzP1.js';
-import '@vitest/mocker';
-import '@vitest/utils/source-map';
-import 'vitest/browser';
-import '@vitest/expect';
-import 'vitest/optional-types.js';
-import './chunks/benchmark.d.DAaHLpsq.js';
-import '@vitest/runner/utils';
-import 'tinybench';
-import './chunks/coverage.d.BZtK59WP.js';
-import '@vitest/snapshot/manager';
-import 'node:console';
-import 'node:fs';
-
-type Threshold = "lines" | "functions" | "statements" | "branches";
-interface ResolvedThreshold {
-	coverageMap: CoverageMap;
-	name: string;
-	thresholds: Partial<Record<Threshold, number | undefined>>;
-}
-/**
-* Holds info about raw coverage results that are stored on file system:
-*
-* ```json
-* "project-a": {
-*   "web": {
-*     "tests/math.test.ts": "coverage-1.json",
-*     "tests/utils.test.ts": "coverage-2.json",
-* //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
-*   },
-*   "ssr": { ... },
-*   "browser": { ... },
-* },
-* "project-b": ...
-* ```
-*/
-type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["environment"], {
-	[TestFilenames: string]: string;
-}>>;
-declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"istanbul" | "v8">> {
-	ctx: Vitest;
-	readonly name: "v8" | "istanbul";
-	version: string;
-	options: Options;
-	globCache: Map<string, boolean>;
-	coverageFiles: CoverageFiles;
-	pendingPromises: Promise<void>[];
-	coverageFilesDirectory: string;
-	roots: string[];
-	_initialize(ctx: Vitest): void;
-	/**
-	* Check if file matches `coverage.include` but not `coverage.exclude`
-	*/
-	isIncluded(_filename: string, root?: string): boolean;
-	private getUntestedFilesByRoot;
-	getUntestedFiles(testedFiles: string[]): Promise<string[]>;
-	createCoverageMap(): CoverageMap;
-	generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
-	parseConfigModule(_: string): Promise<{
-		generate: () => {
-			code: string;
-		};
-	}>;
-	resolveOptions(): Options;
-	clean(clean?: boolean): Promise<void>;
-	onAfterSuiteRun({ coverage, environment, projectName, testFiles }: AfterSuiteRunMeta): void;
-	readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
-		/** Callback invoked with a single coverage result */
-		onFileRead: (data: CoverageType) => void;
-		/** Callback invoked once all results of a project for specific transform mode are read */
-		onFinished: (project: Vitest["projects"][number], environment: string) => Promise<void>;
-		onDebug: ((...logs: any[]) => void) & {
-			enabled: boolean;
-		};
-	}): Promise<void>;
-	cleanAfterRun(): Promise<void>;
-	onTestFailure(): Promise<void>;
-	reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
-	reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
-	/**
-	* Constructs collected coverage and users' threshold options into separate sets
-	* where each threshold set holds their own coverage maps. Threshold set is either
-	* for specific files defined by glob pattern or global for all other files.
-	*/
-	private resolveThresholds;
-	/**
-	* Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
-	*/
-	private checkThresholds;
-	/**
-	* Check if current coverage is above configured thresholds and bump the thresholds if needed
-	*/
-	updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
-		thresholds: ResolvedThreshold[];
-		configurationFile: unknown;
-		onUpdate: () => void;
-	}): Promise<void>;
-	mergeReports(coverageMaps: unknown[]): Promise<void>;
-	hasTerminalReporter(reporters: ResolvedCoverageOptions["reporter"]): boolean;
-	toSlices<T>(array: T[], size: number): T[][];
-	createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<TransformResult | null | undefined>;
-}
-
-export { BaseCoverageProvider };

package/dist/agents/skills/node_modules/vitest/dist/coverage.js

@@ -1,23 +0,0 @@
-export { B as BaseCoverageProvider } from './chunks/coverage.AVPTjMgw.js';
-import 'node:fs';
-import 'node:path';
-import '@vitest/utils/helpers';
-import 'pathe';
-import 'picomatch';
-import 'tinyglobby';
-import 'tinyrainbow';
-import './chunks/defaults.BOqNVLsY.js';
-import 'node:os';
-import './chunks/env.D4Lgay0q.js';
-import 'std-env';
-import 'node:crypto';
-import 'node:url';
-import 'node:module';
-import 'node:process';
-import 'node:fs/promises';
-import 'node:assert';
-import 'node:v8';
-import 'node:util';
-import 'vite';
-import './chunks/constants.D_Q9UYh-.js';
-import './chunks/coverage.D_JHT54q.js';

package/dist/agents/skills/node_modules/vitest/dist/environments.d.ts

@@ -1,22 +0,0 @@
-import { E as Environment } from './chunks/environment.d.CrsxCzP1.js';
-export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.CrsxCzP1.js';
-import '@vitest/utils';
-
-declare const environments: {
-	"node": Environment;
-	"jsdom": Environment;
-	"happy-dom": Environment;
-	"edge-runtime": Environment;
-};
-
-interface PopulateOptions {
-	bindFunctions?: boolean;
-	additionalKeys?: string[];
-}
-declare function populateGlobal(global: any, win: any, options?: PopulateOptions): {
-	keys: Set<string>;
-	skipKeys: string[];
-	originals: Map<string | symbol, any>;
-};
-
-export { Environment, environments as builtinEnvironments, populateGlobal };

package/dist/agents/skills/node_modules/vitest/dist/environments.js

@@ -1,3 +0,0 @@
-export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.CyBMJtT7.js';
-import 'node:url';
-import 'node:console';