vite-plus 0.1.0-alpha.0 → 0.1.1-alpha.0

package/AGENTS.md

@@ -2,43 +2,62 @@
 
 # Using Vite+, the Unified Toolchain for the Web
 
-This project is using Vite+, a modern toolchain built on top of Vite, Rolldown, Vitest, tsdown, Oxlint, and Oxfmt. Vite+ wraps these tools and package manager commands in a single, global CLI called `vp`. Vite+ is distinct from Vite, but it invokes Vite through `vp dev` and `vp build`.
+This project is using Vite+, a unified toolchain built on top of Vite, Rolldown, Vitest, tsdown, Oxlint, Oxfmt, and Vite Task. Vite+ wraps runtime management, package management, and frontend tooling in a single global CLI called `vp`. Vite+ is distinct from Vite, but it invokes Vite through `vp dev` and `vp build`.
 
 ## Vite+ Workflow
 
 `vp` is a global binary that handles the full development lifecycle. Run `vp help` to print a list of commands and `vp <command> --help` for information about a specific command.
 
-### Vite+ Commands
+### Start
+
+- create - Create a new project from a template
+- migrate - Migrate an existing project to Vite+
+- config - Configure hooks and agent integration
+- staged - Run linters on staged files
+- install (`i`) - Install dependencies
+- env - Manage Node.js versions
+
+### Develop
 
 - dev - Run the development server
-- build - Build for production
+- check - Run format, lint, and TypeScript type checks
 - lint - Lint code
-- test - Run tests
 - fmt - Format code
-- check - Run format, lint, and type checks
-- lib - Build library
-- migrate - Migrate an existing project to Vite+
-- create - Create a new monorepo package (in-project) or a new project (global)
-- exec - Execute a command in workspace packages (supports `--filter`, `-r`, `--parallel`)
-- run - Run tasks from `package.json` scripts
+- test - Run tests
 
-These commands map to their corresponding tools. For example, `vp dev --port 3000` runs Vite's dev server and works the same as Vite. `vp test` runs JavaScript tests through the bundled Vitest. The version of all tools can be checked using `vp --version`. This is useful when researching documentation, features, and bugs.
+### Execute
+
+- run - Run monorepo tasks
+- exec - Execute a command from local `node_modules/.bin`
+- dlx - Execute a package binary without installing it as a dependency
+- cache - Manage the task cache
+
+### Build
 
-### Package Manager Commands
+- build - Build for production
+- pack - Build libraries
+- preview - Preview production build
+
+### Manage Dependencies
 
 Vite+ automatically detects and wraps the underlying package manager such as pnpm, npm, or Yarn through the `packageManager` field in `package.json` or package manager-specific lockfiles.
 
-- install - Install all dependencies, or add packages if package names are provided
 - add - Add packages to dependencies
-- remove - Remove packages from dependencies
-- dlx - Execute a package binary without installing it as a dependency
-- info - View package information from the registry, including latest versions
-- link - Link packages for local development
+- remove (`rm`, `un`, `uninstall`) - Remove packages from dependencies
+- update (`up`) - Update packages to latest versions
+- dedupe - Deduplicate dependencies
 - outdated - Check for outdated packages
+- list (`ls`) - List installed packages
+- why (`explain`) - Show why a package is installed
+- info (`view`, `show`) - View package information from the registry
+- link (`ln`) / unlink - Manage local package links
 - pm - Forward a command to the package manager
-- unlink - Unlink packages
-- update - Update packages to their latest versions
-- why - Show why a package is installed
+
+### Maintain
+
+- upgrade - Update `vp` itself to the latest version
+
+These commands map to their corresponding tools. For example, `vp dev --port 3000` runs Vite's dev server and works the same as Vite. `vp test` runs JavaScript tests through the bundled Vitest. The version of all tools can be checked using `vp --version`. This is useful when researching documentation, features, and bugs.
 
 ## Common Pitfalls
 
