docs: move lazy loading docs to config troubleshooting page

Use Vite's native Promise-based plugin support via dynamic import()
instead of the custom lazy field. Migrate the documentation from
config/index.md to a new config/troubleshooting.md page and update
the snap test to use the import().then() pattern.

Author: fengmk2

docs/.vitepress/config.mts

@@ -163,6 +163,7 @@ export default extendConfig(
                 { text: 'Build', link: '/config/build' },
                 { text: 'Pack', link: '/config/pack' },
                 { text: 'Staged', link: '/config/staged' },
+                { text: 'Troubleshooting', link: '/config/troubleshooting' },
               ],
             },
           ],

docs/config/index.md

@@ -28,67 +28,4 @@ Vite+ extends the basic Vite configuration with these additions:
 - [`test`](/config/test) for Vitest
 - [`run`](/config/run) for Vite Task
 - [`pack`](/config/pack) for tsdown
-- [`staged`](/config/staged) for staged-file checks
-
-## Lazy Loading Plugins
-
-When `vite.config.ts` imports heavy plugins at the top level, every `import` is evaluated eagerly, even for commands like `vp lint` or `vp fmt` that don't need those plugins. This can make config loading noticeably slow.
-
-The `lazy` field solves this by letting you defer plugin loading into an async function. Plugins provided through `lazy` are only resolved when actually needed:
-
-```ts
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  lazy: async () => {
-    const { default: myHeavyPlugins } = await import('./my-heavy-plugins');
-    return { plugins: myHeavyPlugins };
-  },
-});
-```
-
-### Type Signature
-
-```ts
-lazy?: () => Promise<{
-  plugins?: Plugin[];
-}>;
-```
-
-### Merging with Existing Plugins
-
-Plugins returned from `lazy` are appended after any plugins already in the `plugins` array. This lets you keep lightweight plugins inline and defer only the expensive ones:
-
-```ts
-import { defineConfig } from 'vite-plus';
-import lightPlugin from 'vite-plugin-light';
-
-export default defineConfig({
-  plugins: [lightPlugin()],
-  lazy: async () => {
-    const { default: heavyPlugin } = await import('vite-plugin-heavy');
-    return { plugins: [heavyPlugin()] };
-  },
-});
-```
-
-The resulting plugin order is: `[lightPlugin(), heavyPlugin()]`.
-
-### Function Config
-
-`lazy` also works with function-style and async function-style configs:
-
-```ts
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig(async () => ({
-  lazy: async () => {
-    const { default: heavyPlugin } = await import('vite-plugin-heavy');
-    return { plugins: [heavyPlugin()] };
-  },
-}));
-```
-
-::: info
-The `lazy` field is a temporary Vite+ extension. We plan to support this in upstream Vite in the future.
-:::
+- [`staged`](/config/staged) for staged-file checks

docs/config/troubleshooting.md

@@ -0,0 +1,35 @@
+# Configuration Troubleshooting
+
+Use this page when your Vite+ configuration is not behaving the way you expect.
+
+## Slow config loading caused by heavy plugins
+
+When `vite.config.ts` imports heavy plugins at the top level, every `import` is evaluated eagerly, even for commands like `vp lint` or `vp fmt` that don't need those plugins. This can make config loading noticeably slow.
+
+Vite supports promises in the `plugins` array, so you can use dynamic `import()` to defer heavy plugin loading:
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  plugins: [
+    import('vite-plugin-heavy').then((m) => m.default()),
+  ],
+});
+```
+
+This way the plugin module is only loaded when Vite actually resolves plugins, keeping config loading fast for commands that don't need them.
+
+You can mix regular plugins with deferred ones. Lightweight plugins stay inline while expensive ones use dynamic `import()`:
+
+```ts
+import { defineConfig } from 'vite-plus';
+import lightPlugin from 'vite-plugin-light';
+
+export default defineConfig({
+  plugins: [
+    lightPlugin(),
+    import('vite-plugin-heavy').then((m) => m.default()),
+  ],
+});
+```

packages/cli/snap-tests/lazy-loading-plugins/snap.txt

@@ -1,4 +1,4 @@
-> # Test that plugins loaded via lazy field are applied during build
+> # Test that lazy-loaded plugins via dynamic import are applied during build
 > vp build
 > cat dist/index.html | grep 'lazy-plugin-injected'
   <!-- lazy-plugin-injected --></body>

packages/cli/snap-tests/lazy-loading-plugins/steps.json

@@ -1,6 +1,6 @@
 {
   "commands": [
-    "# Test that plugins loaded via lazy field are applied during build",
+    "# Test that lazy-loaded plugins via dynamic import are applied during build",
     {
       "command": "vp build",
       "ignoreOutput": true

packages/cli/snap-tests/lazy-loading-plugins/vite.config.ts

@@ -1,8 +1,5 @@
 import { defineConfig } from 'vite-plus';
 
 export default defineConfig({
-  lazy: async () => {
-    const { default: myLazyPlugin } = await import('./my-plugin');
-    return { plugins: [myLazyPlugin()] };
-  },
+  plugins: [import('./my-plugin').then((m) => m.default())],
 });