kempo-server 1.4.6 → 1.4.7

package/README.md

@@ -211,7 +211,7 @@ export default async function(request, response) {
 
 ## Configuration
 
-To configure the server create a `.config.json` within the root directory of your server (`public` in the start example [above](#getting-started)).
+To configure the server, create a configuration file (by default `.config.json`) within the root directory of your server (`public` in the start example [above](#getting-started)). You can specify a different configuration file using the `--config` flag.
 
 This json file can have any of the following properties, any property not defined will use the "Default Config".
 
@@ -620,12 +620,31 @@ Kempo Server supports several command line options to customize its behavior:
 - `--root <path>` - Set the document root directory (required)
 - `--port <number>` - Set the port number (default: 3000)
 - `--host <address>` - Set the host address (default: localhost)
+- `--config <path>` - Set the configuration file path (default: `.config.json`)
 - `--verbose` - Enable verbose logging
 
 ```bash
 kempo-server --root public --port 8080 --host 0.0.0.0 --verbose
 ```
 
+### Configuration File Examples
+
+You can specify different configuration files for different environments:
+
+```bash
+# Development
+kempo-server --root public --config dev.config.json
+
+# Staging
+kempo-server --root public --config staging.config.json
+
+# Production with absolute path
+kempo-server --root public --config /etc/kempo/production.config.json
+
+# Mix with other options
+kempo-server --root dist --port 8080 --config production.config.json --scan
+```
+
 ## Testing
 
 This project uses the Kempo Testing Framework. Tests live in the `tests/` folder and follow these naming conventions:

package/docs/configuration.html

@@ -15,7 +15,8 @@
     <p>Customize Kempo Server's behavior with a simple JSON configuration file.</p>
 
     <h2>Configuration File</h2>
-    <p>To configure the server create a <code>.config.json</code> within the root directory of your server (<code>public</code> in the start example).</p>
+    <p>To configure the server, create a configuration file (by default <code>.config.json</code>) within the root directory of your server (<code>public</code> in the start example). You can specify a different configuration file using the <code>--config</code> flag:</p>
+    <pre><code class="hljs bash"># Use default .config.json<br />kempo-server --root public<br /><br /># Use custom config file<br />kempo-server --root public --config staging.config.json<br /><br /># Use absolute path<br />kempo-server --root public --config /etc/kempo/production.config.json</code></pre>
     <p>This json file can have any of the following properties. Any property not defined will use the default configuration.</p>
 
     <h2>Configuration Options</h2>
@@ -78,15 +79,21 @@
     <pre><code class="hljs json">{<br />  <span class="hljs-attr">"allowedMimes"</span>: {<br />    <span class="hljs-attr">"html"</span>: <span class="hljs-string">"text/html"</span>,<br />    <span class="hljs-attr">"css"</span>: <span class="hljs-string">"text/css"</span>,<br />    <span class="hljs-attr">"js"</span>: <span class="hljs-string">"application/javascript"</span>,<br />    <span class="hljs-attr">"json"</span>: <span class="hljs-string">"application/json"</span>,<br />    <span class="hljs-attr">"png"</span>: <span class="hljs-string">"image/png"</span>,<br />    <span class="hljs-attr">"jpg"</span>: <span class="hljs-string">"image/jpeg"</span>,<br />    <span class="hljs-attr">"jpeg"</span>: <span class="hljs-string">"image/jpeg"</span>,<br />    <span class="hljs-attr">"gif"</span>: <span class="hljs-string">"image/gif"</span>,<br />    <span class="hljs-attr">"svg"</span>: <span class="hljs-string">"image/svg+xml"</span>,<br />    <span class="hljs-attr">"woff"</span>: <span class="hljs-string">"font/woff"</span>,<br />    <span class="hljs-attr">"woff2"</span>: <span class="hljs-string">"font/woff2"</span><br />  },<br />  <span class="hljs-attr">"disallowedRegex"</span>: [<br />    <span class="hljs-string">"^/\\..*"</span>,<br />    <span class="hljs-string">"\\.env$"</span>,<br />    <span class="hljs-string">"\\.config$"</span>,<br />    <span class="hljs-string">"password"</span>,<br />    <span class="hljs-string">"node_modules"</span>,<br />    <span class="hljs-string">"\\.git"</span><br />  ],<br />  <span class="hljs-attr">"routeFiles"</span>: [<br />    <span class="hljs-string">"GET.js"</span>,<br />    <span class="hljs-string">"POST.js"</span>,<br />    <span class="hljs-string">"PUT.js"</span>,<br />    <span class="hljs-string">"DELETE.js"</span>,<br />    <span class="hljs-string">"PATCH.js"</span>,<br />    <span class="hljs-string">"HEAD.js"</span>,<br />    <span class="hljs-string">"OPTIONS.js"</span>,<br />    <span class="hljs-string">"index.js"</span><br />  ],<br />  <span class="hljs-attr">"noRescanPaths"</span>: [<br />    <span class="hljs-string">"/favicon\\.ico$"</span>,<br />    <span class="hljs-string">"/robots\\.txt$"</span>,<br />    <span class="hljs-string">"\\.map$"</span>,<br />    <span class="hljs-string">"\\.css$"</span>,<br />    <span class="hljs-string">"\\.js$"</span>,<br />    <span class="hljs-string">"\\.png$"</span>,<br />    <span class="hljs-string">"\\.jpg$"</span>,<br />    <span class="hljs-string">"\\.jpeg$"</span>,<br />    <span class="hljs-string">"\\.gif$"</span><br />  ],<br />  <span class="hljs-attr">"customRoutes"</span>: {<br />    <span class="hljs-attr">"/vendor/bootstrap.css"</span>: <span class="hljs-string">"./node_modules/bootstrap/dist/css/bootstrap.min.css"</span>,<br />    <span class="hljs-attr">"/vendor/jquery.js"</span>: <span class="hljs-string">"./node_modules/jquery/dist/jquery.min.js"</span>,<br />    <span class="hljs-attr">"assets/*"</span>: <span class="hljs-string">"./static-files/*"</span>,<br />    <span class="hljs-attr">"docs/*"</span>: <span class="hljs-string">"./documentation/*"</span><br />  },<br />  <span class="hljs-attr">"maxRescanAttempts"</span>: <span class="hljs-number">3</span>,<br />  <span class="hljs-attr">"middleware"</span>: {<br />    <span class="hljs-attr">"cors"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"origin"</span>: <span class="hljs-string">"*"</span>,<br />      <span class="hljs-attr">"methods"</span>: [<span class="hljs-string">"GET"</span>, <span class="hljs-string">"POST"</span>, <span class="hljs-string">"PUT"</span>, <span class="hljs-string">"DELETE"</span>],<br />      <span class="hljs-attr">"headers"</span>: [<span class="hljs-string">"Content-Type"</span>, <span class="hljs-string">"Authorization"</span>]<br />    },<br />    <span class="hljs-attr">"compression"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"threshold"</span>: <span class="hljs-number">1024</span><br />    },<br />    <span class="hljs-attr">"security"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"headers"</span>: {<br />        <span class="hljs-attr">"X-Content-Type-Options"</span>: <span class="hljs-string">"nosniff"</span>,<br />        <span class="hljs-attr">"X-Frame-Options"</span>: <span class="hljs-string">"DENY"</span>,<br />        <span class="hljs-attr">"X-XSS-Protection"</span>: <span class="hljs-string">"1; mode=block"</span><br />      }<br />    },<br />    <span class="hljs-attr">"custom"</span>: [<br />      <span class="hljs-string">"./middleware/auth.js"</span>,<br />      <span class="hljs-string">"./middleware/logging.js"</span><br />    ]<br />  }<br />}</code></pre>
 
     <h2>Environment-Specific Configuration</h2>
-    <p>You can create different configuration files for different environments:</p>
+    <p>You can create different configuration files for different environments and specify them using the <code>--config</code> flag:</p>
     
     <h3>Development Configuration</h3>
     <p>Create <code>.config.dev.json</code> for development:</p>
     <pre><code class="hljs json">{<br />  <span class="hljs-attr">"allowedMimes"</span>: {<br />    <span class="hljs-attr">"html"</span>: <span class="hljs-string">"text/html"</span>,<br />    <span class="hljs-attr">"css"</span>: <span class="hljs-string">"text/css"</span>,<br />    <span class="hljs-attr">"js"</span>: <span class="hljs-string">"application/javascript"</span>,<br />    <span class="hljs-attr">"json"</span>: <span class="hljs-string">"application/json"</span>,<br />    <span class="hljs-attr">"map"</span>: <span class="hljs-string">"application/json"</span><br />  },<br />  <span class="hljs-attr">"middleware"</span>: {<br />    <span class="hljs-attr">"cors"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"origin"</span>: <span class="hljs-string">"*"</span><br />    },<br />    <span class="hljs-attr">"compression"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">false</span><br />    }<br />  }<br />}</code></pre>
+    <p>Use with: <code>kempo-server --root public --config .config.dev.json</code></p>
 
     <h3>Production Configuration</h3>
     <p>Create <code>.config.prod.json</code> for production:</p>
     <pre><code class="hljs json">{<br />  <span class="hljs-attr">"allowedMimes"</span>: {<br />    <span class="hljs-attr">"html"</span>: <span class="hljs-string">"text/html"</span>,<br />    <span class="hljs-attr">"css"</span>: <span class="hljs-string">"text/css"</span>,<br />    <span class="hljs-attr">"js"</span>: <span class="hljs-string">"application/javascript"</span>,<br />    <span class="hljs-attr">"json"</span>: <span class="hljs-string">"application/json"</span>,<br />    <span class="hljs-attr">"png"</span>: <span class="hljs-string">"image/png"</span>,<br />    <span class="hljs-attr">"jpg"</span>: <span class="hljs-string">"image/jpeg"</span><br />  },<br />  <span class="hljs-attr">"disallowedRegex"</span>: [<br />    <span class="hljs-string">"^/\\..*"</span>,<br />    <span class="hljs-string">"\\.env$"</span>,<br />    <span class="hljs-string">"\\.config$"</span>,<br />    <span class="hljs-string">"password"</span>,<br />    <span class="hljs-string">"node_modules"</span>,<br />    <span class="hljs-string">"\\.git"</span>,<br />    <span class="hljs-string">"\\.map$"</span><br />  ],<br />  <span class="hljs-attr">"middleware"</span>: {<br />    <span class="hljs-attr">"cors"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"origin"</span>: <span class="hljs-string">"https://yourdomain.com"</span><br />    },<br />    <span class="hljs-attr">"compression"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"threshold"</span>: <span class="hljs-number">1024</span><br />    },<br />    <span class="hljs-attr">"security"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"headers"</span>: {<br />        <span class="hljs-attr">"X-Content-Type-Options"</span>: <span class="hljs-string">"nosniff"</span>,<br />        <span class="hljs-attr">"X-Frame-Options"</span>: <span class="hljs-string">"DENY"</span>,<br />        <span class="hljs-attr">"X-XSS-Protection"</span>: <span class="hljs-string">"1; mode=block"</span>,<br />        <span class="hljs-attr">"Strict-Transport-Security"</span>: <span class="hljs-string">"max-age=31536000; includeSubDomains"</span><br />      }<br />    }<br />  }<br />}</code></pre>
