void 0.7.1 → 0.7.3

package/skills/void/docs/node_modules/void/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/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/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/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
+```

package/skills/void/docs/node_modules/void/node_modules/vite-plus/docs/guide/commit-hooks.md

@@ -0,0 +1,51 @@
+# Commit Hooks
+
+Use `vp config` to install commit hooks, and `vp staged` to run checks on staged files.
+
+## Overview
+
+Vite+ supports commit hooks and staged-file checks without additional tooling.
+
+Use:
+
+- `vp config` to set up project hooks and related integrations
+- `vp staged` to run checks against the files currently staged in Git
+
+If you use [`vp create`](/guide/create) or [`vp migrate`](/guide/migrate), Vite+ prompts you to set this up for your project automatically.
+
+## Commands
+
+### `vp config`
+
+`vp config` configures Vite+ for the current project. It installs Git hooks, sets up the hook directory, and can also handle related project integration such as agent setup. By default, hooks are written to `.vite-hooks`:
+
+```bash
+vp config
+vp config --hooks-dir .vite-hooks
+```
+
+### `vp staged`
+
+`vp staged` runs staged-file checks using the `staged` config from `vite.config.ts`. If you set up Vite+ to handle your commit hooks, it will automatically run when you commit your local changes.
+
+```bash
+vp staged
+vp staged --verbose
+vp staged --fail-on-changes
+```
+
+## Configuration
+
+Define staged-file checks in the `staged` block in `vite.config.ts`:
+
+```ts [vite.config.ts]
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  staged: {
+    '*.{js,ts,tsx,vue,svelte}': 'vp check --fix',
+  },
+});
+```
+
+This is the default Vite+ approach and should replace separate `lint-staged` configuration in most projects. Because `vp staged` reads from `vite.config.ts`, your staged-file checks stay in the same place as your lint, format, test, build, and task-runner config.

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

@@ -0,0 +1,88 @@
+# Creating a Project
+
+`vp create` interactively scaffolds new Vite+ projects, monorepos, and apps inside existing workspaces.
+
+## Overview
+
+The `create` command is the fastest way to start with Vite+. It can be used in a few different ways:
+
+- Start a new Vite+ monorepo
+- Create a new standalone application or library
+- Add a new app or library inside an existing project
+
+This command can be used with built-in templates, community templates, or remote GitHub templates.
+
+## Usage
+
+```bash
+vp create
+vp create <template>
+vp create <template> -- <template-options>
+```
+
+## Built-in Templates
+
+Vite+ ships with these built-in templates:
+
+- `vite:monorepo` creates a new monorepo
+- `vite:application` creates a new application
+- `vite:library` creates a new library
+- `vite:generator` creates a new generator
+
+## Template Sources
+
+`vp create` is not limited to the built-in templates.
+
+- Use shorthand templates like `vite`, `@tanstack/start`, `svelte`, `next-app`, `nuxt`, `react-router`, and `vue`
+- Use full package names like `create-vite` or `create-next-app`
+- Use local templates such as `./tools/create-ui-component` or `@acme/generator-*`
+- Use remote templates such as `github:user/repo` or `https://github.com/user/template-repo`
+
+Run `vp create --list` to see the built-in templates and the common shorthand templates Vite+ recognizes.
+
+## Options
+
+- `--directory <dir>` writes the generated project into a specific target directory
+- `--agent <name>` creates agent instructions files during scaffolding
+- `--editor <name>` writes editor config files
+- `--hooks` enables pre-commit hook setup
+- `--no-hooks` skips hook setup
+- `--no-interactive` runs without prompts
+- `--verbose` shows detailed scaffolding output
+- `--list` prints the available built-in and popular templates
+
+## Template Options
+
+Arguments after `--` are passed directly to the selected template.
+
+This matters when the template itself accepts flags. For example, you can forward Vite template selection like this:
+
+```bash
+vp create vite -- --template react-ts
+```
+
+## Examples
+
+```bash
+# Interactive mode
+vp create
+
+# Create a Vite+ monorepo, application, library, or generator
+vp create vite:monorepo
+vp create vite:application
+vp create vite:library
+vp create vite:generator
+
+# Use shorthand community templates
+vp create vite
+vp create @tanstack/start
+vp create svelte
+
+# Use full package names
+vp create create-vite
+vp create create-next-app
+
+# Use remote templates
+vp create github:user/repo
+vp create https://github.com/user/template-repo
+```

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

