@omnimod/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 salnika
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# @omnimod/core
+
+[![npm](https://img.shields.io/npm/v/%40omnimod%2Fcore?label=npm)](https://www.npmjs.com/package/@omnimod/core)
+[![CI](https://img.shields.io/github/actions/workflow/status/Salnika/omnimod/ci.yml?branch=master&label=ci)](https://github.com/Salnika/omnimod/actions/workflows/ci.yml)
+[![License](https://img.shields.io/github/license/Salnika/omnimod)](../../LICENSE)
+
+Core engine for omnimod, a modular codemod tool built on `oxc-parser` and
+`magic-string`.
+
+This package provides the plugin contract, parsing, AST walking, project
+orchestration, formatting hooks, and terminal diff rendering used by the CLI and
+plugins.
+
+## Install
+
+```bash
+pnpm add @omnimod/core
+```
+
+## API
+
+```ts
+import { definePlugin, run, walk } from "@omnimod/core";
+```
+
+Main exports:
+
+- `definePlugin`: create a typed omnimod plugin.
+- `run`: execute a plugin across a project.
+- `parseFile`: parse JS, JSX, TS, and TSX files.
+- `walk`: traverse ESTree-compatible AST nodes.
+- `detectFixers` and `formatFiles`: run detected project formatters after writes.
+- `renderDiff` and `renderEmitted`: render terminal output for changed and emitted files.
+
+## Plugin Lifecycle
+
+Plugins can implement `analyze`, `transform`, and `finalize` phases. `analyze`
+runs across all files first, `transform` applies edits per file, and `finalize`
+can emit follow-up files such as migration notes.

package/dist/index.d.mts

@@ -0,0 +1,205 @@
+import MagicString from "magic-string";
+
+//#region src/format.d.ts
+interface Fixer {
+  /** Display name, e.g. "prettier". */
+  tool: string;
+  /** Resolved absolute path of the binary. */
+  bin: string;
+  /** Build the argv for a batch of files. */
+  args: (files: string[]) => string[];
+}
+interface FormatResult {
+  /** Tools that were invoked (in order). */
+  tools: string[];
+  /** Non-fatal notes (formatting is best-effort; the files are already written). */
+  errors: string[];
+}
+/**
+ * Detect the project's own formatter/linter fixers so generated code matches the
+ * project's conventions (quotes, semicolons, indentation, import order, …).
+ * Biome is all-in-one; otherwise eslint --fix (lint) then prettier/dprint (format).
+ */
+declare function detectFixers(root: string): Fixer[];
+/**
+ * Run the project's detected fixers over the given files (best-effort — a fixer
+ * that exits non-zero, e.g. eslint with remaining lint errors, still counts as run).
+ */
+declare function formatFiles(root: string, files: string[]): Promise<FormatResult>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * A parsed AST node. oxc-parser emits ESTree-compatible nodes; we type them
+ * structurally so plugins can navigate freely while keeping `type`/`start`/`end`
+ * strongly typed. Byte offsets are UTF-16 code-unit indices (JS string indices),
+ * so they can be fed directly to magic-string.
+ */
+interface Node {
+  type: string;
+  start: number;
+  end: number;
+  [key: string]: unknown;
+}
+interface Program extends Node {
+  type: "Program";
+  body: Node[];
+}
+type Severity = "info" | "warn" | "error";
+interface Diagnostic {
+  message: string;
+  severity: Severity;
+  /** Absolute path of the file the diagnostic refers to. */
+  file: string;
+  /** 1-based line number, when known. */
+  line?: number;
+}
+interface EmittedFile {
+  /** Path of the file to create (absolute, or relative to the run root). */
+  path: string;
+  contents: string;
+}
+/** Everything a plugin needs to inspect and rewrite a single file. */
+interface FileContext {
+  /** Absolute path of the file being processed. */
+  path: string;
+  /** Original, unmodified source text. */
+  source: string;
+  /** Parsed program (oxc AST). */
+  program: Program;
+  /** Comments collected by the parser. */
+  comments: Node[];
+  /**
+   * Edit buffer. Mutate this via overwrite/appendLeft/remove to change the file;
+   * untouched regions keep their exact original formatting.
+   */
+  magic: MagicString;
+  /** Report a diagnostic (warning / manual follow-up). */
+  report(diagnostic: Omit<Diagnostic, "file">): void;
+  /** Emit a new generated file (e.g. a sibling `.css.ts`). */
+  emit(file: EmittedFile): void;
+}
+/** Shared, cross-file context. `state` is the plugin's own reduce target. */
+interface ProjectContext<State = unknown> {
+  /** Absolute project root. */
+  root: string;
+  /** Plugin-defined shared store, typically populated during `analyze`. */
+  state: State;
+  /** Resolve a relative import specifier to an absolute path (best-effort). */
+  resolve(fromFile: string, specifier: string): string | null;
+}
+/**
+ * A codemod plugin. The lifecycle is a two-phase map/reduce so plugins can do
+ * cross-file work: `analyze` runs over every file first (collecting facts into
+ * `state`), then `transform` runs over every file (rewriting using that state),
+ * then `finalize` may emit shared files.
+ */
+interface Plugin<Options = Record<string, unknown>, State = unknown> {
+  name: string;
+  description?: string;
+  /** Glob patterns of files to include (relative to root). */
+  include?: string[];
+  /** Glob patterns to exclude. */
+  exclude?: string[];
+  /** Create the initial shared state. Defaults to `{}`. */
+  createState?(): State;
+  /** Optional first pass: collect cross-file facts into `project.state`. */
+  analyze?(file: FileContext, project: ProjectContext<State>, options: Options): void | Promise<void>;
+  /** Main pass: mutate `file.magic` and/or `file.emit(...)`. */
+  transform(file: FileContext, project: ProjectContext<State>, options: Options): void | Promise<void>;
+  /** Optional final pass: emit shared files (e.g. `theme.css.ts`). */
+  finalize?(project: ProjectContext<State>, options: Options): EmittedFile[] | void;
+}
+interface RunOptions<Options = Record<string, unknown>> {
+  /** Absolute or relative project root to operate on. */
+  root: string;
+  /** Override the plugin's include globs. */
+  include?: string[];
+  /** Additional exclude globs. */
+  exclude?: string[];
+  /** When true, write changes to disk; otherwise this is a dry-run. */
+  write?: boolean;
+  /**
+   * Run the project's own formatter/linter `--fix` on the written files so output
+   * matches its conventions. Defaults to true; only runs in write mode.
+   */
+  format?: boolean;
+  /** Options forwarded to the plugin. */
+  options?: Options;
+}
+interface FileChange {
+  path: string;
+  before: string;
+  after: string;
+}
+interface RunResult {
+  /** Files whose contents changed. */
+  changed: FileChange[];
+  /** Newly created files. */
+  emitted: EmittedFile[];
+  /** Warnings and manual-follow-up notes. */
+  diagnostics: Diagnostic[];
+  /** Formatters run on the written files (write mode only). */
+  format?: FormatResult;
+}
+//#endregion
+//#region src/parse.d.ts
+interface ParsedFile {
+  program: Program;
+  comments: Node[];
+  /** Parser errors (oxc reports rather than throws). Empty when the file is valid. */
+  errors: unknown[];
+}
+type Lang = "js" | "jsx" | "ts" | "tsx";
+/** Pick an oxc language mode from a file path. `.js`/`.jsx` allow JSX for safety. */
+declare function langFromPath(path: string): Lang;
+declare function parseFile(path: string, source: string): ParsedFile;
+//#endregion
+//#region src/walk.d.ts
+type WalkResult = void | "skip";
+/**
+ * Visitor callback. Return `"skip"` to avoid descending into a node's children.
+ * `key`/`index` describe where the node sits in its parent.
+ */
+type Visitor = (node: Node, parent: Node | null, key: string | null, index: number | null) => WalkResult;
+/**
+ * Depth-first walk over an oxc ESTree AST. Engine-agnostic: it recurses into any
+ * own property whose value is a node (has a string `type`) or an array of nodes.
+ */
+declare function walk(root: Node, enter: Visitor, leave?: Visitor): void;
+//#endregion
+//#region src/define.d.ts
+/**
+ * Identity helper for authoring a plugin. It changes nothing at runtime but
+ * gives full type inference and a single, discoverable entry point:
+ *
+ * ```ts
+ * import { definePlugin } from "@omnimod/core";
+ *
+ * export default definePlugin({
+ *   name: "my-codemod",
+ *   include: ["**\/*.ts"],
+ *   transform(file) {
+ *     // mutate file.magic / file.emit(...) / file.report(...)
+ *   },
+ * });
+ * ```
+ */
+declare function definePlugin<Options = Record<string, unknown>, State = unknown>(plugin: Plugin<Options, State>): Plugin<Options, State>;
+//#endregion
+//#region src/runner.d.ts
+/** Best-effort resolution of a relative import specifier to an absolute file path. */
+declare function resolveImport(fromFile: string, specifier: string): string | null;
+/**
+ * Run a single plugin over a project: discover files, parse each once, then
+ * drive the analyze → transform → finalize lifecycle. Dry-run by default;
+ * pass `write: true` to persist changes and emitted files.
+ */
+declare function run<Options, State>(plugin: Plugin<Options, State>, runOptions: RunOptions<Options>): Promise<RunResult>;
+//#endregion
+//#region src/diff.d.ts
+/** A colored unified diff for a modified file. */
+declare function renderDiff(change: FileChange): string;
+/** A colored unified diff for a newly created file. */
+declare function renderEmitted(file: EmittedFile): string;
+//#endregion
+export { type Diagnostic, type EmittedFile, type FileChange, type FileContext, type Fixer, type FormatResult, type Lang, type Node, type ParsedFile, type Plugin, type Program, type ProjectContext, type RunOptions, type RunResult, type Severity, type Visitor, type WalkResult, definePlugin, detectFixers, formatFiles, langFromPath, parseFile, renderDiff, renderEmitted, resolveImport, run, walk };

package/dist/index.mjs

@@ -0,0 +1,380 @@
+import { parseSync } from "oxc-parser";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { globby } from "globby";
+import MagicString from "magic-string";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createTwoFilesPatch } from "diff";
+import pc from "picocolors";
+//#region src/parse.ts
+/** Pick an oxc language mode from a file path. `.js`/`.jsx` allow JSX for safety. */
+function langFromPath(path) {
+	if (path.endsWith(".tsx")) return "tsx";
+	if (path.endsWith(".ts") || path.endsWith(".mts") || path.endsWith(".cts")) return "ts";
+	return "jsx";
+}
+function parseFile(path, source) {
+	const result = parseSync(path, source, {
+		lang: langFromPath(path),
+		sourceType: "module"
+	});
+	return {
+		program: result.program,
+		comments: result.comments ?? [],
+		errors: result.errors ?? []
+	};
+}
+//#endregion
+//#region src/walk.ts
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"start",
+	"end",
+	"range",
+	"loc",
+	"parent"
+]);
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/**
+* Depth-first walk over an oxc ESTree AST. Engine-agnostic: it recurses into any
+* own property whose value is a node (has a string `type`) or an array of nodes.
+*/
+function walk(root, enter, leave) {
+	function visit(node, parent, key, index) {
+		if (enter(node, parent, key, index) === "skip") return;
+		for (const childKey in node) {
+			if (SKIP_KEYS.has(childKey)) continue;
+			const value = node[childKey];
+			if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+				const child = value[i];
+				if (isNode(child)) visit(child, node, childKey, i);
+			}
+			else if (isNode(value)) visit(value, node, childKey, null);
+		}
+		leave?.(node, parent, key, index);
+	}
+	visit(root, null, null, null);
+}
+//#endregion
+//#region src/define.ts
+/**
+* Identity helper for authoring a plugin. It changes nothing at runtime but
+* gives full type inference and a single, discoverable entry point:
+*
+* ```ts
+* import { definePlugin } from "@omnimod/core";
+*
+* export default definePlugin({
+*   name: "my-codemod",
+*   include: ["**\/*.ts"],
+*   transform(file) {
+*     // mutate file.magic / file.emit(...) / file.report(...)
+*   },
+* });
+* ```
+*/
+function definePlugin(plugin) {
+	return plugin;
+}
+//#endregion
+//#region src/format.ts
+const execFileAsync = promisify(execFile);
+const CHUNK_SIZE = 80;
+const CONFIG_FILES = {
+	biome: ["biome.json", "biome.jsonc"],
+	prettier: [
+		".prettierrc",
+		".prettierrc.json",
+		".prettierrc.json5",
+		".prettierrc.yaml",
+		".prettierrc.yml",
+		".prettierrc.js",
+		".prettierrc.cjs",
+		".prettierrc.mjs",
+		".prettierrc.ts",
+		".prettierrc.toml",
+		"prettier.config.js",
+		"prettier.config.cjs",
+		"prettier.config.mjs",
+		"prettier.config.ts"
+	],
+	dprint: [
+		"dprint.json",
+		".dprint.json",
+		"dprint.jsonc"
+	],
+	eslint: [
+		".eslintrc",
+		".eslintrc.js",
+		".eslintrc.cjs",
+		".eslintrc.json",
+		".eslintrc.yaml",
+		".eslintrc.yml",
+		"eslint.config.js",
+		"eslint.config.mjs",
+		"eslint.config.cjs",
+		"eslint.config.ts"
+	]
+};
+/** Walk from `root` up to the filesystem root, calling `check` on each directory. */
+function walkUp(root, check) {
+	let dir = root;
+	for (;;) {
+		if (check(dir)) return true;
+		const parent = dirname(dir);
+		if (parent === dir) return false;
+		dir = parent;
+	}
+}
+function hasConfig(root, names) {
+	return walkUp(root, (dir) => names.some((name) => existsSync(join(dir, name))));
+}
+function hasPackageJsonKey(root, key) {
+	return walkUp(root, (dir) => {
+		const pkgPath = join(dir, "package.json");
+		if (!existsSync(pkgPath)) return false;
+		try {
+			return key in JSON.parse(readFileSync(pkgPath, "utf8"));
+		} catch {
+			return false;
+		}
+	});
+}
+function findBin(root, bin) {
+	let found = null;
+	walkUp(root, (dir) => {
+		const candidate = join(dir, "node_modules", ".bin", bin);
+		if (existsSync(candidate)) {
+			found = candidate;
+			return true;
+		}
+		return false;
+	});
+	return found;
+}
+/**
+* Detect the project's own formatter/linter fixers so generated code matches the
+* project's conventions (quotes, semicolons, indentation, import order, …).
+* Biome is all-in-one; otherwise eslint --fix (lint) then prettier/dprint (format).
+*/
+function detectFixers(root) {
+	const biome = findBin(root, "biome");
+	if (biome && hasConfig(root, CONFIG_FILES.biome)) return [{
+		tool: "biome",
+		bin: biome,
+		args: (files) => [
+			"check",
+			"--write",
+			"--files-ignore-unknown=true",
+			...files
+		]
+	}];
+	const fixers = [];
+	const eslint = findBin(root, "eslint");
+	if (eslint && (hasConfig(root, CONFIG_FILES.eslint) || hasPackageJsonKey(root, "eslintConfig"))) fixers.push({
+		tool: "eslint",
+		bin: eslint,
+		args: (files) => [
+			"--fix",
+			"--no-error-on-unmatched-pattern",
+			...files
+		]
+	});
+	const prettier = findBin(root, "prettier");
+	if (prettier && (hasConfig(root, CONFIG_FILES.prettier) || hasPackageJsonKey(root, "prettier"))) fixers.push({
+		tool: "prettier",
+		bin: prettier,
+		args: (files) => [
+			"--write",
+			"--ignore-unknown",
+			...files
+		]
+	});
+	else {
+		const dprint = findBin(root, "dprint");
+		if (dprint && hasConfig(root, CONFIG_FILES.dprint)) fixers.push({
+			tool: "dprint",
+			bin: dprint,
+			args: (files) => ["fmt", ...files]
+		});
+	}
+	return fixers;
+}
+function chunk(items, size) {
+	const chunks = [];
+	for (let i = 0; i < items.length; i += size) chunks.push(items.slice(i, i + size));
+	return chunks;
+}
+/**
+* Run the project's detected fixers over the given files (best-effort — a fixer
+* that exits non-zero, e.g. eslint with remaining lint errors, still counts as run).
+*/
+async function formatFiles(root, files) {
+	const tools = [];
+	const errors = [];
+	if (files.length === 0) return {
+		tools,
+		errors
+	};
+	for (const fixer of detectFixers(root)) {
+		tools.push(fixer.tool);
+		for (const batch of chunk(files, CHUNK_SIZE)) try {
+			await execFileAsync(fixer.bin, fixer.args(batch), {
+				cwd: root,
+				maxBuffer: 32 * 1024 * 1024,
+				timeout: 18e4
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message.split("\n")[0] : String(error);
+			errors.push(`${fixer.tool}: ${message}`);
+		}
+	}
+	return {
+		tools,
+		errors
+	};
+}
+//#endregion
+//#region src/runner.ts
+const DEFAULT_INCLUDE = ["**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"];
+const DEFAULT_EXCLUDE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/*.d.ts"
+];
+const RESOLVE_EXTENSIONS = [
+	"",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".cts",
+	".mjs",
+	".cjs"
+];
+const RESOLVE_INDEX = [
+	"/index.ts",
+	"/index.tsx",
+	"/index.js",
+	"/index.jsx"
+];
+/** Best-effort resolution of a relative import specifier to an absolute file path. */
+function resolveImport(fromFile, specifier) {
+	if (!specifier.startsWith(".")) return null;
+	const base = resolve(dirname(fromFile), specifier);
+	for (const ext of RESOLVE_EXTENSIONS) {
+		const candidate = base + ext;
+		if (candidate && existsSync(candidate) && !candidate.endsWith("/")) return candidate;
+	}
+	for (const index of RESOLVE_INDEX) {
+		const candidate = base + index;
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+/**
+* Run a single plugin over a project: discover files, parse each once, then
+* drive the analyze → transform → finalize lifecycle. Dry-run by default;
+* pass `write: true` to persist changes and emitted files.
+*/
+async function run(plugin, runOptions) {
+	const root = resolve(runOptions.root);
+	const include = runOptions.include ?? plugin.include ?? DEFAULT_INCLUDE;
+	const exclude = [...DEFAULT_EXCLUDE, ...runOptions.exclude ?? plugin.exclude ?? []];
+	const options = runOptions.options ?? {};
+	const files = await globby(include, {
+		cwd: root,
+		absolute: true,
+		ignore: exclude,
+		gitignore: true,
+		onlyFiles: true
+	});
+	const diagnostics = [];
+	const emitted = [];
+	const project = {
+		root,
+		state: plugin.createState ? plugin.createState() : {},
+		resolve: resolveImport
+	};
+	const loaded = [];
+	for (const path of files) {
+		const source = await readFile(path, "utf8");
+		const parsed = parseFile(path, source);
+		const magic = new MagicString(source);
+		const ctx = {
+			path,
+			source,
+			program: parsed.program,
+			comments: parsed.comments,
+			magic,
+			report: (d) => diagnostics.push({
+				...d,
+				file: path
+			}),
+			emit: (f) => emitted.push(f)
+		};
+		loaded.push({
+			path,
+			source,
+			ctx
+		});
+	}
+	if (plugin.analyze) for (const { ctx } of loaded) await plugin.analyze(ctx, project, options);
+	for (const { ctx } of loaded) await plugin.transform(ctx, project, options);
+	if (plugin.finalize) {
+		const extra = plugin.finalize(project, options);
+		if (extra) emitted.push(...extra);
+	}
+	const changed = [];
+	for (const { path, source, ctx } of loaded) if (ctx.magic.hasChanged()) changed.push({
+		path,
+		before: source,
+		after: ctx.magic.toString()
+	});
+	let format;
+	if (runOptions.write) {
+		const written = [];
+		for (const change of changed) {
+			await writeFile(change.path, change.after, "utf8");
+			written.push(change.path);
+		}
+		for (const file of emitted) {
+			const abs = isAbsolute(file.path) ? file.path : resolve(root, file.path);
+			await mkdir(dirname(abs), { recursive: true });
+			await writeFile(abs, file.contents, "utf8");
+			written.push(abs);
+		}
+		if (runOptions.format !== false && written.length > 0) format = await formatFiles(root, written);
+	}
+	return {
+		changed,
+		emitted,
+		diagnostics,
+		format
+	};
+}
+//#endregion
+//#region src/diff.ts
+function colorize(patch) {
+	return patch.split("\n").map((line) => {
+		if (line.startsWith("+") && !line.startsWith("+++")) return pc.green(line);
+		if (line.startsWith("-") && !line.startsWith("---")) return pc.red(line);
+		if (line.startsWith("@@")) return pc.cyan(line);
+		return line;
+	}).join("\n");
+}
+/** A colored unified diff for a modified file. */
+function renderDiff(change) {
+	return colorize(createTwoFilesPatch(change.path, change.path, change.before, change.after, void 0, void 0, { context: 3 }));
+}
+/** A colored unified diff for a newly created file. */
+function renderEmitted(file) {
+	return colorize(createTwoFilesPatch("/dev/null", file.path, "", file.contents, void 0, void 0, { context: 3 }));
+}
+//#endregion
+export { definePlugin, detectFixers, formatFiles, langFromPath, parseFile, renderDiff, renderEmitted, resolveImport, run, walk };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@omnimod/core",
+  "version": "0.1.0",
+  "description": "Core engine for omnimod, a modular codemod tool built on oxc-parser + magic-string.",
+  "keywords": [
+    "ast",
+    "codemod",
+    "magic-string",
+    "oxc",
+    "refactoring",
+    "typescript"
+  ],
+  "homepage": "https://salnika.github.io/omnimod/",
+  "bugs": "https://github.com/salnika/omnimod/issues",
+  "license": "MIT",
+  "author": "salnika",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/salnika/omnimod.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "diff": "^9.0.0",
+    "globby": "^16.2.0",
+    "magic-string": "^0.30.21",
+    "oxc-parser": "^0.138.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "@typescript/native-preview": "7.0.0-dev.20260509.2",
+    "typescript": "^6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
+    "vite-plus": "0.2.2"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}