+    <p>Use with: <code>kempo-server --root public --config .config.prod.json</code></p>
+
+    <h3>Package.json Scripts</h3>
+    <p>Add environment-specific scripts to your <code>package.json</code>:</p>
+    <pre><code class="hljs json">{<br />  <span class="hljs-attr">"scripts"</span>: {<br />    <span class="hljs-attr">"start"</span>: <span class="hljs-string">"kempo-server --root public"</span>,<br />    <span class="hljs-attr">"start:dev"</span>: <span class="hljs-string">"kempo-server --root public --config .config.dev.json --verbose"</span>,<br />    <span class="hljs-attr">"start:staging"</span>: <span class="hljs-string">"kempo-server --root public --config .config.staging.json"</span>,<br />    <span class="hljs-attr">"start:prod"</span>: <span class="hljs-string">"kempo-server --root public --config .config.prod.json"</span><br />  }<br />}</code></pre>
 
     <h2>Configuration Tips</h2>
     

package/docs/getting-started.html

@@ -51,12 +51,17 @@
       <li><code>--root &lt;path&gt;</code> - Set the document root directory (required)</li>
       <li><code>--port &lt;number&gt;</code> - Set the port number (default: 3000)</li>
       <li><code>--host &lt;address&gt;</code> - Set the host address (default: localhost)</li>