@@ -0,0 +1,24 @@
+# Dev
+
+`vp dev` starts the Vite development server.
+
+## Overview
+
+`vp dev` runs the standard Vite development server through Vite+, so you keep the normal Vite dev experience while using the same CLI entry point as the rest of the toolchain. For more information about using and configuring the dev server, see the [Vite guide](https://vite.dev/guide/).
+
+## Usage
+
+```bash
+vp dev
+```
+
+## Configuration
+
+Use standard Vite config 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)
+- [`server`](https://vite.dev/config/server-options)
+- [environment modes](https://vite.dev/guide/env-and-mode)

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

@@ -0,0 +1,102 @@
+# Environment
+
+`vp env` manages Node.js versions globally and per project.
+
+## Overview
+
+Managed mode is on by default, so `node`, `npm`, and related shims resolve through Vite+ and pick the right Node.js version for the current project.
+
+By default, Vite+ stores its managed runtime and related files in `~/.vite-plus`. If needed, you can override that location with `VP_HOME`.
+
+If you want to keep that behavior, run:
+
+```bash
+vp env on
+```
+
+This enables managed mode, where the shims always use the Vite+-managed Node.js installation.
+
+If you do not want Vite+ to manage Node.js first, run:
+
+```bash
+vp env off
+```
+
+This switches to system-first mode, where the shims prefer your system Node.js and only fall back to the Vite+-managed runtime when needed.
+
+## Commands
+
+### Setup
+
+- `vp env setup` creates or updates shims in `VP_HOME/bin`
+- `vp env on` enables managed mode so shims always use Vite+-managed Node.js
+- `vp env off` enables system-first mode so shims prefer system Node.js first
+- `vp env print` prints the shell snippet for the current session
+
+### Manage
+
+- `vp env default` sets or shows the global default Node.js version
+- `vp env pin` pins a Node.js version in the current directory
+- `vp env unpin` removes `.node-version` from the current directory
+- `vp env use` sets a Node.js version for the current shell session
+- `vp env install` installs a Node.js version
+- `vp env uninstall` removes an installed Node.js version
+- `vp env exec` runs a command with a specific Node.js version
+- `vp node` runs a Node.js script — shorthand for `vp env exec node`
+
+### Inspect
+
+- `vp env current` shows the current resolved environment
+- `vp env doctor` runs environment diagnostics
+- `vp env which` shows which tool path will be used
+- `vp env list` shows locally installed Node.js versions
+- `vp env list-remote` shows available Node.js versions from the registry
+
+## Project Setup
+
+- Pin a project version with `.node-version`
+- Use `vp install`, `vp dev`, and `vp build` normally
+- Let Vite+ pick the right runtime for the project
+
+## Examples
+
+```bash
+# Setup
+vp env setup                  # Create shims for node, npm, npx
+vp env on                     # Use Vite+ managed Node.js
+vp env print                  # Print shell snippet for this session
+
+# Manage
+vp env pin lts                # Pin the project to the latest LTS release
+vp env install                # Install the version from .node-version or package.json
+vp env default lts            # Set the global default version
+vp env use 20                 # Use Node.js 20 for the current shell session
+vp env use --unset            # Remove the session override
+
+# Inspect
+vp env current                # Show current resolved environment
+vp env current --json         # JSON output for automation
+vp env which node             # Show which node binary will be used
+vp env list-remote --lts      # List only LTS versions
+
+# Execute
+vp env exec --node lts npm i  # Execute npm with latest LTS
+vp env exec node -v           # Use shim mode with automatic version resolution
+vp node script.js             # Shorthand: run a Node.js script with the resolved version
+vp node -e "console.log(1+1)" # Shorthand: forward any node flag or argument
+```
+
+## Custom Node.js Mirror
+
+By default, Vite+ downloads Node.js from `https://nodejs.org/dist`. If you're behind a corporate proxy or need to use an internal mirror (e.g., Artifactory), set the `VP_NODE_DIST_MIRROR` environment variable:
+
+```bash
+# Install a specific version from your custom mirror
+VP_NODE_DIST_MIRROR=https://my-mirror.example.com/nodejs/dist vp env install 22
+
+# Set the global default version using a custom mirror
+VP_NODE_DIST_MIRROR=https://my-mirror.example.com/nodejs/dist vp env default lts
+
+# Set it permanently in your shell profile (.bashrc, .zshrc, etc.)
+echo 'export VP_NODE_DIST_MIRROR=https://my-mirror.example.com/nodejs/dist' >> ~/.zshrc
+```

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

@@ -0,0 +1,41 @@
+# Format
+
+`vp fmt` formats code with Oxfmt.
+
+## Overview
+
+`vp fmt` is built on [Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html), the Oxc formatter. Oxfmt has full Prettier compatibility and is designed as a fast drop-in replacement for Prettier.
+
+Use `vp fmt` to format your project, and `vp check` to format, lint and type-check all at once.
+
+## Usage
+
+```bash
+vp fmt
+vp fmt --check
+vp fmt . --write
+```
+
+## Configuration
+
+Put formatting configuration directly in the `fmt` block in `vite.config.ts` so all your configuration stays in one place. We do not recommend using `.oxfmtrc.json` with Vite+.
+
+For editors, point the formatter config path at `./vite.config.ts` so format-on-save uses the same `fmt` block:
+
+```json [.vscode/settings.json]
+{
+  "oxc.fmt.configPath": "./vite.config.ts"
+}
+```
+
+For the upstream formatter behavior and configuration reference, see the [Oxfmt docs](https://oxc.rs/docs/guide/usage/formatter.html).
+
+```ts [vite.config.ts]
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  fmt: {
+    singleQuote: true,
+  },
+});
+```

package/skills/void/docs/node_modules/void/node_modules/vite-plus/docs/guide/ide-integration.md

@@ -0,0 +1,101 @@
+# IDE Integration
+
+Vite+ supports VS Code and Zed through editor-specific settings that `vp create` and `vp migrate` can automatically write into your project.
+
+## VS Code
+
+For the best VS Code experience with Vite+, install the [Vite Plus Extension Pack](https://marketplace.visualstudio.com/items?itemName=VoidZero.vite-plus-extension-pack). It currently includes:
+
+- `Oxc` for formatting and linting via `vp check`
+- `Vitest` for test runs via `vp test`
+
+When you create or migrate a project, Vite+ prompts whether you want editor config written for VS Code. `vp create` additionally sets `npm.scriptRunner` to `vp` so the VS Code NPM Scripts panel runs scripts through the Vite+ task runner. For migrated or existing projects, you can add this setting manually (see below).
+
+You can also manually set up the VS Code config:
+
+```json [.vscode/extensions.json]
+{
+  "recommendations": ["VoidZero.vite-plus-extension-pack"]
+}
+```
+
+```json [.vscode/settings.json]
+{
+  "editor.defaultFormatter": "oxc.oxc-vscode",
+  "[javascript]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+  "[javascriptreact]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+  "[typescript]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+  "[typescriptreact]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+  "oxc.fmt.configPath": "./vite.config.ts",
+  "editor.formatOnSave": true,
+  "editor.formatOnSaveMode": "file",
+  "editor.codeActionsOnSave": {
+    "source.fixAll.oxc": "explicit"
+  }
+}
+```
+
+This gives the project a shared default formatter and enables Oxc-powered fix actions on save. The language-specific override blocks (`[javascript]`, `[typescript]`, etc.) are required because VS Code prioritizes user-level `[language]` settings over the workspace-level `editor.defaultFormatter` — without them, a global Prettier configuration would silently take over. Setting `oxc.fmt.configPath` to `./vite.config.ts` keeps editor format-on-save aligned with the `fmt` block in your Vite+ config. Vite+ uses `formatOnSaveMode: "file"` because Oxfmt does not support partial formatting.
+
+To let the VS Code NPM Scripts panel run scripts through `vp`, add the following to your `.vscode/settings.json`:
+
+```json [.vscode/settings.json]
+{
+  "npm.scriptRunner": "vp"
+}
+```
+
+This is included automatically by `vp create` but not by `vp migrate`, since existing projects may have team members who do not have `vp` installed locally.
+
+## Zed
+
+For the best Zed experience with Vite+, install the [oxc-zed](https://github.com/oxc-project/oxc-zed) extension from the Zed extensions marketplace. It provides formatting and linting via `vp check`.
+
+When you create or migrate a project, Vite+ prompts you to choose whether you want the editor config written for Zed.
+
+You can also manually set up the Zed config:
+
+```json [.zed/settings.json]
+{
+  "lsp": {
+    "oxlint": {
+      "initialization_options": {
+        "settings": {
+          "run": "onType",
+          "fixKind": "safe_fix",
+          "typeAware": true,
+          "unusedDisableDirectives": "deny"
+        }
+      }
+    },
+    "oxfmt": {
+      "initialization_options": {
+        "settings": {
+          "configPath": "./vite.config.ts",
+          "run": "onSave"
+        }
+      }
+    }
+  },
+  "languages": {
+    "JavaScript": {
+      "format_on_save": "on",
+      "prettier": { "allowed": false },
+      "formatter": [{ "language_server": { "name": "oxfmt" } }],
+      "code_action": "source.fixAll.oxc"
+    },
+    "TypeScript": {
+      "format_on_save": "on",
+      "prettier": { "allowed": false },
+      "formatter": [{ "language_server": { "name": "oxfmt" } }]
+    },
+    "Vue.js": {
+      "format_on_save": "on",
+      "prettier": { "allowed": false },
+      "formatter": [{ "language_server": { "name": "oxfmt" } }]
+    }
+  }
+}
+```
+
+Setting `oxfmt.configPath` to `./vite.config.ts` keeps editor format-on-save aligned with the `fmt` block in your Vite+ config. The full generated config covers additional languages (CSS, HTML, JSON, Markdown, etc.) — run `vp create` or `vp migrate` to get the complete file written automatically.