@venos-inc/venos 0.1.5 → 0.1.7

package/etc/mcp-server/node_modules/vitest/dist/chunks/worker.d.CUgIPz9V.d.ts

@@ -0,0 +1,176 @@
+import { File, TestAnnotation, TaskResultPack, TaskEventPack, CancelReason, FileSpecification, Task } from '@vitest/runner';
+import { ViteNodeResolveId, ModuleCacheMap, ModuleExecutionInfo } from 'vite-node';
+import { a as SerializedConfig } from './config.d.BKdhh7Zx.js';
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.cL3nLXbE.js';
+import { SnapshotResult } from '@vitest/snapshot';
+
+type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
+interface ChannelOptions {
+    /**
+     * Function to post raw message
+     */
+    post: (data: any, ...extras: any[]) => any | Promise<any>;
+    /**
+     * Listener to receive raw message
+     */
+    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Clear the listener when `$close` is called
+     */
+    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<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';
+}
+interface EventOptions<Remote> {
+    /**
+     * Names of remote functions that do not need response.
+     */
+    eventNames?: (keyof Remote)[];
+    /**
+     * Maximum timeout for waiting for response, in milliseconds.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom resolver to resolve function to be called
+     *
+     * For advanced use cases only
+     */
+    resolver?: BirpcResolver;
+    /**
+     * Custom error handler
+     *
+     * @deprecated use `onFunctionError` and `onGeneralError` instead
+     */
+    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred in local functions being called
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onFunctionError?: (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?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
+    /**
+     * Custom error handler for timeouts
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+};
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+    $close: (error?: Error) => void;
+    $closed: boolean;
+};
+
+interface RuntimeRPC {
+	fetch: (id: string, transformMode: TransformMode) => Promise<{
+		externalize?: string
+		id?: string
+	}>;
+	transform: (id: string, transformMode: TransformMode) => Promise<{
+		code?: string
+	}>;
+	resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
+		external?: boolean | "absolute" | "relative"
+		id: string
+		/** @deprecated */
+		meta?: Record<string, any> | null
+		/** @deprecated */
+		moduleSideEffects?: boolean | "no-treeshake" | null
+		/** @deprecated */
+		syntheticNamedExports?: boolean | string | null
+	} | null>;
+	/**
+	* @deprecated unused
+	*/
+	getSourceMap: (id: string, force?: boolean) => Promise<any>;
+	onUserConsoleLog: (log: UserConsoleLog) => void;
+	onUnhandledError: (err: unknown, type: string) => void;
+	onQueued: (file: File) => void;
+	onCollected: (files: File[]) => Promise<void>;
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	onTaskAnnotate: (testId: string, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	onCancel: (reason: CancelReason) => void;
+	getCountOfFailedTests: () => number;
+	snapshotSaved: (snapshot: SnapshotResult) => void;
+	resolveSnapshotPath: (testPath: string) => string;
+}
+interface RunnerRPC {
+	onCancel: (reason: CancelReason) => void;
+}
+
+/** @deprecated unused */
+type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
+interface ContextTestEnvironment {
+	name: string;
+	transformMode?: TransformMode;
+	options: Record<string, any> | null;
+}
+type TestExecutionMethod = "run" | "collect";
+interface ContextRPC {
+	pool: string;
+	worker: string;
+	workerId: number;
+	config: SerializedConfig;
+	projectName: string;
+	files: string[] | FileSpecification[];
+	environment: ContextTestEnvironment;
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+}
+interface WorkerGlobalState {
+	ctx: ContextRPC;
+	config: SerializedConfig;
+	rpc: WorkerRPC;
+	current?: Task;
+	filepath?: string;
+	environment: Environment;
+	environmentTeardownRun?: boolean;
+	onCancel: Promise<CancelReason>;
+	moduleCache: ModuleCacheMap;
+	moduleExecutionInfo?: ModuleExecutionInfo;
+	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, RuntimeRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, BirpcReturn as a, WorkerRPC as b, RunnerRPC as c, ContextTestEnvironment as d, ResolveIdFunction as e };

package/etc/mcp-server/node_modules/vitest/dist/chunks/{worker.B9FxPCaC.d.ts → worker.d.uzWsCv9X.d.ts}

@@ -1,8 +1,8 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.tN5KGIih.js';
+import { C as ContextRPC } from './worker.d.CUgIPz9V.js';
 
 interface WorkerContext extends ContextRPC {
-    port: MessagePort;
+	port: MessagePort;
 }
 
 export type { WorkerContext as W };

package/etc/mcp-server/node_modules/vitest/dist/cli.js

@@ -1,8 +1,27 @@
-import { c as createCLI } from './chunks/cac.CB_9Zo9Q.js';
+import { c as createCLI } from './chunks/cac.0BJqEUeA.js';
 import '@vitest/utils';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
-import './chunks/constants.fzPh7AOq.js';
+import './chunks/constants.DnKduX2e.js';
+import './chunks/index.VByaPkjc.js';
+import 'node:perf_hooks';
+import '@vitest/runner/utils';
+import '@vitest/utils/source-map';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
+import './chunks/typechecker.DRKU1-1g.js';
+import 'node:os';
+import 'tinyexec';
+import './path.js';
+import 'node:path';
+import 'node:url';
+import 'vite';
+import 'node:util';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:console';
+import 'node:stream';
+import 'node:module';
 
 createCLI().parse();

package/etc/mcp-server/node_modules/vitest/dist/config.cjs

@@ -4,143 +4,133 @@ var os = require('node:os');
 var stdEnv = require('std-env');
 var vite = require('vite');
 
+// if changed, update also jsdocs and docs
 const defaultBrowserPort = 63315;
 const extraInlineDeps = [
-  /^(?!.*node_modules).*\.mjs$/,
-  /^(?!.*node_modules).*\.cjs\.js$/,
-  // Vite client
-  /vite\w*\/dist\/client\/env.mjs/
+	/^(?!.*node_modules).*\.mjs$/,
+	/^(?!.*node_modules).*\.cjs\.js$/,
+	/vite\w*\/dist\/client\/env.mjs/
 ];
 
 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;
 
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
 const defaultExclude = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/cypress/**",
-  "**/.{idea,git,cache,output,temp}/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/cypress/**",
+	"**/.{idea,git,cache,output,temp}/**",
+	"**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
 ];
 const defaultCoverageExcludes = [
-  "coverage/**",
-  "dist/**",
-  "**/node_modules/**",
-  "**/[.]**",
-  "packages/*/test?(s)/**",
-  "**/*.d.ts",
-  "**/virtual:*",
-  "**/__x00__*",
-  "**/\0*",
-  "cypress/**",
-  "test?(s)/**",
-  "test?(-*).?(c|m)[jt]s?(x)",
-  "**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
-  "**/__tests__/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
-  "**/vitest.{workspace,projects}.[jt]s?(on)",
-  "**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
+	"coverage/**",
+	"dist/**",
+	"**/node_modules/**",
+	"**/[.]**",
+	"packages/*/test?(s)/**",
+	"**/*.d.ts",
+	"**/virtual:*",
+	"**/__x00__*",
+	"**/\0*",
+	"cypress/**",
+	"test?(s)/**",
+	"test?(-*).?(c|m)[jt]s?(x)",
+	"**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
+	"**/__tests__/**",
+	"**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
+	"**/vitest.{workspace,projects}.[jt]s?(on)",
+	"**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
 ];
+// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
 const coverageConfigDefaults = {
-  provider: "v8",
-  enabled: false,
-  all: true,
-  clean: true,
-  cleanOnRerun: true,
-  reportsDirectory: "./coverage",
-  exclude: defaultCoverageExcludes,
-  reportOnFailure: false,
-  reporter: [
-    ["text", {}],
-    ["html", {}],
-    ["clover", {}],
-    ["json", {}]
-  ],
-  extension: [
-    ".js",
-    ".cjs",
-    ".mjs",
-    ".ts",
-    ".mts",
-    ".tsx",
-    ".jsx",
-    ".vue",
-    ".svelte",
-    ".marko",
-    ".astro"
-  ],
-  allowExternal: false,
-  excludeAfterRemap: false,
-  ignoreEmptyLines: true,
-  processingConcurrency: Math.min(
-    20,
-    os.availableParallelism?.() ?? os.cpus().length
-  )
+	provider: "v8",
+	enabled: false,
+	all: true,
+	clean: true,
+	cleanOnRerun: true,
+	reportsDirectory: "./coverage",
+	exclude: defaultCoverageExcludes,
+	reportOnFailure: false,
+	reporter: [
+		["text", {}],
+		["html", {}],
+		["clover", {}],
+		["json", {}]
+	],
+	extension: [
+		".js",
+		".cjs",
+		".mjs",
+		".ts",
+		".mts",
+		".tsx",
+		".jsx",
+		".vue",
+		".svelte",
+		".marko",
+		".astro"
+	],
+	allowExternal: false,
+	excludeAfterRemap: false,
+	ignoreEmptyLines: true,
+	processingConcurrency: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
 };
 const fakeTimersDefaults = {
-  loopLimit: 1e4,
-  shouldClearNativeTimers: true,
-  toFake: [
-    "setTimeout",
-    "clearTimeout",
-    "setInterval",
-    "clearInterval",
-    "setImmediate",
-    "clearImmediate",
-    "Date"
-  ]
+	loopLimit: 1e4,
+	shouldClearNativeTimers: true
 };