+      <li><code>--config &lt;path&gt;</code> - Set the configuration file path (default: .config.json)</li>
       <li><code>--verbose</code> - Enable verbose logging</li>
     </ul>
     
-    <p>Example:</p>
+    <p>Basic example:</p>
     <pre><code>kempo-server --root public --port 8080 --host 0.0.0.0 --verbose</code></pre>
 
+    <h3>Configuration File Examples</h3>
+    <p>You can specify different configuration files for different environments:</p>
+    <pre><code class="hljs bash"># Development<br />kempo-server --root public --config dev.config.json<br /><br /># Staging<br />kempo-server --root public --config staging.config.json<br /><br /># Production with absolute path<br />kempo-server --root public --config /etc/kempo/production.config.json<br /><br /># Mix with other options<br />kempo-server --root dist --port 8080 --config production.config.json --scan</code></pre>
+
     <h2>What's Next?</h2>
     <p>Now that you have Kempo Server running, explore these topics:</p>
     <ul>

package/index.js

@@ -7,12 +7,14 @@ const flags = getFlags(process.argv.slice(2), {
   port: 3000,
   logging: 2,
   root: './',
-  scan: false
+  scan: false,
+  config: '.config.json'
 }, {
   p: 'port',
   l: 'logging',
   r: 'root',
-  s: 'scan'
+  s: 'scan',
+  c: 'config'
 });
 
 if(typeof(flags.logging) === 'string'){

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kempo-server",
   "type": "module",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "A lightweight, zero-dependency, file based routing server.",
   "main": "index.js",
   "bin": {

package/router.js

@@ -21,17 +21,34 @@ export default async (flags, log) => {
   
   let config = defaultConfig;
   try {
-    const configPath = path.join(rootPath, '.config.json');
+    // Use the provided config path or fallback to .config.json in rootPath
+    const configFileName = flags.config || '.config.json';
+    const configPath = path.isAbsolute(configFileName) 
+      ? configFileName 
+      : path.join(rootPath, configFileName);
     log(`Loading config from: ${configPath}`, 2);
     const configContent = await readFile(configPath, 'utf8');
     const userConfig = JSON.parse(configContent);
     config = {
       ...defaultConfig,
-      ...userConfig
+      ...userConfig,
+      // Deep merge nested objects
+      allowedMimes: {
+        ...defaultConfig.allowedMimes,
+        ...userConfig.allowedMimes
+      },
+      middleware: {
+        ...defaultConfig.middleware,
+        ...userConfig.middleware
+      },
+      customRoutes: {
+        ...defaultConfig.customRoutes,
+        ...userConfig.customRoutes
+      }
     };
     log('User config loaded and merged with defaults', 2);
   } catch (e){
-    log('Using default config (no .config.json found)', 2);
+    log('Using default config (no config file found)', 2);
   }
   
   /*

package/tests/builtinMiddleware-cors.node-test.js

@@ -1,5 +1,5 @@
 import {corsMiddleware} from '../builtinMiddleware.js';
-import {createMockReq, createMockRes, expect} from './test-utils.js';
+import {createMockReq, createMockRes} from './test-utils.js';
 
 export default {
   'cors origin array and non-OPTIONS continues to next': async ({pass, fail}) => {
@@ -9,8 +9,8 @@ export default {
       const req = createMockReq({method: 'GET', headers: {origin: 'http://b'}});
       let called = false;
       await mw(req, res, async () => { called = true; });
-      expect(called, 'next not called');
-      expect(res.getHeader('Access-Control-Allow-Origin') === 'http://b', 'allowed origin');
+      if(!called) return fail('next not called');
+      if(res.getHeader('Access-Control-Allow-Origin') !== 'http://b') return fail('allowed origin');
       pass('cors array');
     } catch(e){ fail(e.message); }
   }

package/tests/builtinMiddleware.node-test.js

@@ -1,5 +1,5 @@
 import http from 'http';
-import {createMockReq, createMockRes, expect, bigString, gzipSize, setEnv} from './test-utils.js';
+import {createMockReq, createMockRes, bigString, gzipSize, setEnv} from './test-utils.js';
 import {corsMiddleware, compressionMiddleware, rateLimitMiddleware, securityMiddleware, loggingMiddleware} from '../builtinMiddleware.js';
 
 export default {
@@ -9,8 +9,8 @@ export default {
       const mw = corsMiddleware({origin: '*', methods: ['GET'], headers: ['X']});
       const req = createMockReq({method: 'OPTIONS', headers: {origin: 'http://x'}});
       await mw(req, res, async () => {});
-      expect(res.isEnded(), 'preflight should end');
-      expect(res.getHeader('Access-Control-Allow-Origin') === 'http://x' || res.getHeader('Access-Control-Allow-Origin') === '*', 'origin header');
+      if(!res.isEnded()) return fail('preflight should end');
+      if(!(res.getHeader('Access-Control-Allow-Origin') === 'http://x' || res.getHeader('Access-Control-Allow-Origin') === '*')) return fail('origin header');
       pass('cors');
     } catch(e){ fail(e.message); }
   },
@@ -30,9 +30,9 @@ export default {
       const gzLen = await gzipSize(original);
       // If gzipped is smaller, we expect gzip header. Otherwise, implementation may send uncompressed.
       if(gzLen < original.length){
-        expect(res.getHeader('Content-Encoding') === 'gzip', 'should gzip when beneficial');
+        if(res.getHeader('Content-Encoding') !== 'gzip') return fail('should gzip when beneficial');
       }
-      expect(body.length > 0, 'has body');
+      if(body.length <= 0) return fail('has body');
       pass('compression');
     } catch(e){ fail(e.message); }
   },
@@ -47,7 +47,7 @@ export default {
       await mw(req, res2, async () => {});
       const res3 = createMockRes();
       await mw(req, res3, async () => {});
-      expect(res3.statusCode === 429, 'should rate limit');
+      if(res3.statusCode !== 429) return fail('should rate limit');
       pass('rateLimit');
     } catch(e){ fail(e.message); }
   },
@@ -56,7 +56,7 @@ export default {
       const res = createMockRes();
       const mw = securityMiddleware({headers: {'X-Test': '1'}});
       await mw(createMockReq(), res, async () => {});
-      expect(res.getHeader('X-Test') === '1', 'header set');
+      if(res.getHeader('X-Test') !== '1') return fail('header set');
       pass('security');
     } catch(e){ fail(e.message); }
   },
@@ -67,7 +67,7 @@ export default {
       const mw = loggingMiddleware({includeUserAgent: true, includeResponseTime: true}, logger);
       const res = createMockRes();
       await mw(createMockReq({headers: {'user-agent': 'UA'}}), res, async () => { res.end('x'); });
-      expect(logs.length === 1 && logs[0].includes('GET /') && logs[0].includes('UA'), 'logged');
+      if(!(logs.length === 1 && logs[0].includes('GET /') && logs[0].includes('UA'))) return fail('logged');
       pass('logging');
     } catch(e){ fail(e.message); }
   }

package/tests/config-flag-cli.node-test.js

@@ -0,0 +1,259 @@
+import {startNode, randomPort, httpGet, withTempDir, write} from './test-utils.js';
+import path from 'path';
+
+export default {
+  'CLI uses default config file when no --config flag provided': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create default config and test file
+      const defaultConfig = {
+        allowedMimes: {
+          html: "text/html",
+          default: "text/default"
+        }
+      };
+      await write(dir, '.config.json', JSON.stringify(defaultConfig));
+      await write(dir, 'test.default', 'default config content');
+      
+      const port = randomPort();
+      const args = [path.join(process.cwd(), 'index.js'), '-r', '.', '-p', String(port), '-l', '0'];
+      const child = await startNode(args, {cwd: dir});
+      
+      // Wait briefly for server to start
+      await new Promise(r => setTimeout(r, 400));
+      
+      try {
+        const {res, body} = await httpGet(`http://localhost:${port}/test.default`);
+        if (res.statusCode !== 200) {
+          return fail('server should serve file with default config');
+        }
+        if (res.headers['content-type'] !== 'text/default') {
+          return fail('should use default config mime type');
+        }
+        if (body.toString() !== 'default config content') {
+          return fail('should serve correct content');
+        }
+        pass('CLI default config usage');
+      } finally {
+        child.kill();
+        await new Promise(r => setTimeout(r, 50));
+      }
+    });
+  },
+
+  'CLI uses custom config file with --config flag': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create custom config and test file
+      const customConfig = {
+        allowedMimes: {
+          html: "text/html",
+          custom: "text/custom"
+        }
+      };
+      await write(dir, 'dev.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.custom', 'custom config content');
+      
+      const port = randomPort();
+      const args = [
+        path.join(process.cwd(), 'index.js'), 
+        '-r', '.', 
+        '-p', String(port), 
+        '-l', '0',
+        '--config', 'dev.config.json'
+      ];
+      const child = await startNode(args, {cwd: dir});
+      
+      // Wait briefly for server to start
+      await new Promise(r => setTimeout(r, 400));
+      
+      try {
+        const {res, body} = await httpGet(`http://localhost:${port}/test.custom`);
+        if (res.statusCode !== 200) {
+          return fail('server should serve file with custom config');
+        }
+        if (res.headers['content-type'] !== 'text/custom') {
+          return fail('should use custom config mime type');
+        }
+        if (body.toString() !== 'custom config content') {
+          return fail('should serve correct content');
+        }
+        pass('CLI custom config usage');
+      } finally {
+        child.kill();
+        await new Promise(r => setTimeout(r, 50));
+      }
+    });
+  },
+
+  'CLI uses custom config file with -c short flag': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create custom config and test file
+      const customConfig = {
+        allowedMimes: {
+          html: "text/html",
+          short: "text/short"
+        }
+      };
+      await write(dir, 'short.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.short', 'short flag content');
+      
+      const port = randomPort();
+      const args = [
+        path.join(process.cwd(), 'index.js'), 
+        '-r', '.', 
+        '-p', String(port), 
+        '-l', '0',
+        '-c', 'short.config.json'
+      ];
+      const child = await startNode(args, {cwd: dir});
+      
+      // Wait briefly for server to start
+      await new Promise(r => setTimeout(r, 400));
+      
+      try {
+        const {res, body} = await httpGet(`http://localhost:${port}/test.short`);
+        if (res.statusCode !== 200) {
+          return fail('server should serve file with short flag config');
+        }
+        if (res.headers['content-type'] !== 'text/short') {
+          return fail('should use short flag config mime type');
+        }
+        if (body.toString() !== 'short flag content') {
+          return fail('should serve correct content');
+        }
+        pass('CLI short config flag usage');
+      } finally {
+        child.kill();
+        await new Promise(r => setTimeout(r, 50));
+      }
+    });
+  },
+
+  'CLI uses absolute path config file': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create custom config in subdirectory
+      const configDir = path.join(dir, 'configs');
+      const customConfig = {
+        allowedMimes: {
+          html: "text/html",
+          absolute: "text/absolute"
+        }
+      };
+      const configPath = await write(configDir, 'prod.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.absolute', 'absolute path content');
+      
+      const port = randomPort();
+      const args = [
+        path.join(process.cwd(), 'index.js'), 
+        '-r', '.', 
+        '-p', String(port), 
+        '-l', '0',
+        '--config', configPath
+      ];
+      const child = await startNode(args, {cwd: dir});
+      
+      // Wait briefly for server to start
+      await new Promise(r => setTimeout(r, 400));
+      
+      try {
+        const {res, body} = await httpGet(`http://localhost:${port}/test.absolute`);
+        if (res.statusCode !== 200) {
+          return fail('server should serve file with absolute path config');
+        }
+        if (res.headers['content-type'] !== 'text/absolute') {
+          return fail('should use absolute path config mime type');
+        }
+        if (body.toString() !== 'absolute path content') {
+          return fail('should serve correct content');
+        }
+        pass('CLI absolute path config usage');
+      } finally {
+        child.kill();
+        await new Promise(r => setTimeout(r, 50));
+      }
+    });
+  },
+
+  'CLI gracefully handles missing config file': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create test file but no config
+      await write(dir, 'index.html', '<h1>Home</h1>');
+      
+      const port = randomPort();
+      const args = [
+        path.join(process.cwd(), 'index.js'), 
+        '-r', '.', 
+        '-p', String(port), 
+        '-l', '0',
+        '--config', 'nonexistent.config.json'
+      ];
+      const child = await startNode(args, {cwd: dir});
+      
+      // Wait briefly for server to start
+      await new Promise(r => setTimeout(r, 400));
+      
+      try {
+        const {res, body} = await httpGet(`http://localhost:${port}/index.html`);
+        if (res.statusCode !== 200) {
+          return fail('server should start with missing config');
+        }
+        if (res.headers['content-type'] !== 'text/html') {
+          return fail('should use default mime types');
+        }
+        if (!body.toString().includes('<h1>Home</h1>')) {
+          return fail('should serve HTML content');
+        }
+        pass('CLI missing config file handling');
+      } finally {
+        child.kill();
+        await new Promise(r => setTimeout(r, 50));
+      }
+    });
+  },
+
+  'CLI config flag works with custom routes': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create custom config with custom routes
+      await write(dir, 'source.txt', 'source file content');
+      const customConfig = {
+        allowedMimes: {
+          html: "text/html",
+          txt: "text/plain"
+        },
+        customRoutes: {
+          "/custom-route": "./source.txt"
+        }
+      };
+      await write(dir, 'routes.config.json', JSON.stringify(customConfig));
+      
+      const port = randomPort();
+      const args = [
+        path.join(process.cwd(), 'index.js'), 
+        '-r', '.', 
+        '-p', String(port), 
+        '-l', '0',
+        '--config', 'routes.config.json'
+      ];
+      const child = await startNode(args, {cwd: dir});
+      
+      // Wait briefly for server to start
+      await new Promise(r => setTimeout(r, 400));
+      
+      try {
+        const {res, body} = await httpGet(`http://localhost:${port}/custom-route`);
+        if (res.statusCode !== 200) {
+          return fail('custom route should work with config flag');
+        }
+        if (res.headers['content-type'] !== 'text/plain') {
+          return fail('should use config mime type');
+        }
+        if (body.toString() !== 'source file content') {
+          return fail('should serve custom route content');
+        }
+        pass('CLI config flag with custom routes');
+      } finally {
+        child.kill();
+        await new Promise(r => setTimeout(r, 50));
+      }
+    });
+  }
+};

package/tests/config-flag.node-test.js

@@ -0,0 +1,321 @@
+import http from 'http';
+import path from 'path';
+import {withTempDir, write, randomPort, httpGet} from './test-utils.js';
+import router from '../router.js';
+import getFlags from '../getFlags.js';
+
+export default {
+  'getFlags includes config flag with default value': async ({pass, fail}) => {
+    const args = ['--root', 'public', '--port', '8080'];
+    const flags = getFlags(args, {
+      port: 3000,
+      logging: 2,
+      root: './',
+      scan: false,
+      config: '.config.json'
+    }, {
+      p: 'port',
+      l: 'logging',
+      r: 'root',
+      s: 'scan',
+      c: 'config'
+    });
+    
+    if (flags.config !== '.config.json') {
+      return fail('default config should be .config.json');
+    }
+    if (flags.port !== '8080') {
+      return fail('other flags should still work');
+    }
+    if (flags.root !== 'public') {
+      return fail('root flag should work');
+    }
+    
+    pass('config flag has correct default');
+  },
+
+  'getFlags parses custom config flag with long form': async ({pass, fail}) => {
+    const args = ['--root', 'public', '--config', 'dev.config.json'];
+    const flags = getFlags(args, {
+      port: 3000,
+      logging: 2,
+      root: './',
+      scan: false,
+      config: '.config.json'
+    }, {
+      p: 'port',
+      l: 'logging',
+      r: 'root',
+      s: 'scan',
+      c: 'config'
+    });
+    
+    if (flags.config !== 'dev.config.json') {
+      return fail('should parse custom config file');
+    }
+    if (flags.root !== 'public') {
+      return fail('other flags should still work');
+    }
+    
+    pass('long form config flag parsing');
+  },
+
+  'getFlags parses custom config flag with short form': async ({pass, fail}) => {
+    const args = ['--root', 'public', '-c', 'production.config.json'];
+    const flags = getFlags(args, {
+      port: 3000,
+      logging: 2,
+      root: './',
+      scan: false,
+      config: '.config.json'
+    }, {
+      p: 'port',
+      l: 'logging',
+      r: 'root',
+      s: 'scan',
+      c: 'config'
+    });
+    
+    if (flags.config !== 'production.config.json') {
+      return fail('should parse short form config flag');
+    }
+    if (flags.root !== 'public') {
+      return fail('other flags should still work');
+    }
+    
+    pass('short form config flag parsing');
+  },
+
+  'router uses default config file when none specified': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create a custom config file as .config.json (default name)
+      const customConfig = {
+        allowedMimes: {
+          html: "text/html",
+          custom: "text/custom"
+        }
+      };
+      await write(dir, '.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.custom', 'custom content');
+      
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false, config: '.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const response = await httpGet(`http://localhost:${port}/test.custom`);
+        if (response.res.statusCode !== 200) {
+          return fail('custom mime type should be served');
+        }
+        if (response.res.headers['content-type'] !== 'text/custom') {
+          return fail('should use custom mime type');
+        }
+        pass('default config file usage');
+      } finally {
+        server.close();
+        process.chdir(prev);
+      }
+    });
+  },
+
+  'router uses custom config file with relative path': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create a custom config file with different name
+      const customConfig = {
+        allowedMimes: {
+          html: "text/html",
+          special: "text/special"
+        }
+      };
+      await write(dir, 'dev.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.special', 'special content');
+      
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false, config: 'dev.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const response = await httpGet(`http://localhost:${port}/test.special`);
+        if (response.res.statusCode !== 200) {
+          return fail('custom config should be loaded');
+        }
+        if (response.res.headers['content-type'] !== 'text/special') {
+          return fail('should use custom config mime type');
+        }
+        pass('relative path config file usage');
+      } finally {
+        server.close();
+        process.chdir(prev);
+      }
+    });
+  },
+
+  'router uses custom config file with absolute path': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create a custom config file in different location
+      const configDir = path.join(dir, 'configs');
+      const customConfig = {
+        allowedMimes: {
+          html: "text/html",
+          absolute: "text/absolute"
+        }
+      };
+      const configPath = await write(configDir, 'prod.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.absolute', 'absolute content');
+      
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false, config: configPath};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const response = await httpGet(`http://localhost:${port}/test.absolute`);
+        if (response.res.statusCode !== 200) {
+          return fail('absolute config path should work');
+        }
+        if (response.res.headers['content-type'] !== 'text/absolute') {
+          return fail('should use absolute config mime type');
+        }
+        pass('absolute path config file usage');
+      } finally {
+        server.close();
+        process.chdir(prev);
+      }
+    });
+  },
+
+  'router falls back to default config when custom config file missing': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      await write(dir, 'index.html', '<h1>Home</h1>');
+      
+      const prev = process.cwd();
+      process.chdir(dir);
+      // Point to non-existent config file
+      const flags = {root: '.', logging: 0, scan: false, config: 'nonexistent.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const response = await httpGet(`http://localhost:${port}/index.html`);
+        if (response.res.statusCode !== 200) {
+          return fail('should fall back to default config and serve HTML');
+        }
+        if (!response.body.toString().includes('<h1>Home</h1>')) {
+          return fail('should serve the file content');
+        }
+        pass('fallback to default config when file missing');
+      } finally {
+        server.close();
+        process.chdir(prev);
+      }
+    });
+  },
+
+  'router handles malformed config file gracefully': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create malformed JSON config
+      await write(dir, 'bad.config.json', '{ invalid json }');
+      await write(dir, 'index.html', '<h1>Home</h1>');
+      
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false, config: 'bad.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const response = await httpGet(`http://localhost:${port}/index.html`);
+        if (response.res.statusCode !== 200) {
+          return fail('should fall back to default config with malformed JSON');
+        }
+        if (!response.body.toString().includes('<h1>Home</h1>')) {
+          return fail('should serve the file content');
+        }
+        pass('graceful handling of malformed config');
+      } finally {
+        server.close();
+        process.chdir(prev);
+      }
+    });
+  },
+
+  'router merges custom config with default config': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      // Create partial config that only overrides some settings
+      const partialConfig = {
+        allowedMimes: {
+          custom: "text/custom"
+        },
+        maxRescanAttempts: 5
+      };
+      await write(dir, 'partial.config.json', JSON.stringify(partialConfig));
+      await write(dir, 'test.js', 'console.log("test");'); // JS should still work from default config
+      await write(dir, 'test.custom', 'custom content');
+      
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false, config: 'partial.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        // Test that default config is still used for JS files
+        const jsResponse = await httpGet(`http://localhost:${port}/test.js`);
+        if (jsResponse.res.statusCode !== 200) {
+          return fail('JS files should still be served from default config');
+        }
+        if (jsResponse.res.headers['content-type'] !== 'application/javascript') {
+          return fail('should use default JS mime type');
+        }
+        
+        // Test that custom config overrides work
+        const customResponse = await httpGet(`http://localhost:${port}/test.custom`);
+        if (customResponse.res.statusCode !== 200) {
+          return fail('custom mime type should work');
+        }
+        if (customResponse.res.headers['content-type'] !== 'text/custom') {
+          return fail('should use custom mime type');
+        }
+        pass('config merging with defaults');
+      } finally {
+        server.close();
+        process.chdir(prev);
+      }
+    });
+  }
+};

package/tests/example-middleware.node-test.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import url from 'url';
-import {createMockReq, createMockRes, expect, setEnv} from './test-utils.js';
+import {createMockReq, createMockRes, setEnv} from './test-utils.js';
 
 // import the middleware module by file path to avoid executing index.js
 const examplePath = path.join(process.cwd(), 'example-middleware.js');
@@ -12,18 +12,18 @@ export default {
       await setEnv({API_KEY: 'abc'}, async () => {
         const res1 = createMockRes();
         await authMiddleware(createMockReq({url:'/private'}), res1, async ()=>{});
-        expect(res1.statusCode === 401, 'should 401 without key');
+        if(res1.statusCode !== 401) return fail('should 401 without key');
 
         const res2 = createMockRes();
         const req2 = createMockReq({headers: {'x-api-key': 'abc'}, url:'/private'});
         let called = false;
         await authMiddleware(req2, res2, async ()=>{ called = true; });
-        expect(called, 'should call next');
-        expect(req2.user && req2.user.authenticated, 'user attached');
+        if(!called) return fail('should call next');
+        if(!(req2.user && req2.user.authenticated)) return fail('user attached');
 
         const res3 = createMockRes();
         await authMiddleware(createMockReq({url:'/public/file'}), res3, async ()=>{});
-        expect(res3.isEnded() === false, 'public should not end');
+        if(res3.isEnded() === true) return fail('public should not end');
       });
       pass('auth middleware');
     } catch(e){ fail(e.message); }

package/tests/getFiles.node-test.js

@@ -1,7 +1,7 @@
 import getFiles from '../getFiles.js';
 import defaultConfig from '../defaultConfig.js';
 import path from 'path';
-import {withTempDir, write, expect, log} from './test-utils.js';
+import {withTempDir, write, log} from './test-utils.js';
 
 export default {
   'scans directories recursively and filters by mime and disallowed': async ({pass, fail}) => {
@@ -14,10 +14,10 @@ export default {
         await write(dir, 'sub/app.js', 'console.log(1)');
   const files = await getFiles(dir, cfg, log);
   const rel = files.map(f => path.relative(dir, f).replace(/\\/g, '/'));
-        expect(rel.includes('index.html'), 'includes html');
-        expect(rel.includes('sub/app.js'), 'includes js');
-  expect(!rel.includes('.env'), 'excludes disallowed');
-        expect(!rel.includes('notes.xyz'), 'excludes unknown ext');
+        if(!rel.includes('index.html')) return fail('includes html');
+        if(!rel.includes('sub/app.js')) return fail('includes js');
+  if(rel.includes('.env')) return fail('excludes disallowed');
+        if(rel.includes('notes.xyz')) return fail('excludes unknown ext');
       });
       pass('scan and filter');
     } catch(e){ fail(e.message); }

package/tests/index.node-test.js

@@ -1,4 +1,4 @@
-import {startNode, expect, randomPort, httpGet, withTempDir, write} from './test-utils.js';
+import {startNode, randomPort, httpGet, withTempDir, write} from './test-utils.js';
 import path from 'path';
 
 export default {
@@ -12,8 +12,8 @@ export default {
   // wait briefly for server to start
   await new Promise(r => setTimeout(r, 400));
         const {res, body} = await httpGet(`http://localhost:${port}/index.html`);
-        expect(res.statusCode === 200, 'server running');
-        expect(body.toString() === 'home', 'served');
+        if(res.statusCode !== 200) return fail('server running');
+        if(body.toString() !== 'home') return fail('served');
   child.kill();
   await new Promise(r => setTimeout(r, 50));
       });

package/tests/middlewareRunner.node-test.js

@@ -1,5 +1,5 @@
 import MiddlewareRunner from '../middlewareRunner.js';
-import {createMockReq, createMockRes, expect} from './test-utils.js';
+import {createMockReq, createMockRes} from './test-utils.js';
 
 export default {
   'runs middleware in order and calls finalHandler': async ({pass, fail}) => {
@@ -11,7 +11,7 @@ export default {
       const req = createMockReq();
       const res = createMockRes();
       await mr.run(req, res, async () => { calls.push('final'); });
-      expect(calls.join(',') === 'a,b,final,b:after,a:after', 'order incorrect');
+      if(calls.join(',') !== 'a,b,final,b:after,a:after') return fail('order incorrect');
       pass('middleware order');
     } catch(e){ fail(e.message); }
   }

package/tests/requestWrapper.node-test.js

@@ -1,4 +1,4 @@
-import {createMockReq, expect} from './test-utils.js';
+import {createMockReq} from './test-utils.js';
 import createRequestWrapper from '../requestWrapper.js';
 
 export default {
@@ -6,9 +6,9 @@ export default {
     try {
       const req = createMockReq({url: '/user/123?x=1&y=2', headers: {host: 'localhost'}});
       const wrapped = createRequestWrapper(req, {id: '123'});
-      expect(wrapped.path === '/user/123', 'path');
-      expect(wrapped.query.x === '1' && wrapped.query.y === '2', 'query');
-      expect(wrapped.params.id === '123', 'params');
+      if(wrapped.path !== '/user/123') return fail('path');
+      if(!(wrapped.query.x === '1' && wrapped.query.y === '2')) return fail('query');
+      if(wrapped.params.id !== '123') return fail('params');
       pass('parsed url');
     } catch(e){ fail(e.message); }
   },
@@ -18,15 +18,15 @@ export default {
       // Each body reader must have its own stream instance
       const reqText = createMockReq({method: 'POST', url: '/', headers: {host: 'x', 'content-type': 'application/json'}, body: JSON.stringify(payload)});
       const text = await createRequestWrapper(reqText).text();
-      expect(text === JSON.stringify(payload), 'text');
+      if(text !== JSON.stringify(payload)) return fail('text');
 
       const reqJson = createMockReq({method: 'POST', url: '/', headers: {host: 'x', 'content-type': 'application/json'}, body: JSON.stringify(payload)});
       const obj = await createRequestWrapper(reqJson).json();
-      expect(obj.a === 1, 'json');
+      if(obj.a !== 1) return fail('json');
 
       const reqBuf = createMockReq({url: '/', headers: {host: 'x'}, body: 'abc'});
       const buf = await createRequestWrapper(reqBuf).buffer();
-      expect(Buffer.isBuffer(buf) && buf.toString() === 'abc', 'buffer');
+      if(!(Buffer.isBuffer(buf) && buf.toString() === 'abc')) return fail('buffer');
       pass('helpers');
     } catch(e){ fail(e.message); }
   },
@@ -43,8 +43,8 @@ export default {
     try {
       const req = createMockReq({url: '/', headers: {'content-type': 'text/plain', host: 'x'}});
       const w = createRequestWrapper(req);
-      expect(w.get('content-type') === 'text/plain', 'get');
-      expect(w.is('text/plain') === true, 'is');
+      if(w.get('content-type') !== 'text/plain') return fail('get');
+      if(w.is('text/plain') !== true) return fail('is');
       pass('header helpers');
     } catch(e){ fail(e.message); }
   }

package/tests/responseWrapper.node-test.js

@@ -1,4 +1,4 @@
-import {createMockRes, expect, parseCookies} from './test-utils.js';
+import {createMockRes, parseCookies} from './test-utils.js';
 import createResponseWrapper from '../responseWrapper.js';
 
 export default {
@@ -7,9 +7,9 @@ export default {
       const res = createMockRes();
       const w = createResponseWrapper(res);
       w.status(201).set('X-Test', '1').type('json');
-      expect(res.statusCode === 201, 'status');
-      expect(res.getHeader('X-Test') === '1', 'set/get');
-      expect(res.getHeader('Content-Type') === 'application/json', 'type');
+      if(res.statusCode !== 201) return fail('status');
+      if(res.getHeader('X-Test') !== '1') return fail('set/get');
+      if(res.getHeader('Content-Type') !== 'application/json') return fail('type');
       pass('status+headers+type');
     } catch(e){ fail(e.message); }
   },
@@ -18,7 +18,7 @@ export default {
       const res = createMockRes();
       const w = createResponseWrapper(res);
       w.json({a: 1});
-      expect(res.isEnded(), 'ended');
+      if(!res.isEnded()) return fail('ended');
       try { w.set('X', 'y'); fail('should not set after send'); } catch(_){ /* ok */ }
       pass('json');
     } catch(e){ fail(e.message); }
@@ -28,22 +28,22 @@ export default {
   const res1 = createMockRes();
   createResponseWrapper(res1).send('hello');
   // Content-Type defaults to text/html for string when not set
-  expect(res1.getHeader('Content-Type') === 'text/html', 'string content-type');
-      expect(res1.getBody().toString() === 'hello', 'string body');
+  if(res1.getHeader('Content-Type') !== 'text/html') return fail('string content-type');
+      if(res1.getBody().toString() !== 'hello') return fail('string body');
 
       const res2 = createMockRes();
       createResponseWrapper(res2).send({a:1});
-      expect(res2.getHeader('Content-Type') === 'application/json', 'object content-type');
+      if(res2.getHeader('Content-Type') !== 'application/json') return fail('object content-type');
 
   const res3 = createMockRes();
   const buf = Buffer.from('abc');
   createResponseWrapper(res3).send(buf);
   const body3 = res3.getBody().toString();
-  expect(body3.includes('"data"'), 'buffer equal');
+  if(!body3.includes('"data"')) return fail('buffer equal');
 
   const res4 = createMockRes();
   createResponseWrapper(res4).send(null);
-  expect(res4.isEnded(), 'null ended');
+  if(!res4.isEnded()) return fail('null ended');
       pass('send variants');
     } catch(e){ fail(e.message); }
   },
