@evjs/cli 0.0.5 → 0.0.7

package/README.md

@@ -1,6 +1,6 @@
 # @evjs/cli
 
-> CLI and configuration for the **@evjs/cli** meta-framework.
+> CLI and configuration for the **@evjs/cli** fullstack framework.
 
 ## Install
 
@@ -47,21 +47,17 @@ Create `ev.config.ts` in the project root (optional):
 import { defineConfig } from "@evjs/cli";
 
 export default defineConfig({
-  client: {
-    entry: "./src/main.tsx",
-    html: "./index.html",
-    plugins: [{ name: "tailwind", module: { rules: [{ test: /\.css$/, use: ["style-loader", "css-loader", "postcss-loader"] }] } }],
-    dev: { port: 3000 },
-  },
+  entry: "./src/main.tsx",
+  html: "./index.html",
+  dev: { port: 3000 },
   server: {
     endpoint: "/api/fn",
-
     dev: { port: 3001 },
   },
 });
 ```
 
-The `client.dev` and `server.dev` fields accept extra options that are merged with defaults.
+The `dev` and `server.dev` fields accept extra options that are merged with defaults.
 
 ## Project Structure
 
@@ -93,4 +89,4 @@ my-app/
 Users do NOT need to install these — they're included in `@evjs/cli`:
 - `webpack`, `webpack-dev-server`
 - `html-webpack-plugin`, `swc-loader`, `@swc/core`
-- `@evjs/webpack-plugin`, `@evjs/build-tools`
+- `@evjs/bundler-webpack`, `@evjs/build-tools`

package/bin/ev.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/cli.js";

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { configure, getConsoleSink } from "@logtape/logtape";
 import { Command } from "commander";
-import fs from "fs-extra";
 import { build, dev } from "./index.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 await configure({
@@ -13,7 +13,7 @@ await configure({
         { category: ["evjs"], sinks: ["console"], lowestLevel: "info" },
     ],
 });
-const pkg = fs.readJsonSync(path.resolve(__dirname, "../package.json"));
+const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../package.json"), "utf-8"));
 const program = new Command();
 program
     .name("ev")
@@ -25,7 +25,7 @@ program
     .action(async () => {
     const cwd = process.cwd();
     const { loadConfig } = await import("./load-config.js");
-    const config = await loadConfig(cwd);
+    const config = await loadConfig(cwd, { mode: "development" });
     try {
         await dev(config ?? undefined, { cwd });
     }
@@ -40,7 +40,7 @@ program
     .action(async () => {
     const cwd = process.cwd();
     const { loadConfig } = await import("./load-config.js");
-    const config = await loadConfig(cwd);
+    const config = await loadConfig(cwd, { mode: "production" });
     try {
         await build(config ?? undefined, { cwd });
     }

package/dist/config.d.ts

@@ -1,119 +1,2 @@
-/**
- * Server configuration.
- *
- * Controls server backend, entry, plugins, and dev options.
- */
-export interface ServerConfig {
-    /** Explicit server entry file. If provided, overrides auto-generated entry. */
-    entry?: string;
-    /** Server backend command. Default: "node". */
-    backend?: string;
-    /** Server function configuration. */
-    functions?: {
-        /** Server function endpoint path. Default: "/api/fn". */
-        endpoint?: string;
-    };
-    /** Build plugins for the server bundle. */
-    plugins?: EvPlugin[];
-    /** Dev server options. */
-    dev?: {
-        /** API server port (dev mode). Default: 3001. */
-        port?: number;
-        /** Enable HTTPS. */
-        https?: boolean;
-    };
-}
-/**
- * Client configuration.
- *
- * Controls entry point, HTML template, dev server, and transport.
- */
-export interface ClientConfig {
-    /** Client entry point. Default: "./src/main.tsx". */
-    entry?: string;
-    /** HTML template path. Default: "./index.html". */
-    html?: string;
-    /** Build plugins for the client bundle. */
-    plugins?: EvPlugin[];
-    /** Dev server options. */
-    dev?: {
-        /** Dev server port. Default: 3000. */
-        port?: number;
-        /** Enable HTTPS. */
-        https?: boolean;
-    };
-}
-/**
- * A single loader entry.
- *
- * Can be a plain package name or an object with per-loader options.
- *
- * @example
- * ```ts
- * "css-loader"
- * { loader: "css-loader", options: { modules: true } }
- * ```
- */
-export type EvLoaderEntry = string | {
-    loader: string;
-    options?: Record<string, unknown>;
-};
-/** A module rule declared by a plugin. */
-export interface EvModuleRule {
-    /** File matching pattern (e.g. /\.css$/, /\.svg$/). */
-    test: RegExp;
-    /** Pattern to exclude (e.g. /node_modules/). */
-    exclude?: RegExp;
-    /** Loader(s) to apply. */
-    use: EvLoaderEntry | EvLoaderEntry[];
-}
-/** An evjs build plugin. */
-export interface EvPlugin {
-    /** Plugin name for debugging and logging. */
-    name: string;
-    /** Plugin's module configuration. */
-    module?: {
-        /** Module rules to add to the build pipeline. */
-        rules?: EvModuleRule[];
-    };
-}
-/**
- * evjs framework configuration.
- */
-export interface EvConfig {
-    server?: ServerConfig;
-    client?: ClientConfig;
-}
-/**
- * Default configuration values.
- *
- * Single source of truth for all defaults across the framework.
- */
-export declare const CONFIG_DEFAULTS: {
-    readonly entry: "./src/main.tsx";
-    readonly html: "./index.html";
-    readonly clientPort: 3000;
-    readonly serverPort: 3001;
-    readonly endpoint: "/api/fn";
-};
-/**
- * Define configuration for the evjs framework.
- *
- * @example
- * ```ts
- * // ev.config.ts
- * import { defineConfig } from "@evjs/cli";
- *
- * export default defineConfig({
- *   client: {
- *     entry: "./src/main.tsx",
- *     dev: { port: 3000 },
- *   },
- *   server: {
- *     functions: { endpoint: "/api/fn" },
- *     dev: { port: 3001 },
- *   },
- * });
- * ```
- */
-export declare function defineConfig(config: EvConfig): EvConfig;
+import { CONFIG_DEFAULTS, defineConfig, type EvBundlerCtx, type EvConfig, type EvConfigCtx, type EvPlugin, type ResolvedEvConfig, resolveConfig } from "@evjs/shared";
+export { type EvConfig, type EvConfigCtx, type EvBundlerCtx, type ResolvedEvConfig, type EvPlugin, CONFIG_DEFAULTS, defineConfig, resolveConfig, };

package/dist/config.js

@@ -1,35 +1,2 @@
-/**
- * Default configuration values.
- *
- * Single source of truth for all defaults across the framework.
- */
-export const CONFIG_DEFAULTS = {
-    entry: "./src/main.tsx",
-    html: "./index.html",
-    clientPort: 3000,
-    serverPort: 3001,
-    endpoint: "/api/fn",
-};
-/**
- * Define configuration for the evjs framework.
- *
- * @example
- * ```ts
- * // ev.config.ts
- * import { defineConfig } from "@evjs/cli";
- *
- * export default defineConfig({
- *   client: {
- *     entry: "./src/main.tsx",
- *     dev: { port: 3000 },
- *   },
- *   server: {
- *     functions: { endpoint: "/api/fn" },
- *     dev: { port: 3001 },
- *   },
- * });
- * ```
- */
-export function defineConfig(config) {
-    return config;
-}
+import { CONFIG_DEFAULTS, defineConfig, resolveConfig, } from "@evjs/shared";
+export { CONFIG_DEFAULTS, defineConfig, resolveConfig, };

package/dist/index.d.ts

@@ -1,23 +1,22 @@
-import type { EvConfig } from "./config.js";
-export type { ClientConfig, EvConfig, EvLoaderEntry, EvModuleRule, EvPlugin, ServerConfig, } from "./config.js";
-export { CONFIG_DEFAULTS, defineConfig } from "./config.js";
+import { CONFIG_DEFAULTS, defineConfig, type EvBundlerCtx, type EvConfig, type EvConfigCtx, type EvPlugin, type ResolvedEvConfig, resolveConfig } from "@evjs/shared";
+export { CONFIG_DEFAULTS, type EvConfig, type EvBundlerCtx, type EvConfigCtx, type EvPlugin, type ResolvedEvConfig, resolveConfig, defineConfig, };
 export interface DevOptions {
     cwd?: string;
 }
+export interface BuildOptions {
+    cwd?: string;
+}
 /**
  * Start the development server programmatically.
  *
  * @param config - evjs configuration object (from `defineConfig`)
  * @param options - additional options like `cwd`
  */
-export declare function dev(config?: EvConfig, options?: DevOptions): Promise<void>;
-export interface BuildOptions {
-    cwd?: string;
-}
+export declare function dev(userConfig?: EvConfig, options?: DevOptions): Promise<void>;
 /**
  * Run a production build programmatically.
  *
  * @param config - evjs configuration object (from `defineConfig`)
  * @param options - additional options like `cwd`
  */
-export declare function build(config?: EvConfig, options?: BuildOptions): Promise<void>;
+export declare function build(userConfig?: EvConfig, options?: BuildOptions): Promise<void>;

package/dist/index.js

@@ -1,18 +1,20 @@
-import { createRequire } from "node:module";
+import fs from "node:fs";
 import path from "node:path";
+import { webpackAdapter } from "@evjs/bundler-webpack";
+import { CONFIG_DEFAULTS, defineConfig, resolveConfig, } from "@evjs/shared";
 import { getLogger } from "@logtape/logtape";
 import { execa } from "execa";
-import fs from "fs-extra";
-import { CONFIG_DEFAULTS } from "./config.js";
-export { CONFIG_DEFAULTS, defineConfig } from "./config.js";
-const esmRequire = createRequire(import.meta.url);
+export { CONFIG_DEFAULTS, resolveConfig, defineConfig, };
 const logger = getLogger(["evjs", "cli"]);
 /**
- * Create webpack configuration from an EvConfig object.
+ * Resolve the bundler adapter specified in the configuration.
  */
-async function resolveWebpackConfig(config, cwd) {
-    const { createWebpackConfig } = await import("./create-webpack-config.js");
-    return createWebpackConfig(config, cwd);
+async function getBundlerAdapter(config) {
+    const bundlerName = config?.bundler?.name ?? "webpack";
+    if (bundlerName === "webpack") {
+        return webpackAdapter;
+    }
+    throw new Error(`Bundler '${bundlerName}' is not supported yet.`);
 }
 /**
  * Start the development server programmatically.
@@ -20,65 +22,63 @@ async function resolveWebpackConfig(config, cwd) {
  * @param config - evjs configuration object (from `defineConfig`)
  * @param options - additional options like `cwd`
  */
-export async function dev(config, options) {
+export async function dev(userConfig, options) {
+    const config = resolveConfig(userConfig);
     const cwd = options?.cwd ?? process.cwd();
     process.env.NODE_ENV ??= "development";
-    const webpackConfig = await resolveWebpackConfig(config, cwd);
-    const serverPort = config?.server?.dev?.port ?? CONFIG_DEFAULTS.serverPort;
-    logger.info `Starting development server...`;
-    const webpack = esmRequire("webpack");
-    const WebpackDevServer = esmRequire("webpack-dev-server");
-    const compiler = webpack(webpackConfig);
-    const devServerOptions = webpackConfig.devServer ?? {};
-    const server = new WebpackDevServer(devServerOptions, compiler);
-    await server.start();
+    const bundler = await getBundlerAdapter(config);
     // Background: start Node API when server bundle is ready
     let apiStarted = false;
-    compiler.hooks.done.tap("EvDevServer", async () => {
+    const handleServerBundleReady = () => {
         if (apiStarted)
             return;
         const manifestPath = path.resolve(cwd, "dist/manifest.json");
+        if (!fs.existsSync(manifestPath))
+            return;
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        if (!manifest.server?.entry)
+            return;
+        apiStarted = true;
+        const serverPort = config?.server?.dev?.port ?? CONFIG_DEFAULTS.serverPort;
+        const backendConfig = config?.server?.backend ?? "node";
+        const [backend, ...backendExtraArgs] = backendConfig.split(/\s+/);
+        logger.info `Server bundle detected, starting ${backend} API...`;
         const bootstrapPath = path.resolve(cwd, "dist/server/_dev_start.cjs");
-        if (fs.existsSync(manifestPath)) {
-            const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-            // Start API server if there's a server entry
-            if (!manifest.server?.entry)
-                return;
-            apiStarted = true;
-            const backendConfig = config?.server?.backend ?? "node";
-            const [backend, ...backendExtraArgs] = backendConfig.split(/\s+/);
-            logger.info `Server bundle detected, starting ${backend} API...`;
-            try {
-                const serverBundlePath = path.resolve(cwd, "dist/server", manifest.server.entry);
-                fs.ensureDirSync(path.dirname(bootstrapPath));
-                fs.writeFileSync(bootstrapPath, [
-                    `const bundle = require(${JSON.stringify(serverBundlePath)});`,
-                    `const app = bundle.app || bundle.createApp({ endpoint: ${JSON.stringify(config?.server?.functions?.endpoint ?? CONFIG_DEFAULTS.endpoint)} });`,
-                    `const { serve } = require("@evjs/server/node");`,
-                    `serve(app, { port: ${serverPort}, https: ${Boolean(config?.server?.dev?.https)} });`,
-                ].join("\n"));
-                // node gets --watch flags; other runtimes use their own args as-is
-                const backendArgs = backend === "node"
-                    ? [
-                        "--watch",
-                        "--watch-preserve-output",
-                        ...backendExtraArgs,
-                        bootstrapPath,
-                    ]
-                    : [...backendExtraArgs, bootstrapPath];
-                // Don't await execa here since it's a long-running watch process
-                execa(backend, backendArgs, {
-                    stdio: "inherit",
-                    env: { ...process.env, NODE_ENV: "development" },
-                }).catch(() => {
-                    apiStarted = false;
-                });
+        try {
+            const serverBundlePath = path.resolve(cwd, "dist/server", manifest.server.entry);
+            if (!fs.existsSync(path.dirname(bootstrapPath))) {
+                fs.mkdirSync(path.dirname(bootstrapPath), { recursive: true });
             }
-            catch (err) {
-                logger.error `Server backend failed: ${err}`;
+            fs.writeFileSync(bootstrapPath, [
+                `const bundle = require(${JSON.stringify(serverBundlePath)});`,
+                `const app = bundle.app || bundle.createApp({ endpoint: ${JSON.stringify(config.server.endpoint)} });`,
+                `const { serve } = require("@evjs/server/node");`,
+                `serve(app, { port: ${serverPort}, https: ${Boolean(config.server.dev.https)} });`,
+            ].join("\n"));
+            // node gets --watch flags; other runtimes use their own args as-is
+            const backendArgs = backend === "node"
+                ? [
+                    "--watch",
+                    "--watch-preserve-output",
+                    ...backendExtraArgs,
+                    bootstrapPath,
+                ]
+                : [...backendExtraArgs, bootstrapPath];
+            // Don't await execa here since it's a long-running watch process
+            execa(backend, backendArgs, {
+                stdio: "inherit",
+                env: { ...process.env, NODE_ENV: "development" },
+            }).catch(() => {
                 apiStarted = false;
-            }
+            });
+        }
+        catch (err) {
+            logger.error `Server backend failed: ${err}`;
+            apiStarted = false;
         }
+    };
+    await bundler.dev(config, cwd, {
+        onServerBundleReady: handleServerBundleReady,
     });
 }
 /**
@@ -87,29 +87,10 @@ export async function dev(config, options) {
  * @param config - evjs configuration object (from `defineConfig`)
  * @param options - additional options like `cwd`
  */
-export async function build(config, options) {
+export async function build(userConfig, options) {
+    const config = resolveConfig(userConfig);
     const cwd = options?.cwd ?? process.cwd();
     process.env.NODE_ENV ??= "production";
-    const webpackConfig = await resolveWebpackConfig(config, cwd);
-    logger.info `Building for production...`;
-    const webpack = esmRequire("webpack");
-    const compiler = webpack(webpackConfig);
-    await new Promise((resolve, reject) => {
-        compiler.run((err, stats) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            console.log(stats.toString({
-                colors: true,
-                modules: false,
-                children: true,
-            }));
-            if (stats.hasErrors()) {
-                process.exit(1);
-            }
-            compiler.close(() => resolve());
-        });
-    });
-    logger.info `Build complete!`;
+    const bundler = await getBundlerAdapter(config);
+    await bundler.build(config, cwd);
 }

package/dist/load-config.d.ts

@@ -1,8 +1,11 @@
-import type { EvConfig } from "./config.js";
+import type { EvConfig, EvConfigCtx } from "./config.js";
 /**
  * Load evjs config from the project root.
  *
  * Looks for `ev.config.ts`, `.js`, or `.mjs` in the given directory.
  * Returns undefined if no config file is found.
+ *
+ * After loading, all plugin `config` hooks are executed in order.
+ * If a plugin injects new plugins, their hooks are also executed.
  */
-export declare function loadConfig(cwd: string): Promise<EvConfig | undefined>;
+export declare function loadConfig(cwd: string, ctx?: EvConfigCtx): Promise<EvConfig | undefined>;

package/dist/load-config.js

@@ -2,28 +2,20 @@ import fs from "node:fs";
 import path from "node:path";
 const CONFIG_FILES = ["ev.config.ts", "ev.config.js", "ev.config.mjs"];
 /**
- * Ensure a TypeScript loader is registered before importing `.ts` config files.
- * Tries `@swc-node/register/esm-register` (ships alongside `@swc/core` which
- * the CLI already bundles), then falls back to Node's built-in `--loader tsx`
- * pathway. If neither is available the raw `import()` is attempted anyway —
- * Node will throw a clear error telling the user to install a loader.
+ * Historically used @swc-node/register, but it causes ERR_REQUIRE_CYCLE_MODULE inside Node 22.
+ * Modern evjs relies on Node's native typescript handling or built-in --loader arguments.
  */
-async function ensureTsLoader() {
-    try {
-        // @ts-expect-error — optional dependency, may not be installed
-        await import("@swc-node/register/esm-register");
-    }
-    catch {
-        // Loader not available — Node may still handle .ts via --loader flag
-    }
-}
+async function ensureTsLoader() { }
 /**
  * Load evjs config from the project root.
  *
  * Looks for `ev.config.ts`, `.js`, or `.mjs` in the given directory.
  * Returns undefined if no config file is found.
+ *
+ * After loading, all plugin `config` hooks are executed in order.
+ * If a plugin injects new plugins, their hooks are also executed.
  */
-export async function loadConfig(cwd) {
+export async function loadConfig(cwd, ctx) {
     for (const filename of CONFIG_FILES) {
         const configPath = path.resolve(cwd, filename);
         if (fs.existsSync(configPath)) {
@@ -32,7 +24,24 @@ export async function loadConfig(cwd) {
                 await ensureTsLoader();
             }
             const mod = await import(configPath);
-            return mod.default ?? mod;
+            let config = mod.default ?? mod;
+            // Execute plugin config hooks
+            const currentCtx = ctx ?? { mode: "development" };
+            const executedConfigHooks = new Set();
+            let hasNewPlugins = true;
+            while (hasNewPlugins) {
+                hasNewPlugins = false;
+                const allPlugins = config.plugins ?? [];
+                for (const plugin of allPlugins) {
+                    if (plugin.config && !executedConfigHooks.has(plugin.name)) {
+                        config = plugin.config(config, currentCtx) ?? config;
+                        executedConfigHooks.add(plugin.name);
+                        hasNewPlugins = true;
+                        break;
+                    }
+                }
+            }
+            return config;
         }
     }
     return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evjs/cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "CLI and configuration layer for the evjs framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,35 +15,28 @@
     "access": "public"
   },
   "bin": {
-    "ev": "dist/cli.js"
+    "ev": "bin/ev.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc -w",
     "test": "vitest run",
-    "check-types": "tsc --noEmit",
-    "prepare": "npm run build"
+    "check-types": "tsc --noEmit"
   },
   "dependencies": {
-    "@evjs/webpack-plugin": "*",
+    "@evjs/bundler-webpack": "*",
+    "@evjs/shared": "*",
     "@logtape/logtape": "^2.0.4",
-    "@swc/core": "^1.15.21",
     "commander": "^12.1.0",
     "execa": "^9.6.1",
-    "fs-extra": "^11.3.4",
     "glob": "^13.0.6",
-    "html-webpack-plugin": "^5.6.6",
-    "picocolors": "^1.1.1",
-    "swc-loader": "^0.2.7",
-    "webpack": "^5.105.4",
-    "webpack-cli": "^6.0.1",
-    "webpack-dev-server": "^5.2.3"
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.19.15",
     "typescript": "^6.0.2"
   },

package/dist/create-webpack-config.d.ts

@@ -1,8 +0,0 @@
-import { type EvConfig } from "./config.js";
-/**
- * Create a webpack configuration object from EvfConfig.
- *
- * Returns a plain object that can be passed directly to the webpack Node API.
- * No temp files are generated.
- */
-export declare function createWebpackConfig(config: EvConfig | undefined, cwd: string): Record<string, unknown>;

package/dist/create-webpack-config.js

@@ -1,116 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import { CONFIG_DEFAULTS } from "./config.js";
-const esmRequire = createRequire(import.meta.url);
-/**
- * Create a webpack configuration object from EvfConfig.
- *
- * Returns a plain object that can be passed directly to the webpack Node API.
- * No temp files are generated.
- */
-export function createWebpackConfig(config, cwd) {
-    const client = config?.client;
-    const server = config?.server;
-    const entry = client?.entry ?? CONFIG_DEFAULTS.entry;
-    const html = client?.html ?? CONFIG_DEFAULTS.html;
-    const clientPort = client?.dev?.port ?? CONFIG_DEFAULTS.clientPort;
-    const serverPort = server?.dev?.port ?? CONFIG_DEFAULTS.serverPort;
-    const endpoint = server?.functions?.endpoint ?? CONFIG_DEFAULTS.endpoint;
-    const isProduction = process.env.NODE_ENV === "production";
-    const HtmlWebpackPlugin = esmRequire("html-webpack-plugin");
-    const { EvWebpackPlugin } = esmRequire("@evjs/webpack-plugin");
-    const pluginOptions = server
-        ? { server: { entry: server.entry } }
-        : undefined;
-    // Resolve loader paths from evjs's dependency tree so they work
-    // even when the user's project doesn't list them as direct deps.
-    const resolveLoader = (id) => {
-        try {
-            return esmRequire.resolve(id);
-        }
-        catch {
-            return id;
-        }
-    };
-    // Derive the proxy base path from the configured endpoint.
-    // e.g. "/api/fn" → "/api", "/rpc/v1" → "/rpc"
-    const proxyBase = `/${endpoint.split("/").filter(Boolean)[0] || "api"}`;
-    // Destructure port out of dev overrides to avoid passing it twice.
-    const { port: _p, ...devServerOverrides } = client?.dev ?? {};
-    return {
-        name: "client",
-        mode: isProduction ? "production" : "development",
-        devtool: isProduction ? "hidden-source-map" : "source-map",
-        entry,
-        output: {
-            path: path.resolve(cwd, "dist/client"),
-            filename: isProduction ? "[name].[contenthash:8].js" : "index.js",
-            clean: true,
-        },
-        resolve: {
-            extensions: [".tsx", ".ts", ".js"],
-        },
-        module: {
-            rules: [
-                {
-                    test: /\.m?js/,
-                    resolve: { fullySpecified: false },
-                },
-                {
-                    test: /\.tsx?$/,
-                    exclude: /node_modules/,
-                    use: [
-                        {
-                            loader: resolveLoader("swc-loader"),
-                            options: {
-                                jsc: {
-                                    parser: { syntax: "typescript", tsx: true },
-                                    transform: { react: { runtime: "automatic" } },
-                                },
-                            },
-                        },
-                        {
-                            loader: resolveLoader("@evjs/webpack-plugin/server-fn-loader"),
-                        },
-                    ],
-                },
-                // Plugin-declared module rules (client + server)
-                ...[...(client?.plugins ?? []), ...(server?.plugins ?? [])].flatMap((plugin) => (plugin.module?.rules ?? []).map((rule) => {
-                    const entries = Array.isArray(rule.use) ? rule.use : [rule.use];
-                    return {
-                        test: rule.test,
-                        ...(rule.exclude ? { exclude: rule.exclude } : {}),
-                        use: entries.map((entry) => typeof entry === "string"
-                            ? { loader: resolveLoader(entry) }
-                            : {
-                                loader: resolveLoader(entry.loader),
-                                ...(entry.options ? { options: entry.options } : {}),
-                            }),
-                    };
-                })),
-            ],
-        },
-        plugins: [
-            new HtmlWebpackPlugin({ template: html }),
-            new EvWebpackPlugin(pluginOptions),
-            ...(!isProduction
-                ? [new (esmRequire("webpack").HotModuleReplacementPlugin)()]
-                : []),
-        ],
-        optimization: isProduction
-            ? { splitChunks: { chunks: "all" } }
-            : undefined,
-        devServer: {
-            port: clientPort,
-            hot: true,
-            devMiddleware: { writeToDisk: true },
-            proxy: [
-                {
-                    context: [proxyBase],
-                    target: `http://localhost:${serverPort}`,
-                },
-            ],
-            ...devServerOverrides,
-        },
-    };
-}