fix(test): exclude @vitest/browser/context from vendor-aliases to fix missing server export (#1110)

## Summary

Fixes the missing `server` export from `@vitest/browser/context` when
using `@storybook/addon-vitest` with vite-plus.

resolve #1086

## Root Cause

In vitest's browser mode, `@vitest/browser/context` is a **virtual
module**, the `BrowserContext` plugin intercepts the bare specifier in
`resolveId` and returns dynamically generated code (via
`generateContextFile()`) that includes the `server` export with command
RPC proxies, config, platform info, etc.

However, vite-plus injects a `vitest:vendor-aliases` plugin during
re-packaging (in `build.ts`) that maps `@vitest/*` bare specifiers to
static files in the dist directory.

Both plugins use `enforce: 'pre'`, but `vendor-aliases` is registered
**before** `BrowserContext` in the plugin array.

Since Vite executes same-enforce plugins in registration order,
`vendor-aliases` resolves the bare specifier to the static `context.js`
file before `BrowserContext` ever sees it.

The static `context.js` only exports `{ cdp, createUserEvent, locators,
page, utils }` — it does **not** include `server`, because that's
supposed to come from the virtual module.

### Normal flow (plain vitest — no vendor-aliases)

```mermaid
sequenceDiagram
    participant Browser
    participant ViteServer as Vite Browser Server
    participant BC as BrowserContext Plugin<br/>(resolveId)
    participant Gen as generateContextFile()

    Browser->>ViteServer: import "@vitest/browser/context"
    ViteServer->>BC: resolveId("@vitest/browser/context")
    BC-->>ViteServer: "\0vitest/browser" (virtual module ID)
    ViteServer->>BC: load("\0vitest/browser")
    BC->>Gen: generateContextFile()
    Gen-->>BC: Dynamic code with server, commands, config...
    BC-->>ViteServer: Virtual module source
    ViteServer-->>Browser: Module with { server, page, cdp, ... }
```

### Bug flow (vite-plus — vendor-aliases intercepts first)

```mermaid
sequenceDiagram
    participant Browser
    participant ViteServer as Vite Browser Server
    participant VA as vendor-aliases Plugin<br/>(resolveId) ← runs first
    participant BC as BrowserContext Plugin<br/>(resolveId) ← never called

    Browser->>ViteServer: import "@vitest/browser/context"
    ViteServer->>VA: resolveId("@vitest/browser/context")
    VA-->>ViteServer: "/path/to/dist/@vitest/browser/context.js" (static file)
    Note over BC: resolveId is never called<br/>because vendor-aliases already resolved it
    ViteServer-->>Browser: Static file (no server export)
    Browser->>Browser: SyntaxError: does not provide<br/>an export named 'server'
```

### Plugin registration order in the browser Vite server

```
1. vitest:vendor-aliases              ← enforce:'pre', registered first
2. vitest:browser                     ← enforce:'pre'
3. vitest:browser:tests               ← enforce:'pre'
4. vitest:browser:virtual-module:context (BrowserContext) ← enforce:'pre', registered last
```

## Fix

Exclude `@vitest/browser/context` from the `vendor-aliases` plugin's
`vendorMap` during re-packaging (`build.ts`).

This allows the bare specifier to pass through to the `BrowserContext`
plugin, which correctly returns the virtual module with the `server`
export.

---------

Co-authored-by: MK (fengmk2) <fengmk2@gmail.com>

Author: kazupon

packages/test/__tests__/build-artifacts.spec.ts

@@ -0,0 +1,58 @@
+/**
+ * Verify that the @voidzero-dev/vite-plus-test build output (dist/)
+ * contains the expected files and that patches applied during the build
+ * (in build.ts) produce correct artifacts.
+ *
+ * This is important because vite-plus re-packages vitest with custom
+ * patches, and missing exports or incorrect patches can break
+ * third-party integrations (e.g., @storybook/addon-vitest, #1086).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+const testPkgDir = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), '..');
+const distDir = path.join(testPkgDir, 'dist');
+
+describe('build artifacts', () => {
+  describe('@vitest/browser/context.js', () => {
+    const contextPath = path.join(distDir, '@vitest/browser/context.js');
+
+    it('should exist', () => {
+      expect(fs.existsSync(contextPath), `${contextPath} should exist`).toBe(true);
+    });
+
+    it('should export page, cdp, and utils', () => {
+      const content = fs.readFileSync(contextPath, 'utf-8');
+      expect(content).toMatch(/export\s*\{[^}]*page[^}]*\}/);
+      expect(content).toMatch(/export\s*\{[^}]*cdp[^}]*\}/);
+      expect(content).toMatch(/export\s*\{[^}]*utils[^}]*\}/);
+    });
+  });
+
+  /**
+   * The vitest:vendor-aliases plugin must NOT resolve @vitest/browser/context
+   * to the static file. If it does, the BrowserContext plugin's virtual module
+   * (which provides the `server` export) is bypassed.
+   *
+   * See: https://github.com/voidzero-dev/vite-plus/issues/1086
+   */
+  describe('vitest:vendor-aliases plugin (regression test for #1086)', () => {
+    const browserIndexPath = path.join(distDir, '@vitest/browser/index.js');
+
+    it('should not map @vitest/browser/context in vendorMap', () => {
+      const content = fs.readFileSync(browserIndexPath, 'utf-8');
+      // The vendorMap inside vitest:vendor-aliases should NOT contain
+      // '@vitest/browser/context' — it must be left for BrowserContext
+      // plugin to resolve as a virtual module.
+      const vendorAliasesMatch = content.match(
+        /name:\s*['"]vitest:vendor-aliases['"][\s\S]*?const vendorMap\s*=\s*\{([\s\S]*?)\}/,
+      );
+      expect(vendorAliasesMatch, 'vitest:vendor-aliases plugin should exist').toBeTruthy();
+      const vendorMapContent = vendorAliasesMatch![1];
+      expect(vendorMapContent).not.toContain("'@vitest/browser/context'");
+    });
+  });
+});

packages/test/build.ts

@@ -1458,8 +1458,16 @@ async function patchVitestBrowserPackage() {
 
   // 1. Inject vitest:vendor-aliases plugin into BrowserPlugin return array
   // This allows imports like @vitest/runner to be resolved to our copied @vitest files
+  // Exclude @vitest/browser/context from vendor-aliases so that BrowserContext
+  // plugin's resolveId can intercept the bare specifier and return the virtual
+  // module (which includes the dynamically generated `server` export).
+  // Without this, vendor-aliases resolves the bare specifier to the static
+  // context.js file (which has no `server`), bypassing BrowserContext entirely.
+  // See: https://github.com/voidzero-dev/vite-plus/issues/1086
+  const VENDOR_ALIASES_EXCLUDE = new Set(['@vitest/browser/context']);
+
   const mappingEntries = Object.entries(VITEST_PACKAGE_TO_PATH)
-    .filter(([pkg]) => pkg.startsWith('@vitest/'))
+    .filter(([pkg]) => pkg.startsWith('@vitest/') && !VENDOR_ALIASES_EXCLUDE.has(pkg))
     .map(([pkg, file]) => `'${pkg}': resolve(packageRoot, '${file}')`)
     .join(',\n      ');