@@ -51,11 +51,11 @@ export default {
     try {
       const r1 = createMockRes();
       createResponseWrapper(r1).html('<h1>Ok</h1>');
-      expect(r1.getHeader('Content-Type') === 'text/html', 'html type');
+      if(r1.getHeader('Content-Type') !== 'text/html') return fail('html type');
 
       const r2 = createMockRes();
       createResponseWrapper(r2).text('plain');
-      expect(r2.getHeader('Content-Type') === 'text/plain', 'text type');
+      if(r2.getHeader('Content-Type') !== 'text/plain') return fail('text type');
       pass('helpers');
     } catch(e){ fail(e.message); }
   },
@@ -65,9 +65,9 @@ export default {
       const w = createResponseWrapper(r);
       w.cookie('a', 'b', {httpOnly: true, path: '/'});
       const cookies = parseCookies(r.getHeader('Set-Cookie'));
-      expect(cookies.length === 1 && cookies[0].includes('a=b'), 'cookie added');
+      if(!(cookies.length === 1 && cookies[0].includes('a=b'))) return fail('cookie added');
       w.redirect('/next', 301);
-      expect(r.statusCode === 301 && r.getHeader('Location') === '/next', 'redirect');
+      if(!(r.statusCode === 301 && r.getHeader('Location') === '/next')) return fail('redirect');
       pass('redirect+cookie');
     } catch(e){ fail(e.message); }
   }

