@omnimod/plugin-webpack-to-vite 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,26 @@
+# @omnimod/plugin-webpack-to-vite
+
+[![npm](https://img.shields.io/npm/v/%40omnimod%2Fplugin-webpack-to-vite?label=npm)](https://www.npmjs.com/package/@omnimod/plugin-webpack-to-vite)
+[![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)
+
+omnimod plugin that scaffolds a Vite config from a Webpack config.
+
+## Use With The CLI
+
+```bash
+omnimod run webpack-to-vite "webpack.config.{js,ts,cjs,mjs}"
+omnimod run webpack-to-vite "webpack.config.{js,ts,cjs,mjs}" --write
+```
+
+## Use As A Library
+
+```ts
+import { webpackToVite } from "@omnimod/plugin-webpack-to-vite";
+```
+
+## Notes
+
+The plugin extracts supported Webpack configuration fields and emits a Vite
+configuration scaffold. Project-specific loader, plugin, and runtime behavior is
+reported for manual migration.

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+//#region src/plugin.d.ts
+type WebpackToViteOptions = Record<string, unknown>;
+/**
+ * Scaffold a Vite config from a Webpack config. Webpack configs are arbitrary
+ * JS, so this never transforms the original file. Instead it reads what it can
+ * *statically* (resolve.alias/extensions, DefinePlugin, devServer.port/proxy,
+ * entry/output, module.rules) and emits a sibling `vite.config.js` skeleton plus
+ * a `WEBPACK_MIGRATION.md` agent guide, then reports where to look next.
+ */
+declare const webpackToVite: import("@omnimod/core").Plugin<WebpackToViteOptions, unknown>;
+//#endregion
+export { type WebpackToViteOptions, webpackToVite as default, webpackToVite };

package/dist/index.mjs

@@ -0,0 +1,496 @@
+import { definePlugin } from "@omnimod/core";
+import { cast } from "@omnimod/plugin-utils";
+//#region src/extract.ts
+/** Read a property's key name (identifier or string literal). */
+function keyName(key) {
+	if (key.type === "Identifier") return cast(key).name;
+	if (key.type === "Literal") {
+		const value = cast(key).value;
+		return typeof value === "string" ? value : String(value);
+	}
+	return null;
+}
+/** Find a property by name on an object expression. */
+function prop(obj, name) {
+	for (const p of obj.properties) {
+		if (p.type !== "Property") continue;
+		const property = cast(p);
+		if (keyName(property.key) === name) return property;
+	}
+	return null;
+}
+function asObject(node) {
+	if (!node || node.type !== "ObjectExpression") return null;
+	return cast(node);
+}
+function stringLiteral(node) {
+	if (!node || node.type !== "Literal") return null;
+	const value = cast(node).value;
+	return typeof value === "string" ? value : null;
+}
+/**
+* Find the exported config object: `module.exports = {…}` or
+* `export default {…}`. Function/array-returning configs are not resolved
+* statically (they yield `found: false`).
+*/
+function findConfigObject(program) {
+	for (const stmt of program.body) if (stmt.type === "ExpressionStatement") {
+		const expr = cast(stmt).expression;
+		if (expr.type !== "AssignmentExpression") continue;
+		const assign = cast(expr);
+		if (!isModuleExports(assign.left)) continue;
+		const obj = asObject(assign.right);
+		if (obj) return obj;
+	} else if (stmt.type === "ExportDefaultDeclaration") {
+		const decl = cast(stmt).declaration;
+		const obj = asObject(decl);
+		if (obj) return obj;
+	}
+	return null;
+}
+/** True when `node` is the `module.exports` member expression. */
+function isModuleExports(node) {
+	if (node.type !== "MemberExpression") return false;
+	const member = cast(node);
+	if (member.object.type !== "Identifier" || member.property.type !== "Identifier") return false;
+	return cast(member.object).name === "module" && cast(member.property).name === "exports";
+}
+/** Collect alias entries from `resolve.alias`. */
+function readAliases(aliasObj, source) {
+	const aliases = [];
+	let haveHelpers = false;
+	for (const p of aliasObj.properties) {
+		if (p.type !== "Property") continue;
+		const property = cast(p);
+		const key = keyName(property.key);
+		if (key === null) continue;
+		const literal = stringLiteral(property.value);
+		if (literal === null) haveHelpers = true;
+		aliases.push({
+			key,
+			valueSource: source.slice(property.value.start, property.value.end),
+			literal
+		});
+	}
+	return {
+		aliases,
+		haveHelpers
+	};
+}
+/** Read a string array like `extensions: [".js", ".ts"]`. */
+function readStringArray(node) {
+	if (!node || node.type !== "ArrayExpression") return null;
+	const arr = cast(node);
+	const out = [];
+	for (const el of arr.elements) {
+		if (!el) continue;
+		const str = stringLiteral(el);
+		if (str !== null) out.push(str);
+	}
+	return out;
+}
+/** Read `plugins: [ new webpack.DefinePlugin({...}) ]` into define entries. */
+function readDefine(pluginsNode, source) {
+	if (!pluginsNode || pluginsNode.type !== "ArrayExpression") return [];
+	const arr = cast(pluginsNode);
+	const out = [];
+	for (const el of arr.elements) {
+		if (!el || el.type !== "NewExpression") continue;
+		const created = cast(el);
+		if (!isDefinePlugin(created.callee)) continue;
+		const arg = created.arguments[0];
+		const obj = asObject(arg ?? null);
+		if (!obj) continue;
+		for (const p of obj.properties) {
+			if (p.type !== "Property") continue;
+			const property = cast(p);
+			const key = keyName(property.key);
+			if (key === null) continue;
+			out.push({
+				key,
+				valueSource: source.slice(property.value.start, property.value.end)
+			});
+		}
+	}
+	return out;
+}
+/** True when a callee resolves to `DefinePlugin` (bare or `webpack.DefinePlugin`). */
+function isDefinePlugin(callee) {
+	if (callee.type === "Identifier") return cast(callee).name === "DefinePlugin";
+	if (callee.type === "MemberExpression") {
+		const member = cast(callee);
+		return member.property.type === "Identifier" && cast(member.property).name === "DefinePlugin";
+	}
+	return false;
+}
+/** Read `module.rules: [...]` into a list of test + loader names. */
+function readRules(moduleNode, source) {
+	const moduleObj = asObject(moduleNode);
+	if (!moduleObj) return [];
+	const rulesProp = prop(moduleObj, "rules");
+	if (!rulesProp || rulesProp.value.type !== "ArrayExpression") return [];
+	const rules = cast(rulesProp.value);
+	const out = [];
+	for (const el of rules.elements) {
+		const ruleObj = asObject(el ?? null);
+		if (!ruleObj) continue;
+		const testProp = prop(ruleObj, "test");
+		const test = testProp ? source.slice(testProp.value.start, testProp.value.end) : null;
+		out.push({
+			test,
+			loaders: readLoaders(ruleObj)
+		});
+	}
+	return out;
+}
+/** Gather loader names from a rule's `use` / `loader` fields. */
+function readLoaders(ruleObj) {
+	const loaders = [];
+	const loaderProp = prop(ruleObj, "loader");
+	if (loaderProp) {
+		const str = stringLiteral(loaderProp.value);
+		if (str !== null) loaders.push(str);
+	}
+	const useProp = prop(ruleObj, "use");
+	if (useProp) collectUse(useProp.value, loaders);
+	return loaders;
+}
+/** `use` can be a string, an array of strings/objects, or `{ loader }` objects. */
+function collectUse(node, out) {
+	const str = stringLiteral(node);
+	if (str !== null) {
+		out.push(str);
+		return;
+	}
+	if (node.type === "ArrayExpression") {
+		for (const el of cast(node).elements) if (el) collectUse(el, out);
+		return;
+	}
+	const obj = asObject(node);
+	if (obj) {
+		const loaderProp = prop(obj, "loader");
+		if (loaderProp) {
+			const value = stringLiteral(loaderProp.value);
+			if (value !== null) out.push(value);
+		}
+	}
+}
+/** Parse the webpack config into the statically-readable fields we support. */
+function extractConfig(program, source) {
+	const empty = {
+		found: false,
+		aliases: [],
+		aliasesHaveHelpers: false,
+		extensions: null,
+		define: [],
+		devServerPort: null,
+		devServerProxy: null,
+		entry: null,
+		output: null,
+		rules: []
+	};
+	const config = findConfigObject(program);
+	if (!config) return empty;
+	const resolveObj = asObject(prop(config, "resolve")?.value ?? null);
+	let aliases = [];
+	let aliasesHaveHelpers = false;
+	let extensions = null;
+	if (resolveObj) {
+		const aliasObj = asObject(prop(resolveObj, "alias")?.value ?? null);
+		if (aliasObj) {
+			const read = readAliases(aliasObj, source);
+			aliases = read.aliases;
+			aliasesHaveHelpers = read.haveHelpers;
+		}
+		extensions = readStringArray(prop(resolveObj, "extensions")?.value ?? null);
+	}
+	const define = readDefine(prop(config, "plugins")?.value ?? null, source);
+	const devServerObj = asObject(prop(config, "devServer")?.value ?? null);
+	let devServerPort = null;
+	let devServerProxy = null;
+	if (devServerObj) {
+		const portProp = prop(devServerObj, "port");
+		if (portProp) devServerPort = source.slice(portProp.value.start, portProp.value.end);
+		const proxyProp = prop(devServerObj, "proxy");
+		if (proxyProp) devServerProxy = source.slice(proxyProp.value.start, proxyProp.value.end);
+	}
+	const entryProp = prop(config, "entry");
+	const entry = entryProp ? source.slice(entryProp.value.start, entryProp.value.end) : null;
+	const outputProp = prop(config, "output");
+	const output = outputProp ? source.slice(outputProp.value.start, outputProp.value.end) : null;
+	const rules = readRules(prop(config, "module")?.value ?? null, source);
+	return {
+		found: true,
+		aliases,
+		aliasesHaveHelpers,
+		extensions,
+		define,
+		devServerPort,
+		devServerProxy,
+		entry,
+		output,
+		rules
+	};
+}
+//#endregion
+//#region src/generate.ts
+/** JSON-quote a string for use as an object key/value. */
+function quote(value) {
+	return JSON.stringify(value);
+}
+/** Render the mapped `vite.config.js` skeleton from a parsed webpack config. */
+function renderViteConfig(config) {
+	const body = [];
+	const resolveLines = [];
+	if (config.aliases.length > 0) {
+		const aliasLines = config.aliases.map((alias) => {
+			if (alias.literal !== null) return `      ${quote(alias.key)}: ${quote(alias.literal)},`;
+			return `      ${quote(alias.key)}: ${alias.valueSource}, // TODO(omnimod): review webpack-only helper; Vite resolves relative to the config file`;
+		});
+		resolveLines.push("    alias: {", ...aliasLines, "    },");
+	}
+	if (config.extensions && config.extensions.length > 0) {
+		const exts = config.extensions.map((ext) => quote(ext)).join(", ");
+		resolveLines.push(`    extensions: [${exts}],`);
+	}
+	if (resolveLines.length > 0) body.push("  resolve: {", ...resolveLines, "  },");
+	if (config.define.length > 0) {
+		const defineLines = config.define.map((entry) => `    ${quote(entry.key)}: ${entry.valueSource},`);
+		body.push("  define: {", ...defineLines, "  },");
+	}
+	const serverLines = [];
+	if (config.devServerPort !== null) serverLines.push(`    port: ${config.devServerPort},`);
+	if (config.devServerProxy !== null) serverLines.push(`    proxy: ${config.devServerProxy}, // TODO(omnimod): Vite proxy uses the same http-proxy options; verify keys`);
+	if (serverLines.length > 0) body.push("  server: {", ...serverLines, "  },");
+	const notes = [];
+	if (config.entry !== null) notes.push(`  // TODO(omnimod): webpack entry was ${inlineComment(config.entry)}. Vite uses index.html as the entry point; move your entry <script> there.`);
+	if (config.output !== null) notes.push(`  // TODO(omnimod): webpack output was ${inlineComment(config.output)}. Configure Vite output via build.outDir / build.rollupOptions if needed.`);
+	if (config.rules.length > 0) notes.push("  // TODO(omnimod): module.rules (loaders) were not translated. See WEBPACK_MIGRATION.md for the Vite equivalents.");
+	notes.push("  // TODO(omnimod): add your framework plugin, e.g. `plugins: [react()]` from @vitejs/plugin-react.");
+	return `import { defineConfig } from "vite";\n\nexport default defineConfig({\n${[...body, ...notes].join("\n")}\n});\n`;
+}
+/** Collapse a source snippet into a single-line, comment-safe fragment. */
+function inlineComment(source) {
+	return source.replace(/\s+/g, " ").replace(/\*\//g, "* /").trim();
+}
+//#endregion
+//#region src/migration.ts
+/** Known webpack loader → Vite equivalent, keyed by a substring of the loader name. */
+const LOADER_MAP = [
+	{
+		match: "babel-loader",
+		label: "babel-loader",
+		vite: "Built in via esbuild. Remove; no config needed for standard JS/JSX/TS."
+	},
+	{
+		match: "ts-loader",
+		label: "ts-loader",
+		vite: "Built in via esbuild. Remove; Vite transpiles TypeScript out of the box (type-check separately with `tsc --noEmit`)."
+	},
+	{
+		match: "style-loader",
+		label: "style-loader",
+		vite: "Built in. Remove; Vite injects CSS automatically."
+	},
+	{
+		match: "css-loader",
+		label: "css-loader",
+		vite: "Built in. Remove; `import \"./x.css\"` just works. Use `*.module.css` for CSS Modules."
+	},
+	{
+		match: "sass-loader",
+		label: "sass-loader",
+		vite: "Install `sass` as a dev dependency; Vite compiles `.scss`/`.sass` automatically."
+	},
+	{
+		match: "postcss-loader",
+		label: "postcss-loader",
+		vite: "Add a `postcss.config.js`; Vite runs PostCSS automatically."
+	},
+	{
+		match: "less-loader",
+		label: "less-loader",
+		vite: "Install `less`; Vite compiles `.less` automatically."
+	},
+	{
+		match: "file-loader",
+		label: "file-loader",
+		vite: "Use asset imports: `import url from \"./x.png?url\"`, or put static files under `public/`."
+	},
+	{
+		match: "url-loader",
+		label: "url-loader",
+		vite: "Use `?url` / `?inline` import suffixes; small assets are inlined automatically."
+	},
+	{
+		match: "raw-loader",
+		label: "raw-loader",
+		vite: "Use the `?raw` import suffix: `import src from \"./x.txt?raw\"`."
+	},
+	{
+		match: "svg",
+		label: "svg loader",
+		vite: "Use `?url`/`?raw`, or add `vite-plugin-svgr` for React components."
+	}
+];
+/** Best-effort mapping of a single loader name to its Vite guidance. */
+function mapLoader(loader) {
+	for (const entry of LOADER_MAP) if (loader.includes(entry.match)) return {
+		label: entry.label,
+		vite: entry.vite
+	};
+	return {
+		label: loader,
+		vite: "No direct Vite equivalent detected. Check if a Vite plugin exists, or handle in a custom plugin."
+	};
+}
+/** Render the loader-mapping rows for the config's `module.rules`. */
+function renderLoaderTable(rules) {
+	const seen = /* @__PURE__ */ new Set();
+	const rows = [];
+	for (const rule of rules) for (const loader of rule.loaders) {
+		const { label, vite } = mapLoader(loader);
+		const test = rule.test ? ` (\`${rule.test}\`)` : "";
+		const key = `${label}${test}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		rows.push(`| \`${label}\`${test} | ${vite} |`);
+	}
+	if (rows.length === 0) rows.push("| _(no loaders detected)_ | — |");
+	return [
+		"| Webpack loader | Vite equivalent |",
+		"| --- | --- |",
+		...rows
+	].join("\n");
+}
+/** Render the full agent-ready `WEBPACK_MIGRATION.md`. */
+function renderMigrationGuide(config, viteConfigName) {
+	const lines = [];
+	lines.push("# Finish the Webpack → Vite migration");
+	lines.push("");
+	lines.push(`omnimod scaffolded a \`${viteConfigName}\` next to your \`webpack.config\`. The original webpack config was **left untouched**. Follow the steps below to complete the migration, then delete the webpack config and its loaders/plugins.`);
+	lines.push("");
+	lines.push("## One-time setup");
+	lines.push("");
+	lines.push("1. Install Vite and your framework plugin as dev dependencies:");
+	lines.push("");
+	lines.push("   ```sh");
+	lines.push("   npm install -D vite");
+	lines.push("   # then the plugin for your framework, e.g.:");
+	lines.push("   #   React:  npm install -D @vitejs/plugin-react");
+	lines.push("   #   Vue:    npm install -D @vitejs/plugin-vue");
+	lines.push("   #   Svelte: npm install -D @sveltejs/vite-plugin-svelte");
+	lines.push("   ```");
+	lines.push("");
+	lines.push(`2. Register the plugin in \`${viteConfigName}\` (uncomment/adjust the \`plugins\` TODO).`);
+	lines.push("");
+	lines.push("## Entry point");
+	lines.push("");
+	lines.push("Vite is served from an `index.html` at the project root (not a JS `entry`). Create `index.html` and reference your entry module directly:");
+	lines.push("");
+	lines.push("```html");
+	lines.push("<!doctype html>");
+	lines.push("<html>");
+	lines.push("  <head>");
+	lines.push("    <meta charset=\"utf-8\" />");
+	lines.push("    <title>App</title>");
+	lines.push("  </head>");
+	lines.push("  <body>");
+	lines.push("    <div id=\"root\"></div>");
+	lines.push("    <script type=\"module\" src=\"/src/index.js\"><\/script>");
+	lines.push("  </body>");
+	lines.push("</html>");
+	lines.push("```");
+	if (config.entry) {
+		lines.push("");
+		lines.push(`> Detected webpack \`entry\`: \`${config.entry.replace(/\s+/g, " ")}\``);
+	}
+	lines.push("");
+	lines.push("## Environment variables");
+	lines.push("");
+	lines.push("Vite only exposes env vars prefixed with `VITE_`, accessed via `import.meta.env.VITE_*` (not `process.env.*`).");
+	lines.push("");
+	lines.push("- Rename `MY_VAR` → `VITE_MY_VAR` in your `.env` files.");
+	lines.push("- Replace `process.env.MY_VAR` → `import.meta.env.VITE_MY_VAR` in source.");
+	if (config.define.length > 0) lines.push(`- The following \`DefinePlugin\` keys were mapped into \`define\` in the generated config: ${config.define.map((entry) => `\`${entry.key}\``).join(", ")}.`);
+	lines.push("");
+	lines.push("## Loaders → Vite");
+	lines.push("");
+	lines.push(renderLoaderTable(config.rules));
+	lines.push("");
+	lines.push("## npm scripts");
+	lines.push("");
+	lines.push("Replace your webpack scripts with Vite's:");
+	lines.push("");
+	lines.push("```jsonc");
+	lines.push("{");
+	lines.push("  \"scripts\": {");
+	lines.push("    \"dev\": \"vite\",           // was: \"webpack serve\"");
+	lines.push("    \"build\": \"vite build\",   // was: \"webpack\" / \"webpack --mode production\"");
+	lines.push("    \"preview\": \"vite preview\"");
+	lines.push("  }");
+	lines.push("}");
+	lines.push("```");
+	lines.push("");
+	lines.push("## Verify");
+	lines.push("");
+	lines.push("- [ ] `npm run dev` boots and the app loads.");
+	lines.push("- [ ] `npm run build` produces a working `dist/`.");
+	lines.push("- [ ] All aliases and env vars resolve.");
+	lines.push("- [ ] The old `webpack.config` and webpack deps are removed.");
+	lines.push("");
+	return `${lines.join("\n")}`;
+}
+//#endregion
+//#region src/plugin.ts
+/** Directory portion of an absolute POSIX/Windows path (no node:path dep needed). */
+function dirOf(path) {
+	const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	return slash === -1 ? "" : path.slice(0, slash);
+}
+/** Join a directory and a file name with the directory's separator. */
+function join(dir, name) {
+	if (dir === "") return name;
+	return `${dir}${dir.includes("\\") && !dir.includes("/") ? "\\" : "/"}${name}`;
+}
+/**
+* Scaffold a Vite config from a Webpack config. Webpack configs are arbitrary
+* JS, so this never transforms the original file. Instead it reads what it can
+* *statically* (resolve.alias/extensions, DefinePlugin, devServer.port/proxy,
+* entry/output, module.rules) and emits a sibling `vite.config.js` skeleton plus
+* a `WEBPACK_MIGRATION.md` agent guide, then reports where to look next.
+*/
+const webpackToVite = definePlugin({
+	name: "webpack-to-vite",
+	description: "Scaffold a Vite config from a Webpack config.",
+	include: ["**/webpack.config.{js,ts,cjs,mjs}"],
+	transform(file) {
+		const config = extractConfig(file.program, file.source);
+		const dir = dirOf(file.path);
+		const viteConfigName = "vite.config.js";
+		const viteConfigPath = join(dir, viteConfigName);
+		const migrationPath = join(dir, "WEBPACK_MIGRATION.md");
+		if (!config.found) file.report({
+			severity: "warn",
+			message: "Could not statically read a `module.exports = {…}` / `export default {…}` object (function- or array-returning config?). Emitted a starter vite.config.js and WEBPACK_MIGRATION.md; you'll need to port the fields by hand."
+		});
+		if (config.aliasesHaveHelpers) file.report({
+			severity: "warn",
+			message: "Some `resolve.alias` values use webpack-only helpers (e.g. path.resolve). They were copied verbatim into vite.config.js with a // TODO — Vite resolves relative to the config file, so review them."
+		});
+		file.emit({
+			path: viteConfigPath,
+			contents: renderViteConfig(config)
+		});
+		file.emit({
+			path: migrationPath,
+			contents: renderMigrationGuide(config, viteConfigName)
+		});
+		file.report({
+			severity: "info",
+			message: `Emitted ${viteConfigName} and WEBPACK_MIGRATION.md next to this webpack config. The webpack config was left untouched.`
+		});
+	}
+});
+//#endregion
+export { webpackToVite as default, webpackToVite };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@omnimod/plugin-webpack-to-vite",
+  "version": "0.1.0",
+  "description": "omnimod plugin: scaffold a Vite config from a Webpack config.",
+  "keywords": [
+    "codemod",
+    "migration",
+    "omnimod-plugin",
+    "vite",
+    "webpack"
+  ],
+  "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/plugin-webpack-to-vite"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@omnimod/core": "0.1.0",
+    "@omnimod/plugin-utils": "0.1.0"
+  },
+  "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"
+  }
+}