fix(cli): propagate vite-plus/test rewrite plugin into test.projects

The mocker rewrite plugin was only injected into the root vite config,
so projects defined under `test.projects` (each spinning up an isolated
Vite pipeline) never got the rewrite — `vi.mock()` failed with
"problems in resolving the mocks API" for source that imports from
`'vite-plus/test'` inside a project.

Author: Brooooooklyn

packages/cli/src/__tests__/define-config-mocker-rewrite.spec.ts

@@ -1,6 +1,16 @@
+import type { Plugin } from '@voidzero-dev/vite-plus-core';
 import { describe, expect, it } from 'vitest';
 
-import { rewriteVitePlusTestSpecifier } from '../define-config.ts';
+import { defineConfig, rewriteVitePlusTestSpecifier } from '../define-config.ts';
+
+const REWRITE_PLUGIN_NAME = 'vite-plus:vitest-specifier-rewrite';
+
+function pluginName(p: unknown): string | undefined {
+  if (p && typeof p === 'object' && 'name' in p && typeof (p as { name: unknown }).name === 'string') {
+    return (p as { name: string }).name;
+  }
+  return undefined;
+}
 
 describe('rewriteVitePlusTestSpecifier', () => {
   it('is a no-op when source does not mention vite-plus/test', () => {
@@ -66,3 +76,82 @@ describe('rewriteVitePlusTestSpecifier', () => {
     expect(rewriteVitePlusTestSpecifier(input)).toBe(expected);
   });
 });
+
+describe('defineConfig project plugin injection', () => {
+  it('injects rewrite plugin at the root plugins array', () => {
+    const existing: Plugin = { name: 'user-existing-root-plugin' };
+    const result = defineConfig({ plugins: [existing] }) as { plugins: unknown[] };
+
+    expect(pluginName(result.plugins[0])).toBe(REWRITE_PLUGIN_NAME);
+    expect(pluginName(result.plugins[1])).toBe('user-existing-root-plugin');
+  });
+
+  it('injects rewrite plugin into an inline-object project entry, preserving existing plugins', () => {
+    const existing: Plugin = { name: 'user-unit-project-plugin' };
+    const result = defineConfig({
+      test: {
+        projects: [
+          {
+            plugins: [existing],
+            test: { name: 'unit', include: ['test/unit/**/*.spec.ts'], environment: 'node' },
+          },
+        ],
+      },
+    }) as { test: { projects: unknown[] } };
+
+    const project = result.test.projects[0] as { plugins: unknown[]; test: { name: string } };
+    expect(project.test.name).toBe('unit');
+    expect(pluginName(project.plugins[0])).toBe(REWRITE_PLUGIN_NAME);
+    expect(pluginName(project.plugins[1])).toBe('user-unit-project-plugin');
+    // Sanity: the existing plugin reference is preserved (clone shallow-copies the array).
+    expect(project.plugins[1]).toBe(existing);
+  });
+
+  it('injects rewrite plugin into the return value of a function-shaped project entry', () => {
+    const existing: Plugin = { name: 'user-fn-project-plugin' };
+    const projectFn = () => ({
+      plugins: [existing],
+      test: { name: 'nuxt', environment: 'happy-dom' as const },
+    });
+    const result = defineConfig({
+      test: { projects: [projectFn] },
+    }) as { test: { projects: unknown[] } };
+
+    const wrapped = result.test.projects[0];
+    expect(typeof wrapped).toBe('function');
+
+    // Vitest passes a `ConfigEnv` to the function; we don't depend on its
+    // shape here, the wrapper just forwards it.
+    const fakeEnv = { mode: 'test', command: 'serve' as const };
+    const resolved = (wrapped as (env: typeof fakeEnv) => { plugins: unknown[] })(fakeEnv);
+    expect(pluginName(resolved.plugins[0])).toBe(REWRITE_PLUGIN_NAME);
+    expect(pluginName(resolved.plugins[1])).toBe('user-fn-project-plugin');
+  });
+
+  it('passes string-glob project entries through unchanged', () => {
+    const result = defineConfig({
+      test: {
+        projects: ['./packages/*', './apps/*'],
+      },
+    }) as { test: { projects: unknown[] } };
+
+    expect(result.test.projects).toEqual(['./packages/*', './apps/*']);
+  });
+
+  it('handles projects with no existing plugins array', () => {
+    const result = defineConfig({
+      test: {
+        projects: [
+          {
+            test: { name: 'no-plugins', environment: 'node' },
+          },
+        ],
+      },
+    }) as { test: { projects: unknown[] } };
+
+    const project = result.test.projects[0] as { plugins: unknown[]; test: { name: string } };
+    expect(project.test.name).toBe('no-plugins');
+    expect(project.plugins).toHaveLength(1);
+    expect(pluginName(project.plugins[0])).toBe(REWRITE_PLUGIN_NAME);
+  });
+});

packages/cli/src/define-config.ts

@@ -1,7 +1,13 @@
 import type { PluginOption, UserConfig } from '@voidzero-dev/vite-plus-core';
 import type { OxfmtConfig } from 'oxfmt';
 import type { OxlintConfig } from 'oxlint';
-import { defineConfig as viteDefineConfig, type ConfigEnv } from 'vitest/config';
+import {
+  defineConfig as viteDefineConfig,
+  type ConfigEnv,
+  type TestProjectConfiguration,
+  type TestProjectInlineConfiguration,
+  type UserProjectConfigFn,
+} from 'vitest/config';
 import type { InlineConfig as VitestInlineConfig } from 'vitest/node';
 
 import type { PackUserConfig } from './pack.ts';
@@ -98,13 +104,73 @@ function vitePlusTestSpecifierRewritePlugin(): PluginOption {
   };
 }
 
-function injectPlugin(config: UserConfig): UserConfig {
+/**
+ * Inject the rewrite plugin into a single inline project config. Used both
+ * for root configs and for object-shaped entries inside `test.projects`.
+ *
+ * The shapes overlap (both have an optional top-level `plugins` array), so a
+ * shared helper keeps the wiring consistent.
+ */
+function injectPluginIntoInlineConfig<T extends { plugins?: UserConfig['plugins'] }>(
+  config: T,
+): T {
   return {
     ...config,
     plugins: [vitePlusTestSpecifierRewritePlugin(), ...(config.plugins ?? [])],
   };
 }
 
+/**
+ * Walk `config.test?.projects` and inject the rewrite plugin into each
+ * project entry. Vitest spins up an independent Vite pipeline per project, so
+ * root-level plugins do NOT propagate — without this, files matched by a
+ * project's `include` glob never get the `vite-plus/test` → `vitest` rewrite.
+ *
+ * Entry shapes (from `TestProjectConfiguration`):
+ *   - string  (glob path like `'./packages/*'`)  → passed through unchanged.
+ *   - object  (inline config with `test: {...}`) → clone and prepend plugin.
+ *   - function (sync or async)                   → wrap so its result is injected.
+ *   - Promise (resolves to inline config)        → chain `.then(injectPlugin)`.
+ */
+function injectPluginIntoProject(project: TestProjectConfiguration): TestProjectConfiguration {
+  if (typeof project === 'string') {
+    return project;
+  }
+  if (typeof project === 'function') {
+    const fn = project as UserProjectConfigFn;
+    const wrapped: UserProjectConfigFn = (env: ConfigEnv) => {
+      const result = fn(env);
+      if (result instanceof Promise) {
+        return result.then(injectPluginIntoInlineConfig);
+      }
+      return injectPluginIntoInlineConfig(result);
+    };
+    return wrapped;
+  }
+  if (project instanceof Promise) {
+    return project.then(injectPluginIntoInlineConfig);
+  }
+  if (typeof project === 'object' && project !== null) {
+    return injectPluginIntoInlineConfig(project as TestProjectInlineConfiguration);
+  }
+  return project;
+}
+
+function injectPlugin(config: UserConfig): UserConfig {
+  const injected = injectPluginIntoInlineConfig(config);
+  const projects = injected.test?.projects;
+  if (!projects || projects.length === 0) {
+    return injected;
+  }
+  return {
+    ...injected,
+    test: {
+      ...injected.test,
+      projects: projects.map(injectPluginIntoProject),
+    },
+  };
+}
+
 function injectPluginIntoConfig(config: ViteUserConfigExport): ViteUserConfigExport {
   if (typeof config === 'function') {
     return (env: ConfigEnv) => {