package/tests/router-middleware.node-test.js

@@ -1,5 +1,5 @@
 import http from 'http';
-import {withTempDir, write, expect, randomPort} from './test-utils.js';
+import {withTempDir, write, randomPort} from './test-utils.js';
 import router from '../router.js';
 
 export default {
@@ -31,13 +31,13 @@ export default {
               const chunks = []; r.on('data', c => chunks.push(c)); r.on('end', ()=> res({r, body: Buffer.concat(chunks)}));
             });
           });
-          expect(one.r.statusCode === 200, 'first ok');
+          if(one.r.statusCode !== 200) return fail('first ok');
           const two = await new Promise((res)=>{
             get(`http://localhost:${port}/index.html`, r =>{
               const chunks = []; r.on('data', c => chunks.push(c)); r.on('end', ()=> res({r, body: Buffer.concat(chunks)}));
             });
           });
-          expect(two.r.statusCode === 429, 'rate limited');
+          if(two.r.statusCode !== 429) return fail('rate limited');
         } finally { server.close(); process.chdir(prev); }
       });
       pass('router middleware');

package/tests/router.node-test.js

@@ -1,6 +1,6 @@
 import http from 'http';
 import path from 'path';
-import {withTempDir, write, expect, randomPort, httpGet, log} from './test-utils.js';
+import {withTempDir, write, randomPort, httpGet, log} from './test-utils.js';
 import router from '../router.js';
 import defaultConfig from '../defaultConfig.js';
 

