svelteesp32 1.16.0 → 2.0.0

package/README.md

@@ -6,6 +6,10 @@
 
 [Changelog](CHANGELOG.md)
 
+<p align="center">
+  <img src="svelteesp32.png" alt="svelteesp32" />
+</p>
+
 ---
 
 ## Why SvelteESP32?
@@ -21,7 +25,7 @@
 - **Smart Caching** — Built-in SHA256 ETags deliver HTTP 304 responses, slashing bandwidth on constrained devices.
 - **CI/CD Ready** — Simple npm package that slots into any build pipeline.
 - **Zero Runtime Overhead** — Data served directly from flash. No filesystem reads, no RAM allocation.
-- **4 Web Server Engines** — PsychicHttp V1/V2, ESPAsyncWebServer, and native ESP-IDF supported.
+- **3 Web Server Engines** — PsychicHttpServer, ESPAsyncWebServer, and native ESP-IDF supported.
 
 ---
 
@@ -75,12 +79,13 @@ void setup() {
 
 ## What's New
 
+- **v2.0.0** — **BREAKING**: PsychicHttpServer V2 is now the default `psychic` engine. The `psychic2` engine has been removed. Dry run mode, C++ identifier validation, improved MIME type warnings
+- **v1.16.0** — Size budget constraints (`--maxsize`, `--maxgzipsize`)
 - **v1.15.0** — `--basepath` for multiple frontends (e.g., `/admin`, `/app`)
 - **v1.13.0** — npm package variable interpolation in RC files
 - **v1.12.0** — RC file configuration support
 - **v1.11.0** — File exclusion patterns
 - **v1.9.0** — Native ESP-IDF engine
-- **v1.5.0** — PsychicHttp V2 support
 
 ---
 
@@ -107,9 +112,6 @@ Choose your web server engine:
 # PsychicHttpServer (recommended for ESP32)
 npx svelteesp32 -e psychic -s ./dist -o ./esp32/svelteesp32.h --etag=true
 
-# PsychicHttpServer V2
-npx svelteesp32 -e psychic2 -s ./dist -o ./esp32/svelteesp32.h --etag=true
-
 # ESPAsyncWebServer (ESP32 + ESP8266)
 npx svelteesp32 -e async -s ./dist -o ./esp32/svelteesp32.h --etag=true
 
@@ -140,7 +142,7 @@ Watch your files get optimized in real-time:
 
 ### ESP32 Integration
 
-**PsychicHttpServer (Recommended)**
+**PsychicHttpServer V2 (Recommended)**
 
 ```c
 #include <PsychicHttp.h>
@@ -183,14 +185,14 @@ void app_main() {
 }
 ```
 
-Working examples: [Arduino/PlatformIO](demo/esp32) | [ESP-IDF](demo/esp32idf)
+Working examples with LED control via web interface: [Arduino/PlatformIO](demo/esp32) | [ESP-IDF](demo/esp32idf)
 
 ### What Gets Generated
 
 The generated header file includes everything your ESP needs:
 
 ```c
-//engine:   PsychicHttpServer
+//engine:   PsychicHttpServer V2
 //config:   engine=psychic sourcepath=./dist outputfile=./output.h etag=true gzip=true cachetime=0 espmethod=initSvelteStaticFiles define=SVELTEESP32
 //
 #define SVELTEESP32_COUNT 5
@@ -231,23 +233,21 @@ const size_t SVELTEESP32_FILE_COUNT = sizeof(SVELTEESP32_FILES) / sizeof(SVELTEE
 extern "C" void __attribute__((weak)) SVELTEESP32_onFileServed(const char* path, int statusCode) {}
 
 void initSvelteStaticFiles(PsychicHttpServer * server) {
-  server->on("/assets/index-KwubEIf-.js", HTTP_GET, [](PsychicRequest * request) {
+  server->on("/assets/index-KwubEIf-.js", HTTP_GET, [](PsychicRequest * request, PsychicResponse * response) {
     if (request->hasHeader("If-None-Match") &&
         request->header("If-None-Match").equals(etag_assets_index_KwubEIf__js)) {
-      PsychicResponse response304(request);
-      response304.setCode(304);
+      response->setCode(304);
       SVELTEESP32_onFileServed("/assets/index-KwubEIf-.js", 304);
-      return response304.send();
+      return response->send();
     }
 
-    PsychicResponse response(request);
-    response.setContentType("text/javascript");
-    response.addHeader("Content-Encoding", "gzip");
-    response.addHeader("Cache-Control", "no-cache");
-    response.addHeader("ETag", etag_assets_index_KwubEIf__js);
-    response.setContent(datagzip_assets_index_KwubEIf__js, 12547);
+    response->setContentType("text/javascript");
+    response->addHeader("Content-Encoding", "gzip");
+    response->addHeader("Cache-Control", "no-cache");
+    response->addHeader("ETag", etag_assets_index_KwubEIf__js);
+    response->setContent(datagzip_assets_index_KwubEIf__js, 12547);
     SVELTEESP32_onFileServed("/assets/index-KwubEIf-.js", 200);
-    return response.send();
+    return response->send();
   });
 
   // ... more routes
@@ -258,14 +258,13 @@ void initSvelteStaticFiles(PsychicHttpServer * server) {
 
 ## Supported Web Server Engines
 
-| Engine                | Flag          | Best For                     | Platform        |
-| --------------------- | ------------- | ---------------------------- | --------------- |
-| **PsychicHttp V1**    | `-e psychic`  | Maximum performance          | ESP32 only      |
-| **PsychicHttp V2**    | `-e psychic2` | Modern API + performance     | ESP32 only      |
-| **ESPAsyncWebServer** | `-e async`    | Cross-platform compatibility | ESP32 + ESP8266 |
-| **Native ESP-IDF**    | `-e espidf`   | Pure ESP-IDF projects        | ESP32 only      |
+| Engine                   | Flag         | Best For                     | Platform        |
+| ------------------------ | ------------ | ---------------------------- | --------------- |
+| **PsychicHttpServer V2** | `-e psychic` | Maximum performance          | ESP32 only      |
+| **ESPAsyncWebServer**    | `-e async`   | Cross-platform compatibility | ESP32 + ESP8266 |
+| **Native ESP-IDF**       | `-e espidf`  | Pure ESP-IDF projects        | ESP32 only      |
 
-**Recommendation:** For ESP32-only projects, use PsychicHttpServer for the fastest, most stable experience.
+**Recommendation:** For ESP32-only projects, use PsychicHttpServer V2 (`-e psychic`) for the fastest, most stable experience.
 
 **Note:** For PsychicHttp, configure `server.config.max_uri_handlers` to match your file count.
 
@@ -288,7 +287,7 @@ Reduce bandwidth dramatically with HTTP 304 "Not Modified" responses. When a bro
 - **Minimal overhead** — adds ~1-3% code size for significant bandwidth savings
 - **Compiler mode** — use `--etag=compiler` and control via `-D SVELTEESP32_ENABLE_ETAG`
 
-All four engines support full ETag validation.
+All three engines support full ETag validation.
 
 ### Browser Cache Control
 
@@ -402,22 +401,25 @@ Called for every response (200 = content served, 304 = cache hit).
 
 ## CLI Reference
 
-| Option           | Description                                       | Default                 |
-| ---------------- | ------------------------------------------------- | ----------------------- |
-| `-s`             | Source folder with compiled web files             | (required)              |
-| `-e`             | Web server engine (psychic/psychic2/async/espidf) | `psychic`               |
-| `-o`             | Output header file path                           | `svelteesp32.h`         |
-| `--etag`         | ETag caching (true/false/compiler)                | `false`                 |
-| `--gzip`         | Gzip compression (true/false/compiler)            | `true`                  |
-| `--exclude`      | Exclude files by glob pattern                     | System files            |
-| `--basepath`     | URL prefix for all routes                         | (none)                  |
-| `--cachetime`    | Cache-Control max-age in seconds                  | `0`                     |
-| `--version`      | Version string in header                          | (none)                  |
-| `--define`       | C++ define prefix                                 | `SVELTEESP32`           |
-| `--espmethod`    | Init function name                                | `initSvelteStaticFiles` |
-| `--config`       | Custom RC file path                               | `.svelteesp32rc.json`   |
-| `--noindexcheck` | Skip index.html validation                        | `false`                 |
-| `-h`             | Show help                                         |                         |
+| Option           | Description                                      | Default                 |
+| ---------------- | ------------------------------------------------ | ----------------------- |
+| `-s`             | Source folder with compiled web files            | (required)              |
+| `-e`             | Web server engine (psychic/async/espidf)         | `psychic`               |
+| `-o`             | Output header file path                          | `svelteesp32.h`         |
+| `--etag`         | ETag caching (true/false/compiler)               | `false`                 |
+| `--gzip`         | Gzip compression (true/false/compiler)           | `true`                  |
+| `--exclude`      | Exclude files by glob pattern                    | System files            |
+| `--basepath`     | URL prefix for all routes                        | (none)                  |
+| `--maxsize`      | Max total uncompressed size (e.g., `400k`, `1m`) | (none)                  |
+| `--maxgzipsize`  | Max total gzip size (e.g., `150k`, `500k`)       | (none)                  |
+| `--cachetime`    | Cache-Control max-age in seconds                 | `0`                     |
+| `--version`      | Version string in header                         | (none)                  |
+| `--define`       | C++ define prefix                                | `SVELTEESP32`           |
+| `--espmethod`    | Init function name                               | `initSvelteStaticFiles` |
+| `--config`       | Custom RC file path                              | `.svelteesp32rc.json`   |
+| `--dryrun`       | Show summary without writing output              | `false`                 |
+| `--noindexcheck` | Skip index.html validation                       | `false`                 |
+| `-h`             | Show help                                        |                         |
 
 ---
 
@@ -432,7 +434,12 @@ Store your settings in `.svelteesp32rc.json` for zero-argument builds:
   "outputfile": "./esp32/svelteesp32.h",
   "etag": "true",
   "gzip": "true",
-  "exclude": ["*.map", "*.md"]
+  "exclude": ["*.map", "*.md"],
+  "basepath": "/ui",
+  "maxsize": "400k",
+  "maxgzipsize": "150k",
+  "noindexcheck": false,
+  "dryrun": false
 }
 ```
 

package/dist/commandLine.d.ts

@@ -1,5 +1,5 @@
 interface ICopyFilesArguments {
-    engine: 'psychic' | 'psychic2' | 'async' | 'espidf';
+    engine: 'psychic' | 'async' | 'espidf';
     sourcepath: string;
     outputfile: string;
     espmethod: string;
@@ -14,10 +14,11 @@ interface ICopyFilesArguments {
     maxSize?: number;
     maxGzipSize?: number;
     noIndexCheck?: boolean;
+    dryRun?: boolean;
     help?: boolean;
 }
 interface IRcFileConfig {
-    engine?: 'psychic' | 'psychic2' | 'async' | 'espidf';
+    engine?: 'psychic' | 'async' | 'espidf';
     sourcepath?: string;
     outputfile?: string;
     espmethod?: string;
@@ -28,14 +29,17 @@ interface IRcFileConfig {
     created?: boolean;
     version?: string;
     exclude?: string[];
-    basePath?: string;
-    maxSize?: number | string;
-    maxGzipSize?: number | string;
+    basepath?: string;
+    maxsize?: number | string;
+    maxgzipsize?: number | string;
+    noindexcheck?: boolean;
+    dryrun?: boolean;
 }
+declare function validateCppIdentifier(value: string, name: string): string;
 declare function parseSize(value: string, name: string): number;
 declare function getNpmPackageVariable(packageJson: Record<string, unknown>, variableName: string): string | undefined;
 declare function hasNpmVariables(config: IRcFileConfig): boolean;
 declare function interpolateNpmVariables(config: IRcFileConfig, rcFilePath: string): IRcFileConfig;
-export { getNpmPackageVariable, hasNpmVariables, interpolateNpmVariables, parseSize };
+export { getNpmPackageVariable, hasNpmVariables, interpolateNpmVariables, parseSize, validateCppIdentifier };
 export declare function formatConfiguration(cmdLine: ICopyFilesArguments): string;
 export declare const cmdLine: ICopyFilesArguments;

package/dist/commandLine.js

@@ -8,6 +8,7 @@ exports.getNpmPackageVariable = getNpmPackageVariable;
 exports.hasNpmVariables = hasNpmVariables;
 exports.interpolateNpmVariables = interpolateNpmVariables;
 exports.parseSize = parseSize;
+exports.validateCppIdentifier = validateCppIdentifier;
 exports.formatConfiguration = formatConfiguration;
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -23,7 +24,7 @@ Configuration:
 
 Options:
   -e, --engine <value>       The engine for which the include file is created
-                             (psychic|psychic2|async|espidf) (default: "psychic")
+                             (psychic|async|espidf) (default: "psychic")
   -s, --sourcepath <path>    Source dist folder contains compiled web files (required)
   -o, --outputfile <path>    Generated output file with path (default: "svelteesp32.h")
   --etag <value>             Use ETAG header for cache (true|false|compiler) (default: "false")
@@ -38,6 +39,7 @@ Options:
   --basepath <path>          URL prefix for all routes (e.g., "/ui") (default: "")
   --maxsize <size>           Maximum total uncompressed size (e.g., 400k, 1.5m, 409600)
   --maxgzipsize <size>       Maximum total gzip size (e.g., 150k, 1m, 153600)
+  --dryrun                   Show summary without writing the output file (default: false)
   -h, --help                 Shows this help
 
 RC File:
@@ -52,7 +54,11 @@ RC File:
       "outputfile": "./output.h",
       "etag": "true",
       "gzip": "true",
-      "exclude": ["*.map", "*.md"]
+      "exclude": ["*.map", "*.md"],
+      "basepath": "/ui",
+      "maxsize": "400k",
+      "maxgzipsize": "150k",
+      "noindexcheck": false
     }
 
   CLI arguments override RC file values.
@@ -60,7 +66,7 @@ RC File:
     process.exit(0);
 }
 function validateEngine(value) {
-    if (value === 'psychic' || value === 'psychic2' || value === 'async' || value === 'espidf')
+    if (value === 'psychic' || value === 'async' || value === 'espidf')
         return value;
     console.error((0, errorMessages_1.getInvalidEngineError)(value));
     process.exit(1);
@@ -70,6 +76,11 @@ function validateTriState(value, name) {
         return value;
     throw new Error(`Invalid ${name}: ${value}`);
 }
+function validateCppIdentifier(value, name) {
+    if (!/^[A-Z_a-z]\w*$/.test(value))
+        throw new Error(`${name} must be a valid C++ identifier (letters, digits, underscores, not starting with a digit): ${value}`);
+    return value;
+}
 function validateBasePath(value) {
     if (value === '')
         return value;
@@ -170,7 +181,7 @@ function hasNpmVariables(config) {
         checkStringForNpmVariable(config.espmethod) ||
         checkStringForNpmVariable(config.define) ||
         checkStringForNpmVariable(config.version) ||
-        checkStringForNpmVariable(config.basePath) ||
+        checkStringForNpmVariable(config.basepath) ||
         (Array.isArray(config.exclude) && config.exclude.some((pattern) => checkStringForNpmVariable(pattern))) ||
         false);
 }
@@ -190,8 +201,8 @@ function interpolateNpmVariables(config, rcFilePath) {
             affectedFields.push('espmethod');
         if (config.define?.includes('$npm_package_'))
             affectedFields.push('define');
-        if (config.basePath?.includes('$npm_package_'))
-            affectedFields.push('basePath');
+        if (config.basepath?.includes('$npm_package_'))
+            affectedFields.push('basepath');
         if (config.exclude)
             for (const [index, pattern] of config.exclude.entries())
                 if (pattern.includes('$npm_package_'))
@@ -216,8 +227,8 @@ function interpolateNpmVariables(config, rcFilePath) {
         result.define = interpolateString(result.define);
     if (result.version)
         result.version = interpolateString(result.version);
-    if (result.basePath)
-        result.basePath = interpolateString(result.basePath);
+    if (result.basepath)
+        result.basepath = interpolateString(result.basepath);
     if (result.exclude)
         result.exclude = result.exclude.map((pattern) => interpolateString(pattern));
     return result;
@@ -251,9 +262,11 @@ function validateRcConfig(config, rcPath) {
         'created',
         'version',
         'exclude',
-        'basePath',
-        'maxSize',
-        'maxGzipSize'
+        'basepath',
+        'maxsize',
+        'maxgzipsize',
+        'noindexcheck',
+        'dryrun'
     ]);
     for (const key of Object.keys(configObject))
         if (!validKeys.has(key))
@@ -264,9 +277,16 @@ function validateRcConfig(config, rcPath) {
         configObject['etag'] = validateTriState(configObject['etag'], 'etag');
     if (configObject['gzip'] !== undefined)
         configObject['gzip'] = validateTriState(configObject['gzip'], 'gzip');
-    if (configObject['cachetime'] !== undefined &&
-        (typeof configObject['cachetime'] !== 'number' || Number.isNaN(configObject['cachetime'])))
-        throw new TypeError(`Invalid cachetime in RC file: ${configObject['cachetime']}`);
+    if (configObject['espmethod'] !== undefined)
+        validateCppIdentifier(configObject['espmethod'], 'espmethod');
+    if (configObject['define'] !== undefined)
+        validateCppIdentifier(configObject['define'], 'define');
+    if (configObject['cachetime'] !== undefined) {
+        if (typeof configObject['cachetime'] !== 'number' || Number.isNaN(configObject['cachetime']))
+            throw new TypeError(`Invalid cachetime in RC file: ${configObject['cachetime']}`);
+        if (configObject['cachetime'] < 0)
+            throw new TypeError(`Invalid cachetime in RC file: ${configObject['cachetime']} (must be non-negative)`);
+    }
     if (configObject['exclude'] !== undefined) {
         if (!Array.isArray(configObject['exclude']))
             throw new TypeError("'exclude' in RC file must be an array");
@@ -274,30 +294,34 @@ function validateRcConfig(config, rcPath) {
             if (typeof pattern !== 'string')
                 throw new TypeError('All exclude patterns must be strings');
     }
-    if (configObject['maxSize'] !== undefined) {
-        const value = configObject['maxSize'];
+    if (configObject['maxsize'] !== undefined) {
+        const value = configObject['maxsize'];
         if (typeof value === 'string')
             try {
-                configObject['maxSize'] = parseSize(value, 'maxSize');
+                configObject['maxsize'] = parseSize(value, 'maxsize');
             }
             catch {
-                throw new TypeError(`Invalid maxSize in RC file: ${value} (must be a positive number with optional k/m suffix)`);
+                throw new TypeError(`Invalid maxsize in RC file: ${value} (must be a positive number with optional k/m suffix)`);
             }
         else if (typeof value !== 'number' || Number.isNaN(value) || value <= 0)
-            throw new TypeError(`Invalid maxSize in RC file: ${value} (must be a positive number)`);
+            throw new TypeError(`Invalid maxsize in RC file: ${value} (must be a positive number)`);
     }
-    if (configObject['maxGzipSize'] !== undefined) {
-        const value = configObject['maxGzipSize'];
+    if (configObject['maxgzipsize'] !== undefined) {
+        const value = configObject['maxgzipsize'];
         if (typeof value === 'string')
             try {
-                configObject['maxGzipSize'] = parseSize(value, 'maxGzipSize');
+                configObject['maxgzipsize'] = parseSize(value, 'maxgzipsize');
             }
             catch {
-                throw new TypeError(`Invalid maxGzipSize in RC file: ${value} (must be a positive number with optional k/m suffix)`);
+                throw new TypeError(`Invalid maxgzipsize in RC file: ${value} (must be a positive number with optional k/m suffix)`);
             }
         else if (typeof value !== 'number' || Number.isNaN(value) || value <= 0)
-            throw new TypeError(`Invalid maxGzipSize in RC file: ${value} (must be a positive number)`);
+            throw new TypeError(`Invalid maxgzipsize in RC file: ${value} (must be a positive number)`);
     }
+    if (configObject['noindexcheck'] !== undefined && typeof configObject['noindexcheck'] !== 'boolean')
+        throw new TypeError(`Invalid noindexcheck in RC file: ${configObject['noindexcheck']} (must be boolean)`);
+    if (configObject['dryrun'] !== undefined && typeof configObject['dryrun'] !== 'boolean')
+        throw new TypeError(`Invalid dryrun in RC file: ${configObject['dryrun']} (must be boolean)`);
     return configObject;
 }
 function parseArguments() {
@@ -353,15 +377,75 @@ function parseArguments() {
         result.espmethod = rcConfig.espmethod;
     if (rcConfig.define)
         result.define = rcConfig.define;
-    if (rcConfig.basePath !== undefined)
-        result.basePath = validateBasePath(rcConfig.basePath);
-    if (rcConfig.maxSize !== undefined)
-        result.maxSize = rcConfig.maxSize;
-    if (rcConfig.maxGzipSize !== undefined)
-        result.maxGzipSize = rcConfig.maxGzipSize;
+    if (rcConfig.basepath !== undefined)
+        result.basePath = validateBasePath(rcConfig.basepath);
+    if (rcConfig.maxsize !== undefined)
+        result.maxSize = rcConfig.maxsize;
+    if (rcConfig.maxgzipsize !== undefined)
+        result.maxGzipSize = rcConfig.maxgzipsize;
+    if (rcConfig.noindexcheck !== undefined)
+        result.noIndexCheck = rcConfig.noindexcheck;
+    if (rcConfig.dryrun !== undefined)
+        result.dryRun = rcConfig.dryrun;
     if (rcConfig.exclude && rcConfig.exclude.length > 0)
         result.exclude = [...rcConfig.exclude];
     const cliExclude = [];
+    function applyFlag(flagName, value) {
+        switch (flagName) {
+            case 'config':
+                break;
+            case 'engine':
+                result.engine = validateEngine(value);
+                break;
+            case 'sourcepath':
+                result.sourcepath = value;
+                break;
+            case 'outputfile':
+                result.outputfile = value;
+                break;
+            case 'etag':
+                result.etag = validateTriState(value, 'etag');
+                break;
+            case 'gzip':
+                result.gzip = validateTriState(value, 'gzip');
+                break;
+            case 'version':
+                result.version = value;
+                break;
+            case 'espmethod':
+                result.espmethod = validateCppIdentifier(value, 'espmethod');
+                break;
+            case 'define':
+                result.define = validateCppIdentifier(value, 'define');
+                break;
+            case 'cachetime':
+                result.cachetime = Number.parseInt(value, 10);
+                if (Number.isNaN(result.cachetime))
+                    throw new TypeError(`Invalid cachetime: ${value}`);
+                if (result.cachetime < 0)
+                    throw new TypeError(`Invalid cachetime: ${value} (must be non-negative)`);
+                break;
+            case 'exclude': {
+                const patterns = value
+                    .split(',')
+                    .map((p) => p.trim())
+                    .filter(Boolean);
+                cliExclude.push(...patterns);
+                break;
+            }
+            case 'basepath':
+                result.basePath = validateBasePath(value);
+                break;
+            case 'maxsize':
+                result.maxSize = parseSize(value, '--maxsize');
+                break;
+            case 'maxgzipsize':
+                result.maxGzipSize = parseSize(value, '--maxgzipsize');
+                break;
+            default:
+                throw new Error(`Unknown flag: --${flagName}`);
+        }
+    }
     for (let index = 0; index < arguments_.length; index++) {
         const argument = arguments_[index];
         if (!argument)
@@ -374,59 +458,7 @@ function parseArguments() {
             const value = parts.slice(1).join('=');
             if (!flag || !value)
                 throw new Error(`Invalid argument format: ${argument}`);
-            const flagName = flag.slice(2);
-            switch (flagName) {
-                case 'config':
-                    break;
-                case 'engine':
-                    result.engine = validateEngine(value);
-                    break;
-                case 'sourcepath':
-                    result.sourcepath = value;
-                    break;
-                case 'outputfile':
-                    result.outputfile = value;
-                    break;
-                case 'etag':
-                    result.etag = validateTriState(value, 'etag');
-                    break;
-                case 'gzip':
-                    result.gzip = validateTriState(value, 'gzip');
-                    break;
-                case 'version':
-                    result.version = value;
-                    break;
-                case 'espmethod':
-                    result.espmethod = value;
-                    break;
-                case 'define':
-                    result.define = value;
-                    break;
-                case 'cachetime':
-                    result.cachetime = Number.parseInt(value, 10);
-                    if (Number.isNaN(result.cachetime))
-                        throw new TypeError(`Invalid cachetime: ${value}`);
-                    break;
-                case 'exclude': {
-                    const patterns = value
-                        .split(',')
-                        .map((p) => p.trim())
-                        .filter(Boolean);
-                    cliExclude.push(...patterns);
-                    break;
-                }
-                case 'basepath':
-                    result.basePath = validateBasePath(value);
-                    break;
-                case 'maxsize':
-                    result.maxSize = parseSize(value, '--maxsize');
-                    break;
-                case 'maxgzipsize':
-                    result.maxGzipSize = parseSize(value, '--maxgzipsize');
-                    break;
-                default:
-                    throw new Error(`Unknown flag: ${flag}`);
-            }
+            applyFlag(flag.slice(2), value);
             continue;
         }
         if (argument === '--created') {
@@ -437,6 +469,10 @@ function parseArguments() {
             result.noIndexCheck = true;
             continue;
         }
+        if (argument === '--dryrun' || argument === '--dry-run') {
+            result.dryRun = true;
+            continue;
+        }
         if (argument.startsWith('-') && !argument.startsWith('--')) {
             const flag = argument.slice(1);
             const nextArgument = arguments_[index + 1];
@@ -465,72 +501,8 @@ function parseArguments() {
             const nextArgument = arguments_[index + 1];
             if (!nextArgument || nextArgument.startsWith('-'))
                 throw new Error(`Missing value for flag: ${argument}`);
-            switch (flag) {
-                case 'config':
-                    index++;
-                    break;
-                case 'engine':
-                    result.engine = validateEngine(nextArgument);
-                    index++;
-                    break;
-                case 'sourcepath':
-                    result.sourcepath = nextArgument;
-                    index++;
-                    break;
-                case 'outputfile':
-                    result.outputfile = nextArgument;
-                    index++;
-                    break;
-                case 'etag':
-                    result.etag = validateTriState(nextArgument, 'etag');
-                    index++;
-                    break;
-                case 'gzip':
-                    result.gzip = validateTriState(nextArgument, 'gzip');
-                    index++;
-                    break;
-                case 'version':
-                    result.version = nextArgument;
-                    index++;
-                    break;
-                case 'espmethod':
-                    result.espmethod = nextArgument;
-                    index++;
-                    break;
-                case 'define':
-                    result.define = nextArgument;
-                    index++;
-                    break;
-                case 'cachetime':
-                    result.cachetime = Number.parseInt(nextArgument, 10);
-                    if (Number.isNaN(result.cachetime))
-                        throw new TypeError(`Invalid cachetime: ${nextArgument}`);
-                    index++;
-                    break;
-                case 'exclude': {
-                    const patterns = nextArgument
-                        .split(',')
-                        .map((p) => p.trim())
-                        .filter(Boolean);
-                    cliExclude.push(...patterns);
-                    index++;
-                    break;
-                }
-                case 'basepath':
-                    result.basePath = validateBasePath(nextArgument);
-                    index++;
-                    break;
-                case 'maxsize':
-                    result.maxSize = parseSize(nextArgument, '--maxsize');
-                    index++;
-                    break;
-                case 'maxgzipsize':
-                    result.maxGzipSize = parseSize(nextArgument, '--maxgzipsize');
-                    index++;
-                    break;
-                default:
-                    throw new Error(`Unknown flag: --${flag}`);
-            }
+            applyFlag(flag, nextArgument);
+            index++;
             continue;
         }
         throw new Error(`Unknown argument: ${argument}`);