@@ -46,11 +65,12 @@ Vite+ automatically detects and wraps the underlying package manager such as pnp
 - **Always use Vite commands to run tools:** Don't attempt to run `vp vitest` or `vp oxlint`. They do not exist. Use `vp test` and `vp lint` instead.
 - **Running scripts:** Vite+ commands take precedence over `package.json` scripts. If there is a `test` script defined in `scripts` that conflicts with the built-in `vp test` command, run it using `vp run test`.
 - **Do not install Vitest, Oxlint, Oxfmt, or tsdown directly:** Vite+ wraps these tools. They must not be installed directly. You cannot upgrade these tools by installing their latest versions. Always use Vite+ commands.
+- **Use Vite+ wrappers for one-off binaries:** Use `vp dlx` instead of package-manager-specific `dlx`/`npx` commands.
 - **Import JavaScript modules from `vite-plus`:** Instead of importing from `vite` or `vitest`, all modules should be imported from the project's `vite-plus` dependency. For example, `import { defineConfig } from 'vite-plus';` or `import { expect, test, vi } from 'vite-plus/test';`. You must not install `vitest` to import test utilities.
 - **Type-Aware Linting:** There is no need to install `oxlint-tsgolint`, `vp lint --type-aware` works out of the box.
 
 ## Review Checklist for Agents
 
 - [ ] Run `vp install` after pulling remote changes and before getting started.
-- [ ] Run `vp lint`, `vp fmt`, and `vp test` to validate changes.
+- [ ] Run `vp check` and `vp test` to validate changes.
 <!--VITE PLUS END-->

package/README.md

@@ -1,22 +1,26 @@
 # VITE+(⚡︎) Local CLI
 
 **The Unified Toolchain for the Web**
-_dev, build, test, lint, format, monorepo caching & more in a single dependency, built for scale, speed, and sanity_
+_runtime and package management, create, dev, check, test, build, pack, and monorepo task caching in a single dependency_
 
 This package provides the project-local version of Vite+. The global `vite` command automatically delegates to this package for all project-specific tasks.
 
 ---
 