package/tests/serveFile.node-test.js

@@ -2,7 +2,7 @@ import serveFile from '../serveFile.js';
 import findFile from '../findFile.js';
 import defaultConfig from '../defaultConfig.js';
 import path from 'path';
-import {createMockReq, createMockRes, withTempDir, write, expect, log} from './test-utils.js';
+import {createMockReq, createMockRes, withTempDir, write, log} from './test-utils.js';
 
 export default {
   'serves static file with correct mime': async ({pass, fail}) => {
@@ -13,9 +13,9 @@ export default {
         const files = [path.join(dir, 'index.html')];
         const res = createMockRes();
         const ok = await serveFile(files, dir, '/index.html', 'GET', cfg, createMockReq(), res, log);
-        expect(ok === true, 'should serve');
-        expect(res.statusCode === 200, 'status');
-        expect(res.getHeader('Content-Type') === 'text/html', 'mime');
+        if(ok !== true) return fail('should serve');
+        if(res.statusCode !== 200) return fail('status');
+        if(res.getHeader('Content-Type') !== 'text/html') return fail('mime');
       });
       pass('static');
     } catch(e){ fail(e.message); }
@@ -28,9 +28,9 @@ export default {
         const files = [path.join(dir, 'api/GET.js')];
         const res = createMockRes();
         const ok = await serveFile(files, dir, '/api', 'GET', cfg, createMockReq(), res, log);
-        expect(ok === true, 'served route');
-        expect(res.statusCode === 201, 'route status');
-        expect(res.getBody().toString().includes('ok'), 'body contains ok');
+        if(ok !== true) return fail('served route');
+        if(res.statusCode !== 201) return fail('route status');
+        if(!res.getBody().toString().includes('ok')) return fail('body contains ok');
       });
       pass('route exec');
     } catch(e){ fail(e.message); }
@@ -43,8 +43,8 @@ export default {
         const files = [path.join(dir, 'api/GET.js')];
         const res = createMockRes();
         const ok = await serveFile(files, dir, '/api', 'GET', cfg, createMockReq(), res, log);
-        expect(ok === true, 'handled');
-        expect(res.statusCode === 500, '500');
+        if(ok !== true) return fail('handled');
+        if(res.statusCode !== 500) return fail('500');
       });
       pass('route no default');
     } catch(e){ fail(e.message); }

package/tests/test-utils.js

@@ -92,10 +92,6 @@ export const setEnv = (pairs, fn) => {
   return fn().finally(restore);
 };
 
-export const expect = (condition, message) => {
-  if(!condition){ throw new Error(message); }
-};
-
 export const toString = (buf) => Buffer.isBuffer(buf) ? buf.toString() : String(buf);
 
 export const gzipSize = async (buf) => {