void 0.7.1 → 0.7.3

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

@@ -0,0 +1,18 @@
+# Format Config
+
+`vp fmt` and `vp check` read Oxfmt settings from the `fmt` block in `vite.config.ts`. See [Oxfmt's configuration](https://oxc.rs/docs/guide/usage/formatter/config.html) for details.
+
+## Example
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  fmt: {
+    ignorePatterns: ['dist/**'],
+    singleQuote: true,
+    semi: true,
+    sortPackageJson: true,
+  },
+});
+```

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

@@ -0,0 +1,31 @@
+# Configuring Vite+
+
+Vite+ keeps project configuration in one place: `vite.config.ts`, allowing you to consolidate many top-level configuration files in a single file. You can keep using your Vite configuration such as `server` or `build`, and add Vite+ blocks for the rest of your workflow:
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  server: {},
+  build: {},
+  preview: {},
+
+  test: {},
+  lint: {},
+  fmt: {},
+  run: {},
+  pack: {},
+  staged: {},
+});
+```
+
+## Vite+ Specific Configuration
+
+Vite+ extends the basic Vite configuration with these additions:
+
+- [`lint`](/config/lint) for Oxlint
+- [`fmt`](/config/fmt) for Oxfmt
+- [`test`](/config/test) for Vitest
+- [`run`](/config/run) for Vite Task
+- [`pack`](/config/pack) for tsdown
+- [`staged`](/config/staged) for staged-file checks

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

@@ -0,0 +1,24 @@
+# Lint Config
+
+`vp lint` and `vp check` read Oxlint settings from the `lint` block in `vite.config.ts`. See [Oxlint's configuration](https://oxc.rs/docs/guide/usage/linter/config.html) for details.
+
+## Example
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  lint: {
+    ignorePatterns: ['dist/**'],
+    options: {
+      typeAware: true,
+      typeCheck: true,
+    },
+    rules: {
+      'no-console': ['error', { allow: ['error'] }],
+    },
+  },
+});
+```
+
+We recommend enabling both `options.typeAware` and `options.typeCheck` so `vp lint` and `vp check` can use the full type-aware path.

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

@@ -0,0 +1,17 @@
+# Pack Config
+
+`vp pack` reads tsdown settings from the `pack` block in `vite.config.ts`. See [tsdown's configuration](https://tsdown.dev/options/config-file) for details.
+
+## Example
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  pack: {
+    dts: true,
+    format: ['esm', 'cjs'],
+    sourcemap: true,
+  },
+});
+```

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