-const config = {
-  allowOnly: !stdEnv.isCI,
-  isolate: true,
-  watch: !stdEnv.isCI,
-  globals: false,
-  environment: "node",
-  pool: "forks",
-  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
-};
-const configDefaults = Object.freeze(config);
+const configDefaults = Object.freeze({
+	allowOnly: !stdEnv.isCI,
+	isolate: true,
+	watch: !stdEnv.isCI && process.stdin.isTTY,
+	globals: false,
+	environment: "node",
+	pool: "forks",
+	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;
+	return config;
 }
 function defineProject(config) {
-  return config;
+	return config;
 }
+/**
+* @deprecated use the `projects` field in the root config instead
+*/
 function defineWorkspace(config) {
-  return config;
+	return config;
 }
 
 Object.defineProperty(exports, "mergeConfig", {

package/etc/mcp-server/node_modules/vitest/dist/config.d.ts

@@ -1,79 +1,82 @@
 import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { R as ResolvedCoverageOptions, c as CoverageV8Options, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport, W as WorkspaceProjectConfiguration } from './chunks/reporters.nr4dxCkA.js';
-import './chunks/vite.CzKp4x9w.js';
+import { c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport, b as TestProjectConfiguration } from './chunks/reporters.d.BuRON0I0.js';
+export { f as TestProjectInlineConfiguration, g as WatcherTriggerPattern, W as WorkspaceProjectConfiguration } from './chunks/reporters.d.BuRON0I0.js';
+import './chunks/vite.d.BnOPPc46.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.BKdhh7Zx.js';
 import '@vitest/runner';
-import './chunks/environment.LoooBwUu.js';
-import 'node:stream';
+import './chunks/environment.d.cL3nLXbE.js';
+import 'vitest/optional-types.js';
 import '@vitest/utils';
-import './chunks/config.Cy0C388Z.js';
-import '@vitest/pretty-format';
-import '@vitest/snapshot';
-import '@vitest/snapshot/environment';
+import 'node:stream';
+import 'node:console';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import './chunks/worker.d.CUgIPz9V.js';
 import 'vite-node';
+import '@vitest/snapshot';
+import '@vitest/pretty-format';
+import '@vitest/utils/diff';
 import 'chai';
-import '@vitest/utils/source-map';
-import 'vite-node/client';
-import 'vite-node/server';
-import './chunks/benchmark.geERunq4.js';
+import './chunks/benchmark.d.BwvBVTda.js';
 import '@vitest/runner/utils';
 import 'tinybench';
+import './chunks/coverage.d.S9RMNXIe.js';
+import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'node:fs';
+import '@vitest/snapshot/environment';
 
 declare const defaultBrowserPort = 63315;
 declare const extraInlineDeps: RegExp[];
 
 declare const defaultInclude: string[];
 declare const defaultExclude: string[];
+// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
 declare const coverageConfigDefaults: ResolvedCoverageOptions;
 declare const configDefaults: Readonly<{
-    allowOnly: boolean;
-    isolate: true;
-    watch: boolean;
-    globals: false;
-    environment: "node";
-    pool: "forks";
-    clearMocks: false;
-    restoreMocks: false;
-    mockReset: false;
-    unstubGlobals: false;
-    unstubEnvs: false;
-    include: string[];
-    exclude: string[];
-    teardownTimeout: number;
-    forceRerunTriggers: string[];
-    update: false;
-    reporters: never[];
-    silent: false;
-    hideSkippedTests: false;
-    api: false;
-    ui: false;
-    uiBase: string;
-    open: boolean;
-    css: {
-        include: never[];
-    };
-    coverage: CoverageV8Options;
-    fakeTimers: {
-        loopLimit: number;
-        shouldClearNativeTimers: true;
-        toFake: ("setTimeout" | "setInterval" | "clearInterval" | "clearTimeout" | "setImmediate" | "clearImmediate" | "Date")[];
-    };
-    maxConcurrency: number;
-    dangerouslyIgnoreUnhandledErrors: false;
-    typecheck: {
-        checker: "tsc";
-        include: string[];
-        exclude: string[];
-    };
-    slowTestThreshold: number;
-    disableConsoleIntercept: false;
+	allowOnly: boolean
+	isolate: boolean
+	watch: boolean
+	globals: boolean
+	environment: "node"
+	pool: "forks"
+	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
 }>;
 
 /**
- * @deprecated Use `ViteUserConfig` instead
- */
+* @deprecated Use `ViteUserConfig` instead
+*/
 type UserConfig = UserConfig$1;
 
 type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;
@@ -88,6 +91,10 @@ 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;
-declare function defineWorkspace(config: WorkspaceProjectConfiguration[]): WorkspaceProjectConfiguration[];
+/**
+* @deprecated use the `projects` field in the root config instead
+*/
+declare function defineWorkspace(config: TestProjectConfiguration[]): TestProjectConfiguration[];
 
-export { type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, WorkspaceProjectConfiguration, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };
+export { TestProjectConfiguration, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };
+export type { UserConfig, UserConfigExport, UserConfigFn, UserConfigFnObject, UserConfigFnPromise };