void 0.7.1 → 0.7.3

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/run.md

@@ -0,0 +1,324 @@
+# Run
+
+`vp run` runs `package.json` scripts and tasks defined in `vite.config.ts`. It works like `pnpm run`, with caching, dependency ordering, and workspace-aware execution built in.
+
+::: tip
+`vpr` is available as a standalone shorthand for `vp run`. All examples below work with both `vp run` and `vpr`.
+:::
+
+## Overview
+
+Use `vp run` with existing `package.json` scripts:
+
+```json [package.json]
+{
+  "scripts": {
+    "build": "node compile-legacy-app.js",
+    "test": "jest"
+  }
+}
+```
+
+`vp run build` executes the associated build script:
+
+```
+$ node compile-legacy-app.js
+
+building legacy app for production...
+
+✓ built in 69s
+```
+
+Use `vp run` without a task name to use the interactive task runner:
+
+```
+Select a task (↑/↓, Enter to run, Esc to clear):
+
+  › build: node compile-legacy-app.js
+    test: jest
+```
+
+## Caching
+
+`package.json` scripts are not cached by default. Use `--cache` to enable caching:
+
+```bash
+vp run --cache build
+```
+
+```
+$ node compile-legacy-app.js
+✓ built in 69s
+```
+
+If nothing changes, the output is replayed from the cache on the next run:
+
+```
+$ node compile-legacy-app.js ✓ cache hit, replaying
+✓ built in 69s
+
+---
+vp run: cache hit, 69s saved.
+```
+
+If an input changes, the task runs again:
+
+```
+$ node compile-legacy-app.js ✗ cache miss: 'legacy/index.js' modified, executing
+```
+
+## Task Definitions
+
+Vite Task automatically tracks which files your command uses. You can define tasks directly in `vite.config.ts` to enable caching by default or control which files and environment variables affect cache behavior.
+
+```ts [vite.config.ts]
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  run: {
+    tasks: {
+      build: {
+        command: 'vp build',
+        dependsOn: ['lint'],
+        env: ['NODE_ENV'],
+      },
+      deploy: {
+        command: 'deploy-script --prod',
+        cache: false,
+        dependsOn: ['build', 'test'],
+      },
+    },
+  },
+});
+```
+
+If you want to run an existing `package.json` script as-is, use `vp run <script>`. If you want task-level caching, dependencies, or environment/input controls, define a task with an explicit `command`. A task name can come from `vite.config.ts` or `package.json`, but not both.
+
+::: info
+Tasks defined in `vite.config.ts` are cached by default. `package.json` scripts are not. See [When Is Caching Enabled?](/guide/cache#when-is-caching-enabled) for the full resolution order.
+:::
+
+See [Run Config](/config/run) for the full `run` block reference.
+
+## Task Dependencies
+
+Use [`dependsOn`](#depends-on) to run tasks in the right order. Running `vp run deploy` with the config above runs `build` and `test` first. Dependencies can also target other packages in the same project with the `package#task` notation:
+
+```ts
+dependsOn: ['@my/core#build', '@my/utils#lint'];
+```
+
+## Running in a Workspace
+
+With no package-selection flags, `vp run` runs the task in the package in your current working directory:
+
+```bash
+cd packages/app
+vp run build
+```
+
+You can also target a package explicitly from anywhere:
+
+```bash
+vp run @my/app#build
+```
+
+Workspace package ordering is based on the normal monorepo dependency graph declared in each package's `package.json`. In other words, when Vite+ talks about package dependencies, it means the regular `dependencies` relationships between workspace packages, not a separate task-runner-specific graph.
+
+### Recursive (`-r`)
+
+Run the task in every workspace package, in dependency order:
+
+```bash
+vp run -r build
+```
+
+That dependency order comes from the workspace packages referenced through `package.json` dependencies.
+
+### Transitive (`-t`)
+
+Run the task in one package and all of its dependencies:
+
+```bash
+vp run -t @my/app#build
+```
+
+If `@my/app` depends on `@my/utils`, which depends on `@my/core`, this runs all three in order. Vite+ resolves that chain from the normal workspace package dependencies declared in `package.json`.
+
+### Filter (`--filter`)
+
+Select packages by name, directory, or glob pattern. The syntax matches pnpm's `--filter`:
+
+```bash
+# By name
+vp run --filter @my/app build
+
+# By glob
+vp run --filter "@my/*" build
+
+# By directory
+vp run --filter ./packages/app build
+
+# Include dependencies
+vp run --filter "@my/app..." build
+
+# Include dependents
+vp run --filter "...@my/core" build
+
+# Exclude packages
+vp run --filter "@my/*" --filter "!@my/utils" build
+```
+
+Multiple `--filter` flags are combined as a union. Exclusion filters are applied after all inclusions.
+
+### Workspace Root (`-w`)
+
+Explicitly run the task in the workspace root package:
+
+```bash
+vp run -w build
+```
+
+## Compound Commands
+
+Commands joined with `&&` are split into independent sub-tasks. Each sub-task is cached separately when [caching is enabled](/guide/cache#when-is-caching-enabled). This works for both `vite.config.ts` tasks and `package.json` scripts:
+
+```json [package.json]
+{
+  "scripts": {
+    "check": "vp lint && vp build"
+  }
+}
+```
+
+Now, run `vp run --cache check`:
+
+```
+$ vp lint
+Found 0 warnings and 0 errors.
+
+$ vp build
+✓ built in 28ms
+
+---
+vp run: 0/2 cache hit (0%).
+```
+
+Each sub-task has its own cache entry. If only `.ts` files changed but lint still passes, only `vp build` runs again the next time `vp run --cache check` is called:
+
+```
+$ vp lint ✓ cache hit, replaying
+$ vp build ✗ cache miss: 'src/index.ts' modified, executing
+✓ built in 30ms
+
+---
+vp run: 1/2 cache hit (50%), 120ms saved.
+```
+
+### Nested `vp run`
+
+When a command contains `vp run`, Vite Task inlines it as separate tasks instead of spawning a nested process. Each sub-task is cached independently and output stays flat:
+
+```json [package.json]
+{
+  "scripts": {
+    "ci": "vp run lint && vp run test && vp run build"
+  }
+}
+```
+
+Running `vp run ci` expands into three tasks:
+
+```mermaid
+graph LR
+  lint --> test --> build
+```
+
+Flags also work inside nested scripts. For example, `vp run -r build` inside a script expands into individual build tasks for every package.
+
+::: info
+A common monorepo pattern is a root script that runs a task recursively:
+
+```json [package.json (root) ~vscode-icons:file-type-node~]
+{
+  "scripts": {
+    "build": "vp run -r build"
+  }
+}
+```
+
+This creates a potential recursion: root's `build` -> `vp run -r build` -> includes root's `build` -> ...
+
+Vite Task detects this and prunes the self-reference automatically, so other packages build normally.
+:::
+
+## Execution Summary
+
+Use `-v` to show a detailed execution summary:
+
+```bash
+vp run -r -v build
+```
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    Vite+ Task Runner • Execution Summary
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Statistics:   3 tasks • 3 cache hits • 0 cache misses
+Performance:  100% cache hit rate, 468ms saved in total
+
+Task Details:
+────────────────────────────────────────────────
+  [1] @my/core#build: ~/packages/core$ vp build ✓
+      → Cache hit - output replayed - 200ms saved
+  ·······················································
+  [2] @my/utils#build: ~/packages/utils$ vp build ✓
+      → Cache hit - output replayed - 150ms saved
+  ·······················································
+  [3] @my/app#build: ~/packages/app$ vp build ✓
+      → Cache hit - output replayed - 118ms saved
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Use `--last-details` to show the summary from the last run without running tasks again:
+
+```bash
+vp run --last-details
+```
+
+## Concurrency
+
+By default, up to 4 tasks run at the same time. Use `--concurrency-limit` to change this:
+
+```bash
+# Run up to 8 tasks at once
+vp run -r --concurrency-limit 8 build
+
+# Run tasks one at a time
+vp run -r --concurrency-limit 1 build
+```
+
+The limit can also be set via the `VP_RUN_CONCURRENCY_LIMIT` environment variable. The `--concurrency-limit` flag takes priority over the environment variable.
+
+### Parallel Mode
+
+Use `--parallel` to ignore task dependencies and run all tasks at once with unlimited concurrency:
+
+```bash
+vp run -r --parallel dev
+```
+
+This is useful when tasks are independent and you want maximum throughput. You can combine `--parallel` with `--concurrency-limit` to run tasks without dependency ordering but still cap the number of concurrent tasks:
+
+```bash
+vp run -r --parallel --concurrency-limit 4 dev
+```
+
+## Additional Arguments
+
+Arguments after the task name are passed through to the task command:
+
+```bash
+vp run test --reporter verbose
+```

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/test.md

@@ -0,0 +1,35 @@
+# Test
+
+`vp test` runs tests with [Vitest](https://vitest.dev).
+
+## Overview
+
+`vp test` is built on [Vitest](https://vitest.dev/), so you get a Vite-native test runner that reuses your Vite config and plugins, supports Jest-style expectations, snapshots, and coverage, and handles modern ESM, TypeScript, and JSX projects cleanly.
+
+## Usage
+
+```bash
+vp test
+vp test watch
+vp test run --coverage
+```
+
+::: info
+Unlike Vitest on its own, `vp test` does not stay in watch mode by default. Use `vp test` when you want a normal test run, and use `vp test watch` when you want to jump into watch mode.
+:::
+
+## Configuration
+
+Put test configuration directly in the `test` block in `vite.config.ts` so all your configuration stays in one place. We do not recommend using `vitest.config.ts` with Vite+.
+
+```ts [vite.config.ts]
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+  },
+});
+```
+
+For the full Vitest configuration reference, see the [Vitest config docs](https://vitest.dev/config/).

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/troubleshooting.md

@@ -0,0 +1,132 @@
+# Troubleshooting
+
+Use this page when something in Vite+ is not behaving the way you expect.
+
+::: warning
+Vite+ is still in alpha. We are making frequent changes, adding features quickly, and we want feedback to help make it great.
+:::
+
+## Supported Tool Versions
+
+Vite+ expects modern upstream tool versions.
+
+- Vite 8 or newer
+- Vitest 4.1 or newer
+
+If you are migrating an existing project and it still depends on older Vite or Vitest versions, upgrade those first before adopting Vite+.
+
+## `vp check` does not run type-aware lint rules or type checks
+
+- Confirm that `lint.options.typeAware` and `lint.options.typeCheck` are enabled in `vite.config.ts`
+- Check whether your `tsconfig.json` uses `compilerOptions.baseUrl`
+
+The Oxlint type checker path powered by `tsgolint` does not support `baseUrl`, so Vite+ skips `typeAware` and `typeCheck` when that setting is present.
+
+
+## `vp lint` / `vp fmt` may fail to read `vite.config.ts`
+
+`vp lint`, `vp fmt`, and the Oxc VS Code extension all read the `lint` / `fmt` blocks from `vite.config.ts`. Today that support has important limitations.
+
+### What is currently supported
+
+- Static object export:
+  - `export default { ... }`
+  - `export default defineConfig({ ... })`
+
+### What can fail in current integrations
+
+- Functional or async config:
+  - `defineConfig((env) => ({ ... }))`
+  - `defineConfig(async (env) => ({ ... }))`
+- Config files that rely on Vite transform/bundling behavior to execute.
+
+In scenarios reported in issue #930, Oxc-side integrations that read `vite.config.ts` can behave closer to native ESM loading (similar to Vite `--configLoader native`) than Vite's bundled default loader. That means configs depending on bundling/transforms can fail to load for lint/fmt/editor paths. See: https://github.com/voidzero-dev/vite-plus/issues/930
+
+### Workarounds
+
+- Prefer a static `defineConfig({ ... })` export when you need `lint` / `fmt` in `vite.config.ts`.
+- Avoid Node-specific globals (`__dirname` in ESM), unresolved TS-only imports, or JSON imports without import attributes in config code used by lint/fmt.
+- If needed, keep `.oxlintrc.*` / `.oxfmtrc.*` as temporary fallback, [although we do not recommend doing this normally](/guide/lint##configuration), while this integration behavior is being improved.
+
+### VS Code multi-root workspace note
+
+If VS Code has multiple folders open, the shared Oxc language server may pick a different workspace than expected. That can make it look like `vite.config.ts` support is missing.
+
+- Confirm the extension is using the intended workspace.
+- Confirm the workspace resolves to a recent Oxc/Oxlint/Oxfmt toolchain.
+
+## `vp build` does not run my build script
+
+Unlike package managers, built-in commands cannot be overwritten. If you are trying to run a `package.json` script use `vp run build` instead.
+
+For example:
+
+- `vp build` always runs the built-in Vite build
+- `vp test` always runs the built-in Vitest command
+- `vp run build` and `vp run test` run `package.json` scripts instead
+
+::: info
+You can also run custom tasks defined in `vite.config.ts` and migrate away from `package.json` scripts entirely.
+:::
+
+## Staged Checks and Commit Hooks
+
+If `vp staged` fails or your pre-commit hook does not run:
+
+- make sure `vite.config.ts` contains a `staged` block
+- run `vp config` to install hooks
+- check whether hook installation was skipped intentionally through `VITE_GIT_HOOKS=0`
+
+A minimal staged config looks like this:
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  staged: {
+    '*': 'vp check --fix',
+  },
+});
+```
+
+## 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.
+
+Use `lazyPlugins` to wrap plugin loading. Plugins are only loaded for commands that need them (`dev`, `build`, `test`, `preview`), and skipped for everything else:
+
+```ts
+import { defineConfig, lazyPlugins } from 'vite-plus';
+import myPlugin from 'vite-plugin-foo';
+
+export default defineConfig({
+  plugins: lazyPlugins(() => [myPlugin()]),
+});
+```
+
+For heavy plugins that should be lazily imported, combine with dynamic `import()`:
+
+```ts
+import { defineConfig, lazyPlugins } from 'vite-plus';
+
+export default defineConfig({
+  plugins: lazyPlugins(async () => {
+    const { default: heavyPlugin } = await import('vite-plugin-heavy');
+    return [heavyPlugin()];
+  }),
+});
+```
+
+## Asking for Help
+
+If you are stuck, please reach out:
+
+- [Discord](https://discord.gg/cAnsqHh5PX) for real-time discussion and troubleshooting help
+- [GitHub](https://github.com/voidzero-dev/vite-plus) for issues, discussions, and bug reports
+
+When reporting a problem, please include:
+
+- The full output of `vp env current` and `vp --version`
+- The package manager used by the project
+- The exact steps needed to reproduce the problem and your `vite.config.ts`
+- A minimal reproduction repository or runnable sandbox

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/upgrade.md

@@ -0,0 +1,49 @@
+# Upgrading Vite+
+
+Use `vp upgrade` to update the global `vp` binary, and use Vite+'s package management commands to update the local `vite-plus` package in a project.
+
+## Overview
+
+There are two parts to upgrading Vite+:
+
+- The global `vp` command installed on your machine
+- The local `vite-plus` package used by an individual project
+
+You can upgrade both of them independently.
+
+## Global `vp`
+
+```bash
+vp upgrade
+```
+
+## Local `vite-plus`
+
+Update the project dependency with the package manager commands in Vite+:
+
+```bash
+vp update vite-plus
+```
+
+You can also use `vp add vite-plus@latest` if you want to move the dependency explicitly to the latest version.
+
+### Updating Aliased Packages
+
+Vite+ sets up npm aliases for its core packages during installation:
+
+- `vite` is aliased to `npm:@voidzero-dev/vite-plus-core@latest`
+- `vitest` is aliased to `npm:@voidzero-dev/vite-plus-test@latest`
+
+`vp update vite-plus` does not re-resolve these aliases in the lockfile. To fully upgrade, update them separately:
+
+```bash
+vp update @voidzero-dev/vite-plus-core @voidzero-dev/vite-plus-test
+```
+
+Or update everything at once:
+
+```bash
+vp update vite-plus @voidzero-dev/vite-plus-core @voidzero-dev/vite-plus-test
+```
+
+You can verify with `vp outdated` that no Vite+ packages remain outdated.

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/vpx.md

@@ -0,0 +1,66 @@
+# Running Binaries
+
+Use `vpx`, `vp exec`, and `vp dlx` to run binaries without switching between local installs, downloaded packages, and project-specific tools.
+
+## Overview
+
+`vpx` executes a command from a local or remote npm package. It can run a package that is already available locally, download a package on demand, or target an explicit package version.
+
+Use the other binary commands when you need stricter control:
+
+- `vpx` resolves a package binary locally first by default and downloads it if not found; with `pkg@version`, `--package/-p`, or `--shell-mode`, it runs via `vp dlx`
+- `vp exec` runs a binary from the current project's `node_modules/.bin`
+- `vp dlx` runs a package binary without adding it as a dependency
+
+## `vpx`
+
+Use `vpx` for running any local or remote binary:
+
+```bash
+vpx <pkg[@version]> [args...]
+```
+
+### Options
+
+- `-p, --package <name>` installs one or more additional packages before running the command
+- `-c, --shell-mode` executes the command inside a shell
+- `-s, --silent` suppresses Vite+ output and only shows the command output
+
+### Examples
+
+```bash
+vpx eslint .
+vpx create-vue my-app
+vpx typescript@5.5.4 tsc --version
+vpx -p cowsay -c 'echo "hi" | cowsay'
+```
+
+## `vp exec`
+
+Use `vp exec` when the binary must come from the current project, for example a binary from a dependency installed in `node_modules/.bin`.
+
+```bash
+vp exec <command> [args...]
+```
+
+Examples:
+
+```bash
+vp exec eslint .
+vp exec tsc --noEmit
+```
+
+## `vp dlx`
+
+Use `vp dlx` for one-off package execution without adding the package to your project dependencies.
+
+```bash
+vp dlx <package> [args...]
+```
+
+Examples:
+
+```bash
+vp dlx create-vite
+vp dlx typescript tsc --version
+```

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/why.md

@@ -0,0 +1,39 @@
+# Why Vite+?
+
+Working in the JavaScript ecosystem today, developers need a runtime such as Node.js, a package manager like pnpm, a dev server, a linter, a formatter, a test runner, a bundler, a task runner, and a growing number of config files.
+
+Vite showed that frontend tooling could become dramatically faster by rethinking the architecture instead of accepting the status quo. Vite+ applies that same idea to the rest of the local development workflow, and unifies them all into a single package that speeds up and simplifies development.
+
+## The Problem Vite+ is Solving
+
+The JavaScript tooling ecosystem has seen its fair share of fragmentation and churn. Web apps keep getting larger, and as a result tooling performance, complexity, and inconsistencies have become real bottlenecks as projects grow.
+
+These bottlenecks are amplified in organizations with multiple teams, each using a different tooling stack. Dependency management, build infrastructure, and code quality become fragmented responsibilities, handled team by team and often not owned as a priority by anyone. As a result, dependencies drift out of sync, builds get slower, and code quality declines. Fixing those problems later requires significantly more effort, slows everyone down, and pulls teams away from shipping product.
+
+## What's Included in Vite+
+
+Vite+ brings the tools needed for modern web development together into a single, integrated toolchain. Instead of assembling and maintaining a custom toolchain, Vite+ provides a consistent entry point that manages the runtime, dependencies, development server, code quality checks, testing, and builds in one place.
+
+- **[Vite](https://vite.dev/)** and **[Rolldown](https://rolldown.rs/)** for development and application builds
+- **[Vitest](https://vitest.dev/)** for testing
+- **[Oxlint](https://oxc.rs/docs/guide/usage/linter.html)** and **[Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html)** for linting and formatting
+- **[tsdown](https://tsdown.dev/)** for library builds or standalone executables
+- **[Vite Task](https://github.com/voidzero-dev/vite-task)** for task orchestration
+
+In practice, this means developers interact with one consistent workflow: `vp dev`, `vp check`, `vp test`, and `vp build`.
+
+This unified toolchain reduces configuration overhead, improves performance, and makes it easier for teams to maintain consistent tooling across projects.
+
+## Fast and Scalable by Default
+
+Vite+ is built on top of modern tooling such as Vite, Rolldown, Oxc, Vitest, and Vite Task to keep your projects fast and scalable as your codebase grows. By using Rust, we can speed up common tasks by [10× or sometimes even by 100×](https://voidzero.dev/posts/announcing-vite-plus-alpha#performance-scale). However, many Rust-based toolchains are incompatible with existing tools, or aren't extensible using JavaScript.
+
+Vite+ bridges Rust to JavaScript via [NAPI-RS](https://napi.rs/) which allows it to provide a familiar, easy-to-configure, and extensible interface in JavaScript with a great ecosystem-compatible developer experience.
+
+Unifying the toolchain has performance benefits beyond just using faster tools on their own. For example, many developers set up their linter with "type aware" tools, requiring a full-typecheck to be run during the linting stage. With `vp check` you can format, lint, and type-check your code all in a single pass, speeding up static checks by 2× compared to running type-aware lint rules and type-checks separately.
+
+## Fully Open Source
+
+Vite+ is fully open source and not a new framework or locked-down platform. Vite+ integrates with the existing Vite ecosystem and the frameworks built on top of it, including React, Vue, Svelte, and others. It can use pnpm, npm, yarn, or Bun as package manager, and manages the Node.js runtime for you.
+
+We always welcome contributions from the community. See our [Contributing Guidelines](https://github.com/voidzero-dev/vite-plus/blob/main/CONTRIBUTING.md) to get involved.

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/index.md

@@ -0,0 +1,12 @@
+---
+home: true
+layout: home
+theme: light
+titleTemplate: The Unified Toolchain for the Web
+---
+
+<script setup>
+import Home from '@layouts/Home.vue'
+</script>
+
+<Home />

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/team.md

@@ -0,0 +1,35 @@
+---
+layout: page
+title: Meet the Team
+description: The development of Vite+ is guided by an international team.
+---
+
+<script setup>
+import {
+  VPTeamPage,
+  VPTeamPageTitle,
+  VPTeamPageSection,
+  VPTeamMembers
+} from '@voidzero-dev/vitepress-theme'
+import { core } from './_data/team'
+</script>
+
+<VPTeamPage>
+  <VPTeamPageTitle>
+    <template #title>Meet the Team</template>
+    <template #lead>
+      The team members who work on Vite+ and are responsible for its development, maintenance, and community engagement.
+    </template>
+  </VPTeamPageTitle>
+  <VPTeamMembers :members="core" />
+  <!-- <VPTeamPageSection v-if="emeriti.length">
+    <template #title>Team Emeriti</template>
+    <template #lead>
+      Here we honor some no-longer-active team members who have made valuable
+      contributions in the past.
+    </template>
+    <template #members>
+      <VPTeamMembers size="small" :members="emeriti" />
+    </template>
+  </VPTeamPageSection> -->
+</VPTeamPage>