@@ -0,0 +1,249 @@
+# Run Config
+
+You can configure Vite Task under the `run` field in `vite.config.ts`. Check out [`vp run`](/guide/run) to learn more about running scripts and tasks with Vite+.
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  run: {
+    enablePrePostScripts: true,
+    cache: {
+      /* ... */
+    },
+    tasks: {
+      /* ... */
+    },
+  },
+});
+```
+
+## `run.enablePrePostScripts`
+
+- **Type:** `boolean`
+- **Default:** `true`
+
+Whether to automatically run `preX`/`postX` package.json scripts as lifecycle hooks when script `X` is executed.
+
+When enabled (the default), running a script like `test` will automatically run `pretest` before it and `posttest` after it, if they exist in `package.json`.
+
+```ts
+export default defineConfig({
+  run: {
+    enablePrePostScripts: false, // Disable pre/post lifecycle hooks
+  },
+});
+```
+
+::: warning
+This option can only be set in the workspace root's `vite.config.ts`. Setting it in a package's config will result in an error.
+:::
+
+## `run.cache`
+
+- **Type:** `boolean | { scripts?: boolean, tasks?: boolean }`
+- **Default:** `{ scripts: false, tasks: true }`
+
+Controls whether task results are cached and replayed on subsequent runs.
+
+```ts
+export default defineConfig({
+  run: {
+    cache: {
+      scripts: true, // Cache package.json scripts (default: false)
+      tasks: true, // Cache task definitions (default: true)
+    },
+  },
+});
+```
+
+`cache: true` enables both task and script caching, `cache: false` disables both.
+
+## `run.tasks`
+
+- **Type:** `Record<string, TaskConfig>`
+
+Defines tasks that can be run with `vp run <task>`.
+
+### `command`
+
+- **Type:** `string`
+
+Defines the shell command to run for the task.
+
+```ts
+tasks: {
+  build: {
+    command: 'vp build',
+  },
+}
+```
+
+Each task defined in `vite.config.ts` must include its own `command`. You cannot define a task in both `vite.config.ts` and `package.json` with the same task name.
+
+Commands joined with `&&` are automatically split into independently cached sub-tasks. See [Compound Commands](/guide/run#compound-commands).
+
+### `dependsOn`
+
+- **Type:** `string[]`
+- **Default:** `[]`
+
+Tasks that must complete successfully before this one starts.
+
+```ts
+tasks: {
+  deploy: {
+    command: 'deploy-script --prod',
+    dependsOn: ['build', 'test'],
+  },
+}
+```
+
+Dependencies can reference tasks in other packages using the `package#task` format:
+
+```ts
+dependsOn: ['@my/core#build', '@my/utils#lint'];
+```
+
+See [Task Dependencies](/guide/run#task-dependencies) for details on how explicit and topological dependencies interact.
+
+### `cache`
+
+- **Type:** `boolean`
+- **Default:** `true`
+
+Whether to cache this task's output. Set to `false` for tasks that should never be cached, like dev servers:
+
+```ts
+tasks: {
+  dev: {
+    command: 'vp dev',
+    cache: false,
+  },
+}
+```
+
+### `env`
+
+- **Type:** `string[]`
+- **Default:** `[]`
+
+Environment variables included in the cache fingerprint. When any listed variable's value changes, the cache is invalidated.
+
+```ts
+tasks: {
+  build: {
+    command: 'vp build',
+    env: ['NODE_ENV'],
+  },
+}
+```
+
+Wildcard patterns are supported: `VITE_*` matches all variables starting with `VITE_`.
+
+```bash
+$ NODE_ENV=development vp run build    # first run
+$ NODE_ENV=production vp run build     # cache miss: variable changed
+```
+
+### `untrackedEnv`
+
+- **Type:** `string[]`
+- **Default:** see below
+
+Environment variables passed to the task process but **not** included in the cache fingerprint. Changing these values won't invalidate the cache.
+
+```ts
+tasks: {
+  build: {
+    command: 'vp build',
+    untrackedEnv: ['CI', 'GITHUB_ACTIONS'],
+  },
+}
+```
+
+A set of common environment variables are automatically passed through to all tasks:
+
+- **System:** `HOME`, `USER`, `PATH`, `SHELL`, `LANG`, `TZ`
+- **Node.js:** `NODE_OPTIONS`, `COREPACK_HOME`, `PNPM_HOME`
+- **CI/CD:** `CI`, `VERCEL_*`, `NEXT_*`
+- **Terminal:** `TERM`, `COLORTERM`, `FORCE_COLOR`, `NO_COLOR`
+
+### `input`
+
+- **Type:** `Array<string | { auto: boolean } | { pattern: string, base: "workspace" | "package" }>`
+- **Default:** `[{ auto: true }]` (auto-inferred)
+
+Vite Task automatically detects which files are used by a command (see [Automatic File Tracking](/guide/cache#automatic-file-tracking)). The `input` option can be used to explicitly include or exclude certain files.
+
+**Exclude files** from automatic tracking:
+
+```ts
+tasks: {
+  build: {
+    command: 'vp build',
+    // Use `{ auto: true }` to use automatic fingerprinting (default).
+    input: [{ auto: true }, '!**/*.tsbuildinfo', '!dist/**'],
+  },
+}
+```
+
+**Specify explicit files** only without automatic tracking:
+
+```ts
+tasks: {
+  build: {
+    command: 'vp build',
+    input: ['src/**/*.ts', 'vite.config.ts'],
+  },
+}
+```
+
+**Resolve patterns relative to the workspace root** using the object form:
+
+```ts
+tasks: {
+  build: {
+    command: 'vp build',
+    input: [
+      { auto: true },
+      { pattern: 'shared-config/**', base: 'workspace' },
+    ],
+  },
+}
+```
+
+The `base` field is required and controls how the glob pattern is resolved:
+- `"package"`: relative to the package directory
+- `"workspace"`: relative to the workspace root
+
+**Disable file tracking** entirely and cache only on command/env changes:
+
+```ts
+tasks: {
+  greet: {
+    command: 'node greet.mjs',
+    input: [],
+  },
+}
+```
+
+::: tip
+String glob patterns are resolved relative to the package directory by default. Use the object form with `base: "workspace"` to resolve relative to the workspace root.
+:::
+
+### `cwd`
+
+- **Type:** `string`
+- **Default:** package root
+
+Working directory for the task, relative to the package root.
+
+```ts
+tasks: {
+  'test-e2e': {
+    command: 'vp test',
+    cwd: 'tests/e2e',
+  },
+}
+```

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

@@ -0,0 +1,15 @@
+# Staged Config
+
+`vp staged` and `vp config` read staged-file rules from the `staged` block in `vite.config.ts`. See the [Commit hooks guide](/guide/commit-hooks).
+
+## Example
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  staged: {
+    '*.{js,ts,tsx,vue,svelte}': 'vp check --fix',
+  },
+});
+```

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

@@ -0,0 +1,18 @@
+# Test Config
+
+`vp test` reads Vitest settings from the `test` block in `vite.config.ts`. See [Vitest's configuration](https://vitest.dev/config/) for details.
+
+## Example
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+    coverage: {
+      reporter: ['text', 'html'],
+    },
+  },
+});
+```

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

@@ -0,0 +1,40 @@
+# Build
+
+`vp build` builds Vite applications for production.
+
+## Overview
+
+`vp build` runs the standard Vite production build through Vite+. Since it is directly based on Vite, the build pipeline and configuration model are the same as Vite. For more information about how Vite production builds work, see the [Vite guide](https://vite.dev/guide/build). Note that Vite+ uses Vite 8 and [Rolldown](https://rolldown.rs/) for builds.
+
+::: info
+`vp build` always runs the built-in Vite production build. If your project also has a `build` script in `package.json`, run `vp run build` when you want to run that script instead.
+:::
+
+## Usage
+
+```bash
+vp build
+vp build --watch
+vp build --sourcemap
+```
+
+## Configuration
+
+Use standard Vite configuration in `vite.config.ts`. For the full configuration reference, see the [Vite config docs](https://vite.dev/config/).
+
+Use it for:
+
+- [plugins](https://vite.dev/guide/using-plugins)
+- [aliases](https://vite.dev/config/shared-options#resolve-alias)
+- [`build`](https://vite.dev/config/build-options)
+- [`preview`](https://vite.dev/config/preview-options)
+- [environment modes](https://vite.dev/guide/env-and-mode)
+
+## Preview
+
+Use `vp preview` to serve the production build locally after `vp build`.
+
+```bash
+vp build
+vp preview
+```

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

@@ -0,0 +1,119 @@
+# Task Caching
+
+Vite Task can automatically track dependencies and cache tasks run through `vp run`.
+
+## Overview
+
+When a task runs successfully (exit code 0), its terminal output (stdout/stderr) is saved. On the next run, Vite Task checks if anything changed:
+
+1. **Arguments:** did the [additional arguments](/guide/run#additional-arguments) passed to the task change?
+2. **Environment variables:** did any [fingerprinted env vars](/config/run#env) change?
+3. **Input files:** did any file that the command reads change?
+
+If everything matches, the cached output is replayed instantly, and the command does not run.
+
+::: info
+Currently, only terminal output is cached and replayed. Output files such as `dist/` are not cached. If you delete them, use `--no-cache` to force a re-run. Output file caching is planned for a future release.
+:::
+
+When a cache miss occurs, Vite Task tells you exactly why:
+
+```
+$ vp lint ✗ cache miss: 'src/utils.ts' modified, executing
+$ vp build ✗ cache miss: env changed, executing
+$ vp test ✗ cache miss: args changed, executing
+```
+
+## When Is Caching Enabled?
+
+A command run by `vp run` is either a **task** defined in `vite.config.ts` or a **script** defined in `package.json`. Task names and script names cannot overlap. By default, **tasks are cached and scripts are not.**
+
+There are three types of controls for task caching, in order:
+
+### 1. Per-task `cache: false`
+
+A task can set [`cache: false`](/config/run#cache) to opt out. This cannot be overridden by any other cache control flag.
+
+### 2. CLI flags
+
+`--no-cache` disables caching for everything. `--cache` enables caching for both tasks and scripts, which is equivalent to setting [`run.cache: true`](/config/run#run-cache) for that invocation.
+
+### 3. Workspace config
+
+The [`run.cache`](/config/run#run-cache) option in your root `vite.config.ts` controls the default for each category:
+
+| Setting         | Default | Effect                                  |
+| --------------- | ------- | --------------------------------------- |
+| `cache.tasks`   | `true`  | Cache tasks defined in `vite.config.ts` |
+| `cache.scripts` | `false` | Cache `package.json` scripts            |
+
+## Automatic File Tracking
+
+Vite Task tracks which files each command reads during execution. When a task runs, it records which files the process opens, such as your `.ts` source files, `vite.config.ts`, and `package.json`, and records their content hashes. On the next run, it re-checks those hashes to determine if anything changed.
+
+This means caching works out of the box for most commands without any configuration. Vite Task also records:
+
+- **Missing files:** if a command probes for a file that doesn't exist, such as `utils.ts` during module resolution, creating that file later correctly invalidates the cache.
+- **Directory listings:** if a command scans a directory, such as a test runner looking for `*.test.ts`, adding or removing files in that directory invalidates the cache.
+
+### Avoiding Overly Broad Input Tracking
+
+Automatic tracking can sometimes include more files than necessary, causing unnecessary cache misses:
+
+- **Tool cache files:** some tools maintain their own cache, such as TypeScript's `.tsbuildinfo` or Cargo's `target/`. These files may change between runs even when your source code has not, causing unnecessary cache invalidation.
+- **Directory listings:** when a command scans a directory, such as when globbing for `**/*.js`, Vite Task sees the directory read but not the glob pattern. Any file added or removed in that directory, even unrelated ones, invalidates the cache.
+
+Use the [`input`](/config/run#input) option to exclude files or to replace automatic tracking with explicit file patterns:
+
+```ts
+tasks: {
+  build: {
+    command: 'tsc',
+    input: [{ auto: true }, '!**/*.tsbuildinfo'],
+  },
+}
+```
+
+## Environment Variables
+
+By default, tasks run in a clean environment. Only a small set of common variables, such as `PATH`, `HOME`, and `CI`, are passed through. Other environment variables are neither visible to the task nor included in the cache fingerprint.
+
+To add an environment variable to the cache key, add it to [`env`](/config/run#env). Changing its value then invalidates the cache:
+
+```ts
+tasks: {
+  build: {
+    command: 'webpack --mode production',
+    env: ['NODE_ENV'],
+  },
+}
+```
+
+To pass a variable to the task **without** affecting cache behavior, use [`untrackedEnv`](/config/run#untracked-env). This is useful for variables like `CI` or `GITHUB_ACTIONS` that should be available in the task, but do not generally affect caching behavior.
+
+See [Run Config](/config/run#env) for details on wildcard patterns and the full list of automatically passed-through variables.
+
+## Cache Sharing
+
+Vite Task's cache is content-based. If two tasks run the same command with the same inputs, they share the cache entry. This happens naturally when multiple tasks include a common step, either as standalone tasks or as parts of [compound commands](/guide/run#compound-commands):
+
+```json [package.json]
+{
+  "scripts": {
+    "check": "vp lint && vp build",
+    "release": "vp lint && deploy-script"
+  }
+}
+```
+
+With caching enabled, for example through `--cache` or [`run.cache.scripts: true`](/config/run#run-cache), running `check` first means the `vp lint` step in `release` is an instant cache hit, since both run the same command against the same files.
+
+## Cache Commands
+
+Use `vp cache clean` when you need to clear cached task results:
+
+```bash
+vp cache clean
+```
+
+The task cache is stored in `node_modules/.vite/task-cache` at the project root. `vp cache clean` deletes that cache directory.

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

@@ -0,0 +1,44 @@
+# Check
+
+`vp check` runs format, lint, and type checks together.
+
+## Overview
+
+`vp check` is the default command for fast static checks in Vite+. It brings together formatting through [Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html), linting through [Oxlint](https://oxc.rs/docs/guide/usage/linter.html), and TypeScript type checks through [tsgolint](https://github.com/oxc-project/tsgolint). By merging all of these tasks into a single command, `vp check` is faster than running formatting, linting, and type checking as separate tools in separate commands.
+
+When `typeCheck` is enabled in the `lint.options` block in `vite.config.ts`, `vp check` also runs TypeScript type checks through the Oxlint type-aware path powered by the TypeScript Go toolchain and [tsgolint](https://github.com/oxc-project/tsgolint). `vp create` and `vp migrate` enable both `typeAware` and `typeCheck` by default.
+
+We recommend turning `typeCheck` on so `vp check` becomes the single command for static checks during development.
+
+## Usage
+
+```bash
+vp check
+vp check --fix             # Format and run autofixers.
+vp check --no-fmt          # Skip format; run lint (and type-check if enabled).
+vp check --no-lint         # Skip lint rules; keep type-check when enabled.
+vp check --no-fmt --no-lint # Type-check only (requires `typeCheck` enabled).
+```
+
+## Configuration
+
+`vp check` uses the same configuration you already define for linting and formatting:
+
+- [`lint`](/guide/lint#configuration) block in `vite.config.ts`
+- [`fmt`](/guide/fmt#configuration) block in `vite.config.ts`
+- TypeScript project structure and tsconfig files for type-aware linting
+
+Recommended base `lint` config:
+
+```ts [vite.config.ts]
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  lint: {
+    options: {
+      typeAware: true,
+      typeCheck: true,
+    },
+  },
+});
+```

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

@@ -0,0 +1,64 @@
+# Continuous Integration
+
+You can use `voidzero-dev/setup-vp` to use Vite+ in CI environments.
+
+## Overview
+
+For GitHub Actions, the recommended setup is [`voidzero-dev/setup-vp`](https://github.com/voidzero-dev/setup-vp). It installs Vite+, sets up the required Node.js version and package manager, and can cache package installs automatically.
+
+That means you usually do not need separate `setup-node`, package-manager setup, and manual dependency-cache steps in your workflow.
+
+## GitHub Actions
+
+```yaml
+- uses: voidzero-dev/setup-vp@v1
+  with:
+    node-version: '22'
+    cache: true
+- run: vp install
+- run: vp check
+- run: vp test
+- run: vp build
+```
+
+With `cache: true`, `setup-vp` handles dependency caching for you automatically.
+
+## Simplifying Existing Workflows
+
+If you are migrating an existing GitHub Actions workflow, you can often replace large blocks of Node, package-manager, and cache setup with a single `setup-vp` step.
+
+#### Before:
+
+```yaml
+- uses: actions/setup-node@v4
+  with:
+    node-version: '24'
+
+- uses: pnpm/action-setup@v4
+  with:
+    version: 10
+
+- name: Get pnpm store path
+  run: pnpm store path
+
+- uses: actions/cache@v4
+  with:
+    path: ~/.pnpm-store
+    key: ${{ runner.os }}-pnpm-${{ hashFiles('pnpm-lock.yaml') }}
+
+- run: pnpm install && pnpm dev:setup
+- run: pnpm test
+```
+
+#### After:
+
+```yaml
+- uses: voidzero-dev/setup-vp@v1
+  with:
+    node-version: '24'
+    cache: true
+
+- run: vp install && vp run dev:setup
+- run: vp check
+- run: vp test
+```