-Vite+ combines [Vite](https://vite.dev/), [Vitest](https://vitest.dev/), [Oxlint](https://oxc.rs/docs/guide/usage/linter.html), [Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html), [tsdown](https://tsdown.dev/) and [Rolldown](https://rolldown.rs/) as a single zero-config toolchain:
+Vite+ is the unified entry point for local web development. It combines [Vite](https://vite.dev/), [Vitest](https://vitest.dev/), [Oxlint](https://oxc.rs/docs/guide/usage/linter.html), [Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html), [Rolldown](https://rolldown.rs/), [tsdown](https://tsdown.dev/), and [Vite Task](https://github.com/voidzero-dev/vite-task) into one zero-config toolchain that also manages runtime and package manager workflows:
 
-- **Dev Server:** Powered by Vite's fast development experience with native ES modules and instant HMR
-- **Build Tool:** Optimized production builds using Rolldown and Oxc
-- **Testing:** Seamless Vitest integration with fast feedback loops
-- **Linting:** Ships with Oxlint for quick code quality checks
-- **Task Runner:** Monorepo task execution with automated caching and dependency resolution
-- **Package Management:** Vite+ wraps package managers to provide a unified interface
+- **`vp env`:** Manage Node.js globally and per project
+- **`vp install`:** Install dependencies with automatic package manager detection
+- **`vp dev`:** Run Vite's fast native ESM dev server with instant HMR
+- **`vp check`:** Run formatting, linting, and type checks in one command
+- **`vp test`:** Run tests through bundled Vitest
+- **`vp build`:** Build applications for production with Vite + Rolldown
+- **`vp run`:** Execute monorepo tasks with caching and dependency-aware scheduling
+- **`vp pack`:** Build libraries for npm publishing or standalone app binaries
+- **`vp create` / `vp migrate`:** Scaffold new projects and migrate existing ones
 
-Vite+ is built to scale with your codebase while reducing your devtools to a single dependency.
+All of this is configured from your project root and works across Vite's framework ecosystem.
+Vite+ is fully open-source under the MIT license.
 
 ## Getting Started
 
@@ -25,44 +29,115 @@ Install Vite+ globally as `vp`:
 For Linux or macOS:
 
 ```bash
-curl -fsSL https://staging.viteplus.dev/install.sh | bash
+curl -fsSL https://viteplus.dev/install.sh | bash
 ```
 
 For Windows:
 
 ```bash
-irm https://staging.viteplus.dev/install.ps1 | iex
+irm https://viteplus.dev/install.ps1 | iex
 ```
 
 `vp` handles the full development lifecycle such as package management, development servers, linting, formatting, testing and building for production.
 
-### Vite+ Commands
+## Configuring Vite+
+
+Vite+ can be configured using a single `vite.config.ts` at the root of your project:
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  // Standard Vite configuration for dev/build/preview.
+  plugins: [],
+
+  // Vitest configuration.
+  test: {
+    include: ['src/**/*.test.ts'],
+  },
+
+  // Oxlint configuration.
+  lint: {
+    ignorePatterns: ['dist/**'],
+  },
+
+  // Oxfmt configuration.
+  fmt: {
+    semi: true,
+    singleQuote: true,
+  },
+
+  // Vite Task configuration.
+  run: {
+    tasks: {
+      'generate:icons': {
+        command: 'node scripts/generate-icons.js',
+        envs: ['ICON_THEME'],
+      },
+    },
+  },
+
+  // `vp staged` configuration.
+  staged: {
+    '*': 'vp check --fix',
+  },
+});
+```
+
+This lets you keep the configuration for your development server, build, test, lint, format, task runner, and staged-file workflow in one place with type-safe config and shared defaults.
+
+Use `vp migrate` to migrate to Vite+. It merges tool-specific config files such as `.oxlintrc*`, `.oxfmtrc*`, and lint-staged config into `vite.config.ts`.
+
+### CLI Workflows (`vp help`)
+
+#### Start
+
+- **create** - Create a new project from a template
+- **migrate** - Migrate an existing project to Vite+
+- **config** - Configure hooks and agent integration
+- **staged** - Run linters on staged files
+- **install** (`i`) - Install dependencies
+- **env** - Manage Node.js versions
+
+#### Develop
 
 - **dev** - Run the development server
-- **build** - Build for production
+- **check** - Run format, lint, and type checks
 - **lint** - Lint code
-- **test** - Run tests
 - **fmt** - Format code
-- **lib** - Build library
-- **migrate** - Migrate an existing project to Vite+
-- **create** - Create a new monorepo package (in-project) or a new project (global)
-- **run** - Run tasks from `package.json` scripts
+- **test** - Run tests
+
+#### Execute
+
+- **run** - Run monorepo tasks
+- **exec** - Execute a command from local `node_modules/.bin`
+- **dlx** - Execute a package binary without installing it as a dependency
+- **cache** - Manage the task cache
+
+#### Build
 
-### Package Manager Commands
+- **build** - Build for production
+- **pack** - Build libraries
+- **preview** - Preview production build
+
+#### Manage Dependencies
 
-Vite+ automatically detects and wraps the underlying package manager such as pnpm, npm, or Yarn through the `packageManager` field in `package.json` or package manager-specific lockfiles.
+Vite+ automatically wraps your package manager (pnpm, npm, or Yarn) based on `packageManager` and lockfiles:
 
-- **install** - Install all dependencies, or add packages if package names are provided
 - **add** - Add packages to dependencies
-- **remove** - Remove packages from dependencies
-- **dlx** - Execute a package binary without installing it as a dependency
-- **info** - View package information from the registry, including latest versions
-- **link** - Link packages for local development
-- **outdated** - Check for outdated packages
+- **remove** (`rm`, `un`, `uninstall`) - Remove packages from dependencies
+- **update** (`up`) - Update packages to latest versions
+- **dedupe** - Deduplicate dependencies
+- **outdated** - Check outdated packages
+- **list** (`ls`) - List installed packages
+- **why** (`explain`) - Show why a package is installed
+- **info** (`view`, `show`) - View package metadata from the registry
+- **link** (`ln`) / **unlink** - Manage local package links
 - **pm** - Forward a command to the package manager
-- **unlink** - Unlink packages
-- **update** - Update packages to their latest versions
-- **why** - Show why a package is installed
+
+#### Maintain
+
+- **upgrade** - Update `vp` itself to the latest version
 
 ### Scaffolding your first Vite+ project
 

package/dist/bin.d.ts

@@ -1,7 +1,7 @@
 /**
  * Unified entry point for both the local CLI (via bin/vp) and the global CLI (via Rust vp binary).
  *
- * Global commands (create, migrate, init, mcp, --version) are handled by rolldown-bundled modules.
+ * Global commands (create, migrate, config, mcp, staged, --version) are handled by rolldown-bundled modules.
  * All other commands are delegated to the Rust core through NAPI bindings, which
  * uses JavaScript tool resolver functions to locate tool binaries.
  *

package/dist/bin.js

@@ -1,7 +1,7 @@
 /**
  * Unified entry point for both the local CLI (via bin/vp) and the global CLI (via Rust vp binary).
  *
- * Global commands (create, migrate, init, mcp, --version) are handled by rolldown-bundled modules.
+ * Global commands (create, migrate, config, mcp, staged, --version) are handled by rolldown-bundled modules.
  * All other commands are delegated to the Rust core through NAPI bindings, which
  * uses JavaScript tool resolver functions to locate tool binaries.
  *
@@ -9,7 +9,9 @@
  * vite-plus installation using oxc_resolver and runs its dist/bin.js directly.
  * If no local installation is found, this global dist/bin.js is used as fallback.
  */
+import path from 'node:path';
 import { run } from '../binding/index.js';
+import { applyToolInitConfigToViteConfig, inspectInitCommand } from './init-config.js';
 import { doc } from './resolve-doc.js';
 import { fmt } from './resolve-fmt.js';
 import { lint } from './resolve-lint.js';
@@ -17,6 +19,7 @@ import { pack } from './resolve-pack.js';
 import { test } from './resolve-test.js';
 import { resolveUniversalViteConfig } from './resolve-vite-config.js';
 import { vite } from './resolve-vite.js';
+import { accent, log } from './utils/terminal.js';
 // Parse command line arguments
 let args = process.argv.slice(2);
 // Transform `vp help [command]` into `vp [command] --help`
@@ -35,9 +38,9 @@ else if (command === 'migrate') {
     // @ts-ignore — rolldown output
     await import('./global/migrate.js');
 }
-else if (command === 'init') {
+else if (command === 'config') {
     // @ts-ignore — rolldown output
-    await import('./global/init.js');
+    await import('./global/config.js');
 }
 else if (command === 'mcp') {
     // @ts-ignore — rolldown output
@@ -47,23 +50,57 @@ else if (command === '--version' || command === '-V') {
     // @ts-ignore — rolldown output
     await import('./global/version.js');
 }
+else if (command === 'staged') {
+    // @ts-ignore — rolldown output
+    await import('./global/staged.js');
+}
 else {
     // All other commands — delegate to Rust core via NAPI binding
-    run({
-        lint,
-        pack,
-        fmt,
-        vite,
-        test,
-        doc,
-        resolveUniversalViteConfig,
-        args: process.argv.slice(2),
-    })
-        .then((exitCode) => {
-        process.exit(exitCode);
-    })
-        .catch((err) => {
+    try {
+        const initInspection = inspectInitCommand(command, args.slice(1));
+        if (initInspection.handled &&
+            initInspection.configKey &&
+            initInspection.hasExistingConfigKey &&
+            initInspection.existingViteConfigPath) {
+            log(`Skipped initialization: '${accent(initInspection.configKey)}' already exists in '${accent(path.basename(initInspection.existingViteConfigPath))}'.`);
+            process.exit(0);
+        }
+        const exitCode = await run({
+            lint,
+            pack,
+            fmt,
+            vite,
+            test,
+            doc,
+            resolveUniversalViteConfig,
+            args: process.argv.slice(2),
+        });
+        let finalExitCode = exitCode;
+        if (exitCode === 0) {
+            try {
+                const result = await applyToolInitConfigToViteConfig(command, args.slice(1));
+                if (result.handled &&
+                    result.action === 'added' &&
+                    result.configKey &&
+                    result.viteConfigPath) {
+                    log(`Added '${accent(result.configKey)}' to '${accent(path.basename(result.viteConfigPath))}'.`);
+                }
+                if (result.handled &&
+                    result.action === 'skipped-existing' &&
+                    result.configKey &&
+                    result.viteConfigPath) {
+                    log(`Skipped initialization: '${accent(result.configKey)}' already exists in '${accent(path.basename(result.viteConfigPath))}'.`);
+                }
+            }
+            catch (err) {
+                console.error('[Vite+] Failed to initialize config in vite.config.ts:', err);
+                finalExitCode = 1;
+            }
+        }
+        process.exit(finalExitCode);
+    }
+    catch (err) {
         console.error('[Vite+] run error:', err);
         process.exit(1);
-    });
+    }
 }

package/dist/config/agent.d.ts

@@ -0,0 +1,9 @@
+import { type AgentConfig } from '../utils/agent.js';
+export interface AgentSetupSelection {
+    instructionFilePath: 'CLAUDE.md' | 'AGENTS.md';
+    agents: AgentConfig[];
+}
+export declare function resolveAgentSetup(root: string, interactive: boolean): Promise<AgentSetupSelection>;
+export declare function hasExistingAgentInstructions(root: string): boolean;
+export declare function injectAgentBlock(root: string, filePath: string): void;
+export declare function setupMcpConfig(root: string, selectedAgents: AgentConfig[]): void;

package/dist/config/agent.js

@@ -0,0 +1,190 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import * as prompts from '@voidzero-dev/vite-plus-prompts';
+import { detectAgents, getAgentById, } from '../utils/agent.js';
+import { writeJsonFile, readJsonFile } from '../utils/json.js';
+import { pkgRoot } from '../utils/path.js';
+function detectInstructionFilePath(root, agentConfigs) {
+    if (agentConfigs.some((a) => a.skillsDir === '.claude/skills')) {
+        return 'CLAUDE.md';
+    }
+    if (existsSync(join(root, 'CLAUDE.md'))) {
+        return 'CLAUDE.md';
+    }
+    return 'AGENTS.md';
+}
+async function pickAgentWhenUndetected() {
+    const choice = await prompts.select({
+        message: 'Could not detect your coding agent. Which one are you using?',
+        options: [
+            { value: 'claude-code', label: 'Claude Code' },
+            { value: 'cursor', label: 'Cursor' },
+            { value: 'codex', label: 'Codex' },
+            { value: 'gemini-cli', label: 'Gemini CLI' },
+            { value: 'generic', label: 'Generic' },
+        ],
+    });
+    if (prompts.isCancel(choice)) {
+        prompts.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+    if (choice === 'generic') {
+        return {
+            instructionFilePath: 'AGENTS.md',
+            agents: [],
+        };
+    }
+    const selected = getAgentById(choice);
+    if (!selected) {
+        return {
+            instructionFilePath: 'AGENTS.md',
+            agents: [],
+        };
+    }
+    return {
+        instructionFilePath: choice === 'claude-code' ? 'CLAUDE.md' : 'AGENTS.md',
+        agents: [selected],
+    };
+}
+export async function resolveAgentSetup(root, interactive) {
+    const detected = detectAgents(root);
+    if (detected.length > 0 || !interactive) {
+        return {
+            instructionFilePath: detectInstructionFilePath(root, detected),
+            agents: detected,
+        };
+    }
+    return pickAgentWhenUndetected();
+}
+// --- Version and template reading ---
+function getOwnVersion() {
+    const pkg = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf-8'));
+    if (typeof pkg.version !== 'string') {
+        throw new Error('vite-plus package.json is missing a "version" field');
+    }
+    return pkg.version;
+}
+function readAgentPrompt() {
+    return readFileSync(join(pkgRoot, 'AGENTS.md'), 'utf-8');
+}
+// --- Versioned injection ---
+const MARKER_OPEN_RE = /<!--injected-by-vite-plus-v([\w.+-]+)-->/;
+const MARKER_CLOSE = '<!--/injected-by-vite-plus-->';
+const MARKER_BLOCK_RE = /<!--injected-by-vite-plus-v[\w.+-]+-->\n[\s\S]*?<!--\/injected-by-vite-plus-->/;
+export function hasExistingAgentInstructions(root) {
+    for (const file of ['AGENTS.md', 'CLAUDE.md']) {
+        const fullPath = join(root, file);
+        if (existsSync(fullPath)) {
+            const content = readFileSync(fullPath, 'utf-8');
+            if (MARKER_OPEN_RE.test(content)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function injectAgentBlock(root, filePath) {
+    const fullPath = join(root, filePath);
+    const version = getOwnVersion();
+    const promptContent = readAgentPrompt();
+    const openMarker = `<!--injected-by-vite-plus-v${version}-->`;
+    const block = `${openMarker}\n${promptContent}\n${MARKER_CLOSE}`;
+    if (existsSync(fullPath)) {
+        const existing = readFileSync(fullPath, 'utf-8');
+        const match = existing.match(MARKER_OPEN_RE);
+        if (match) {
+            if (match[1] === version) {
+                prompts.log.info(`${filePath} already has Vite+ instructions (v${version})`);
+                return;
+            }
+            // Replace existing block with updated version
+            const updated = existing.replace(MARKER_BLOCK_RE, block);
+            if (updated === existing) {
+                // Closing marker is missing or malformed — append fresh block
+                const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+                writeFileSync(fullPath, existing + separator + block + '\n');
+                prompts.log.warn(`Existing Vite+ block in ${filePath} was malformed; appended fresh block`);
+            }
+            else {
+                writeFileSync(fullPath, updated);
+                prompts.log.success(`Updated Vite+ instructions in ${filePath} (v${match[1]} → v${version})`);
+            }
+        }
+        else {
+            // Append block to end of file
+            const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+            writeFileSync(fullPath, existing + separator + block + '\n');
+            prompts.log.success(`Added Vite+ instructions to ${filePath}`);
+        }
+    }
+    else {
+        writeFileSync(fullPath, block + '\n');
+        prompts.log.success(`Created ${filePath} with Vite+ instructions`);
+    }
+}
+// --- MCP config ---
+function writeMcpConfigForTarget(root, target) {
+    const fullPath = join(root, target.filePath);
+    let existing = {};
+    if (existsSync(fullPath)) {
+        try {
+            existing = readJsonFile(fullPath);
+        }
+        catch {
+            prompts.log.warn(`Could not parse ${target.filePath} — skipping MCP config. Please add the config manually.`);
+            return;
+        }
+    }
+    if (!existing[target.rootKey]) {
+        existing[target.rootKey] = {};
+    }
+    if (existing[target.rootKey]['vite-plus']) {
+        prompts.log.info(`${target.filePath} already has vite-plus MCP config`);
+        return;
+    }
+    existing[target.rootKey]['vite-plus'] = {
+        command: 'npx',
+        args: ['vp', 'mcp'],
+        ...target.extraFields,
+    };
+    mkdirSync(dirname(fullPath), { recursive: true });
+    writeJsonFile(fullPath, existing);
+    prompts.log.success(`Added vite-plus MCP server to ${target.filePath}`);
+}
+function pickMcpTarget(root, targets) {
+    if (targets.length === 1) {
+        return targets[0];
+    }
+    return targets.find((t) => existsSync(join(root, t.filePath))) ?? targets[0];
+}
+export function setupMcpConfig(root, selectedAgents) {
+    if (selectedAgents.length === 0) {
+        prompts.note(JSON.stringify({
+            'vite-plus': {
+                command: 'npx',
+                args: ['vp', 'mcp'],
+            },
+        }, null, 2), 'Add this MCP server config to your agent');
+        return;
+    }
+    const mcpAgents = [];
+    const hintAgents = [];
+    for (const agent of selectedAgents) {
+        if (agent.mcpConfig) {
+            mcpAgents.push({ agent, targets: agent.mcpConfig });
+        }
+        else if (agent.mcpHint) {
+            hintAgents.push({ agent, hint: agent.mcpHint });
+        }
+    }
+    // Print hints for agents without project-level config
+    for (const { agent, hint } of hintAgents) {
+        prompts.log.info(`${agent.displayName}: ${hint}`);
+    }
+    // Write config for agents with project-level support
+    for (const { agent, targets } of mcpAgents) {
+        const target = pickMcpTarget(root, targets);
+        prompts.log.info(`${agent.displayName} MCP target: ${target.filePath}`);
+        writeMcpConfigForTarget(root, target);
+    }
+}

package/dist/config/bin.d.ts

@@ -0,0 +1 @@
+export {};