perf(webpack-cli): stop retaining serve option arrays for the whole session

The serve command stashed the full webpack and dev-server option arrays
(~900KB) in its command context, which lives for the entire dev-server
session even though the arrays are only needed during setup. Build the
arrays transiently in the `options` callback for registration, and derive
the action's lightweight lookups (built-in option name set, dev-server arg
metadata) from the cached `getArguments` map instead. The large arrays are
now reclaimable after startup.

https://claude.ai/code/session_01PEtzv6Xqv2yXQaQsZaeoSF

Author: claude

.changeset/fast-pumas-cache.md

@@ -2,4 +2,4 @@
 "webpack-cli": patch
 ---
 
-Cache CLI argument metadata built from the webpack/dev-server schema and apply CLI options using the cached name-keyed map directly, avoiding a redundant schema walk and the rebuild of a large options array and lookup map on every run. Default-config discovery now reads each candidate directory once instead of probing every `<name><ext>` combination with a separate `fs.access` call (up to ~100 sequential syscalls when no config file exists). Colors are also created lazily, so commands that don't need webpack (such as `version` and `info`) no longer load it. The cached argument metadata (~1MB per schema) is held via `WeakRef` so the garbage collector can reclaim it once command setup is done, which matters for long-running `serve`/`watch`. This reduces per-invocation CPU work, syscalls, and memory usage.
+Cache CLI argument metadata built from the webpack/dev-server schema and apply CLI options using the cached name-keyed map directly, avoiding a redundant schema walk and the rebuild of a large options array and lookup map on every run. Default-config discovery now reads each candidate directory once instead of probing every `<name><ext>` combination with a separate `fs.access` call (up to ~100 sequential syscalls when no config file exists). Colors are also created lazily, so commands that don't need webpack (such as `version` and `info`) no longer load it. The cached argument metadata (~1MB per schema) is held via `WeakRef` so the garbage collector can reclaim it once command setup is done, which matters for long-running `serve`/`watch`. The `serve` command no longer retains the full option arrays (~900KB) in its context for the whole session, deriving the lookups it needs from the cached argument metadata instead. This reduces per-invocation CPU work, syscalls, and memory usage.

packages/webpack-cli/src/webpack-cli.ts

@@ -114,28 +114,16 @@ interface WebpackContext {
   webpack: typeof webpack;
 }
 
-interface WebpackOptionsContext {
-  webpackOptions: CommandOption[];
-}
-
 interface WebpackDevServerContext {
   devServer: typeof import("webpack-dev-server");
 }
 
-interface WebpackDevServerOptionsContext {
-  devServerOptions: CommandOption[];
-}
-
 interface KnownWebpackCLICommands {
   build: CommandOptions<string[], CommanderArgs, WebpackContext & Context>;
   serve: CommandOptions<
     string[],
     CommanderArgs,
-    WebpackContext &
-      WebpackOptionsContext &
-      WebpackDevServerContext &
-      WebpackDevServerOptionsContext &
-      Context
+    WebpackContext & WebpackDevServerContext & Context
   >;
   watch: CommandOptions<string[], CommanderArgs, WebpackContext & Context>;
   version: CommandOptions<void, CommanderArgs, Context>;
@@ -1651,26 +1639,31 @@ class WebpackCLI {
       dependencies: [WEBPACK_PACKAGE, WEBPACK_DEV_SERVER_PACKAGE],
       preload: async () => {
         const webpack = await this.loadWebpack();
-        const webpackOptions = this.schemaToOptions(webpack, undefined, this.#CLIOptions);
         const devServer = await this.loadWebpackDevServer();
+
+        return { webpack, devServer };
+      },
+      options: (cmd) => {
+        const { webpack, devServer } = cmd.context;
+        const webpackOptions = this.schemaToOptions(webpack, undefined, this.#CLIOptions);
         // @ts-expect-error different versions of the `Schema` type
         const devServerOptions = this.schemaToOptions(webpack, devServer.schema, undefined, {
           hidden: false,
           negativeHidden: false,
         });
 
-        return { webpack, webpackOptions, devServer, devServerOptions };
-      },
-      options: (cmd) => {
-        const { webpackOptions, devServerOptions } = cmd.context;
-
         return [...webpackOptions, ...devServerOptions];
       },
       action: async (entries: string[], options: CommanderArgs, cmd) => {
-        const { webpack, webpackOptions, devServerOptions } = cmd.context;
+        const { webpack, devServer } = cmd.context;
         const webpackCLIOptions: Options = { webpack, isWatchingLikeCommand: true };
         const devServerCLIOptions: CommanderArgs = {};
-        const webpackOptionNames = new Set(webpackOptions.map((option) => option.name));
+        // Derive the built-in option names from the cached argument metadata
+        // instead of retaining the full option arrays for the whole session.
+        const webpackOptionNames = new Set([
+          ...this.#CLIOptions.map((option) => option.name),
+          ...Object.keys(this.#getArguments(webpack, undefined)),
+        ]);
 
         for (const optionName in options) {
           const kebabedOption = this.toKebabCase(optionName);
@@ -1717,9 +1710,8 @@ class WebpackCLI {
         const compilersForDevServer =
           possibleCompilers.length > 0 ? possibleCompilers : [compilers[0]];
         const usedPorts: number[] = [];
-        const devServerOptionsByName = new Map(
-          devServerOptions.map((option) => [option.name, option]),
-        );
+        // @ts-expect-error different versions of the `Schema` type
+        const devServerArgs = this.#getArguments(webpack, devServer.schema);
 
         for (const compilerForDevServer of compilersForDevServer) {
           if (compilerForDevServer.options.devServer === false) {
@@ -1736,10 +1728,10 @@ class WebpackCLI {
             if (name === "argv") continue;
 
             const kebabName = this.toKebabCase(name);
-            const arg = devServerOptionsByName.get(kebabName);
+            const arg = devServerArgs[kebabName];
 
             if (arg) {
-              args[name] = arg as unknown as WebpackArgument;
+              args[name] = arg;
               // We really don't know what the value is
               // eslint-disable-next-line @typescript-eslint/no-explicit-any
               values[name] = options[name as keyof Options] as any;