kempo-testing-framework 1.1.0 → 1.2.1

package/index.js

@@ -10,7 +10,8 @@ const shortFlagMap = {
     'd': 'delay',
     'p': 'port',
     'g': 'gui',
-    'w': 'show-browser'
+    'w': 'show-browser',
+    'h': 'help'
 };
 
 /*
@@ -22,7 +23,7 @@ const remainingArgs = [];
 
 // Define which flags take values vs booleans
 const valueFlags = new Set(['log-level', 'delay', 'port']);
-const booleanFlags = new Set(['browser', 'node', 'gui', 'show-browser']);
+const booleanFlags = new Set(['browser', 'node', 'gui', 'show-browser', 'help']);
 
 for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -108,6 +109,41 @@ if (Object.prototype.hasOwnProperty.call(flags, 'log-level')) {
     delete flags['log-level'];
 }
 
+/*
+ * Help Display
+ */
+if (flags.help || flags.h) {
+    console.log(`
+Kempo Testing Framework
+
+USAGE:
+  kempo-test [OPTIONS] [SUITE_FILTER] [TEST_FILTER]
+
+OPTIONS:
+  -h, --help              Show this help message and exit
+  -b, --browser           Run only browser tests
+  -n, --node              Run only node tests
+  -l, --log-level LEVEL   Set log level (0-4 or silent/minimal/normal/verbose/debug)
+  -d, --delay MS          Add delay between tests in milliseconds
+  -p, --port PORT         Set port for test server (default: 3000)
+  -g, --gui               Launch GUI mode
+  -w, --show-browser      Show browser window during tests
+
+ARGUMENTS:
+  SUITE_FILTER           Filter test suites by name
+  TEST_FILTER            Filter individual tests by name
+
+EXAMPLES:
+  kempo-test                    # Run all tests
+  kempo-test --browser          # Run only browser tests
+  kempo-test -l verbose         # Run with verbose logging
+  kempo-test --gui              # Launch GUI mode
+  kempo-test myComponent        # Run tests for 'myComponent' suite
+  kempo-test myComponent myTest # Run specific test in specific suite
+`);
+    process.exit(0);
+}
+
 /*
  * Mode Selection and Execution
  */
@@ -115,8 +151,6 @@ if (flags.gui) {
     const { default: gui } = await import('./src/gui.js');
     await gui(flags, remainingArgs);
 } else {
-    // Log flags to verify capture
-    console.log('kempo-test flags:', flags);
     const { default: cli } = await import('./src/cli.js');
     await cli(flags, remainingArgs);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kempo-testing-framework",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "The Kempo Testing Framework is a simple testing framework built on the principle that code intended to be ran in the browser should be tested in the browser, code intended to be ran in Node should be tested in Node, and code intended to be ran in both should be tested in both. No mocking, no complexity—just testing.",
   "main": "index.js",
   "bin": {

package/src/findTests.js

@@ -1,34 +1,40 @@
-import fs from 'fs/promises';
-import path from 'path';
-
-const findFiles = async (dir, filter = '') => {
-  const results = [];
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const entryPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...await findFiles(entryPath, filter));
-    } else if(
-      entry.isFile() &&
-      entry.name.endsWith('test.js') &&
-      path.relative(process.cwd(), entryPath).includes(filter)
-    ){
-      // Normalize path to always use forward slashes for consistency across platforms
-      const relativePath = path.relative(process.cwd(), entryPath).replace(/\\/g, '/');
-      results.push(relativePath);
-    }
-  }
-  return results;
-};
-
-export default async (suiteFilter, testFilter, browser = true, node = true) => {
-  const files = await findFiles(process.cwd(), suiteFilter);
-  
-  const nodeTests = files.filter(file => (file.endsWith('.test.js') || file.endsWith('.node-test.js')) && node);
-  const browserTests = files.filter(file => (file.endsWith('.test.js') || file.endsWith('.browser-test.js')) && browser);
-  
-  return {
-    nodeTests,
-    browserTests
-  };
-};
+import fs from 'fs/promises';
+import path from 'path';
+
+const findFiles = async (testDirs, filter = '') => {
+  const results = [];
+  
+  for (const dir of testDirs) {
+    try {
+      await fs.access(dir);
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        if (entry.isFile() && 
+            entry.name.endsWith('test.js') &&
+            entry.name.includes(filter)) {
+          const entryPath = path.join(dir, entry.name);
+          // Normalize path to always use forward slashes for consistency across platforms
+          const relativePath = path.relative(process.cwd(), entryPath).replace(/\\/g, '/');
+          results.push(relativePath);
+        }
+      }
+    } catch (error) {
+      // Directory doesn't exist, skip it
+    }
+  }
+  return results;
+};
+
+export default async (suiteFilter, testFilter, browser = true, node = true) => {
+  const testDirectories = ['tests', 'test']; // Only look in these directories
+  const files = await findFiles(testDirectories, suiteFilter);
+  
+  const nodeTests = files.filter(file => (file.endsWith('.test.js') || file.endsWith('.node-test.js')) && node);
+  const browserTests = files.filter(file => (file.endsWith('.test.js') || file.endsWith('.browser-test.js')) && browser);
+  
+  return {
+    nodeTests,
+    browserTests
+  };
+};

package/src/gui.js

@@ -1,249 +1,249 @@
-import http from 'http';
-import { readFile } from 'fs/promises';
-import { fileURLToPath } from 'url';
-import path from 'path';
-import { exec } from 'child_process';
-import { platform } from 'os';
-import findTests from './findTests.js';
-import runTestFiles from './runTestFiles.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export default async (flags, args) => {
-  const server = http.createServer(async (req, res) => {
-    const basePath = req.url.split('?')[0];
-    
-    /*
-      Custom API Endpoints
-    */
-    
-    /* 
-      Serve essential.css
-    */
-    if(basePath === '/essential.css'){
-      res.writeHead(200, { 'Content-Type': 'text/css' });
-      res.end(await readFile(path.join(__dirname, '../node_modules/essentialcss/dist/essential.min.css'), 'utf8'));
-    } 
-    
-    /*
-      Get list of all test files with their test names
-    */
-    else if(basePath === '/testFiles'){
-      try {
-        const testFiles = await findTests('', '', true, true);
-        
-        // Extract test names from Node test files (safe to import in Node.js)
-        const nodeTestsWithNames = await Promise.all(
-          testFiles.nodeTests.map(async file => {
-            try {
-              // Convert forward slashes back to OS-specific path separators for import
-              const normalizedFile = file.replace(/\//g, path.sep);
-              const module = await import(`file://${path.resolve(process.cwd(), normalizedFile)}`);
-              const testNames = module.default ? Object.keys(module.default) : [];
-              return { file, testNames };
-            } catch (error) {
-              console.error(`Error loading Node test file ${file}:`, error);
-              return { file, testNames: [], error: error.message };
-            }
-          })
-        );
-
-        // Browser tests just return file names (test names will be extracted client-side)
-        const browserTestsWithNames = testFiles.browserTests.map(file => ({ file, testNames: null }));
-
-        const result = {
-          nodeTests: nodeTestsWithNames,
-          browserTests: browserTestsWithNames
-        };
-
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(result));
-      } catch (error) {
-        console.error('Error finding test files:', error);
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Failed to find test files' }));
-      }
-    } 
-    
-    /*
-      Serve test files as ES modules for dynamic imports
-    */
-    else if(basePath.startsWith('/test/')){
-      // URL format: /test/path/to/testfile.js
-      const testPath = basePath.substring(6); // Remove '/test/' prefix
-      
-      try {
-        // Convert forward slashes back to OS-specific path separators for file reading
-        const normalizedFile = testPath.replace(/\//g, path.sep);
-        const filePath = path.resolve(process.cwd(), normalizedFile);
-        
-        // Security check: ensure the file is within the project directory
-        if (!filePath.startsWith(process.cwd())) {
-          res.writeHead(403, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Access denied' }));
-          return;
-        }
-        
-        const fileContent = await readFile(filePath, 'utf8');
-        res.writeHead(200, { 'Content-Type': 'application/javascript' });
-        res.end(fileContent);
-      } catch (error) {
-        console.error(`Error reading test file ${testPath}:`, error);
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Test file not found' }));
-      }
-    } 
-
-    /*
-      Run a testFile
-    */
-    else if(basePath == '/runTest'){
-      const url = new URL(req.url, `http://${req.headers.host}`);
-      const testFile = url.searchParams.get('testFile');
-      const testNamesParam = url.searchParams.get('testNames');
-      const testNames = testNamesParam ? testNamesParam.split(',') : [];
-      const showBrowserParam = url.searchParams.get('showBrowser');
-      const showBrowser = showBrowserParam === 'true';
-     const delayMs = Math.max(0, parseInt(url.searchParams.get('delayMs')||'0', 10) || 0);
-
-      try {
-        // Determine if this is a browser or node test based on file extension
-        const isBrowserTest = testFile.endsWith('.browser-test.js');
-        const isNodeTest = testFile.endsWith('.node-test.js');
-        
-        if (!isBrowserTest && !isNodeTest) {
-          res.writeHead(400, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Unknown test file type' }));
-          return;
-        }
-
-        // Run the specific test file using the specificFiles parameter
-        const { nodeResults, browserResults } = await runTestFiles({
-          testFilter: (testNames && testNames.length === 1) ? testNames[0] : '',
-          shouldRunBrowser: isBrowserTest,
-          shouldRunNode: isNodeTest,
-          showBrowser, // pass through from query
-          port: 3001,
-          logLevel: 2,
-          delayMs,
-          specificFiles: [testFile]
-        });
-
-        // Return the results for the specific test file
-        const results = isBrowserTest ? browserResults : nodeResults;
-        const fileResults = results[testFile] || { tests: {} };
-        
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          testFile,
-          testNames,
-          results: fileResults
-        }));
-      } catch (error) {
-        console.error(`Error running test file ${testFile}:`, error);
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Failed to run test file', details: error.message }));
-      }
-    }
-
-    /*
-      Return 404 for common browser requests that we don't need to handle
-    */
-    else if(['/favicon.ico', '/.well-known/appspecific/com.chrome.devtools.json'].includes(basePath)){
-      res.writeHead(404);
-      res.end('');
-    } 
-    
-    // Serve static files from the gui directory (HTML, JS, CSS, images, etc.)
-    else {
-      // Serve static files from gui directory
-      try {
-        let filePath;
-        
-        // If requesting root, serve index.html
-        if (basePath === '/') {
-          filePath = path.join(__dirname, '../gui/index.html');
-        } else {
-          // Remove leading slash and serve from gui directory
-          const requestedFile = basePath.substring(1);
-          filePath = path.join(__dirname, '../gui', requestedFile);
-        }
-        
-        // Security check: ensure the resolved path is within the gui directory
-        const guiDir = path.resolve(__dirname, '../gui');
-        const resolvedPath = path.resolve(filePath);
-        if (!resolvedPath.startsWith(guiDir)) {
-          res.writeHead(403, { 'Content-Type': 'text/plain' });
-          res.end('Access denied');
-          return;
-        }
-        
-        /*
-          Static File Content Type Mapping
-        */
-        const ext = path.extname(filePath).toLowerCase();
-        let contentType = 'text/plain';
-        switch (ext) {
-          case '.html': contentType = 'text/html'; break;
-          case '.js': contentType = 'application/javascript'; break;
-          case '.css': contentType = 'text/css'; break;
-          case '.json': contentType = 'application/json'; break;
-          case '.png': contentType = 'image/png'; break;
-          case '.jpg': case '.jpeg': contentType = 'image/jpeg'; break;
-          case '.svg': contentType = 'image/svg+xml'; break;
-        }
-        
-        const fileContent = await readFile(filePath, ext === '.png' || ext === '.jpg' || ext === '.jpeg' ? null : 'utf8');
-        res.writeHead(200, { 'Content-Type': contentType });
-        res.end(fileContent);
-      } catch (error) {
-        res.writeHead(404, { 'Content-Type': 'text/plain' });
-        res.end('File not found');
-      }
-    }
-  });
-  
-  /*
-    Server Startup and Browser Launch
-  */
-  const port = flags['gui-port'] || 4000;
-  server.listen(port);
-  const startUrl = `http://localhost:${port}`;
-  console.log(`Server running at ${startUrl}`);
-  
-  // Show platform-specific instructions for stopping the server
-  const platformName = platform();
-  const stopKey = platformName === 'darwin' ? 'Cmd+C' : 'Ctrl+C';
-  console.log(`Press ${stopKey} to stop the testing ui`);
-  
-  const openBrowser = url => {
-    const platformName = platform();
-    let command;
-    
-    switch(platformName){
-      case 'win32':
-        command = `start ${url}`;
-        break;
-      case 'darwin':
-        command = `open ${url}`;
-        break;
-      case 'linux':
-        command = `xdg-open ${url}`;
-        break;
-      default:
-        console.log(`Unable to open browser automatically on this platform: ${platformName}`);
-        console.log(`Please manually open your browser and navigate to: ${url}`);
-        return;
-    }
-    
-    exec(command, error => {
-      if (error) {
-        console.log(`Failed to open browser: ${error.message}`);
-        console.log(`Please manually open your browser and navigate to: ${url}`);
-      }
-    });
-  };
-  
-  openBrowser(startUrl);
-};
+import http from 'http';
+import { readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { exec } from 'child_process';
+import { platform } from 'os';
+import findTests from './findTests.js';
+import runTestFiles from './runTestFiles.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default async (flags, args) => {
+  const server = http.createServer(async (req, res) => {
+    const basePath = req.url.split('?')[0];
+    
+    /*
+      Custom API Endpoints
+    */
+    
+    /* 
+      Serve essential.css
+    */
+    if(basePath === '/essential.css'){
+      res.writeHead(200, { 'Content-Type': 'text/css' });
+      res.end(await readFile(path.join(__dirname, '../node_modules/essentialcss/dist/essential.min.css'), 'utf8'));
+    } 
+    
+    /*
+      Get list of all test files with their test names
+    */
+    else if(basePath === '/testFiles'){
+      try {
+        const testFiles = await findTests('', '', true, true);
+        
+        // Extract test names from Node test files (safe to import in Node.js)
+        const nodeTestsWithNames = await Promise.all(
+          testFiles.nodeTests.map(async file => {
+            try {
+              // Convert forward slashes back to OS-specific path separators for import
+              const normalizedFile = file.replace(/\//g, path.sep);
+              const module = await import(`file://${path.resolve(process.cwd(), normalizedFile)}`);
+              const testNames = module.default ? Object.keys(module.default) : [];
+              return { file, testNames };
+            } catch (error) {
+              console.error(`Error loading Node test file ${file}:`, error);
+              return { file, testNames: [], error: error.message };
+            }
+          })
+        );
+
+        // Browser tests just return file names (test names will be extracted client-side)
+        const browserTestsWithNames = testFiles.browserTests.map(file => ({ file, testNames: null }));
+
+        const result = {
+          nodeTests: nodeTestsWithNames,
+          browserTests: browserTestsWithNames
+        };
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result));
+      } catch (error) {
+        console.error('Error finding test files:', error);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Failed to find test files' }));
+      }
+    } 
+    
+    /*
+      Serve test files as ES modules for dynamic imports
+    */
+    else if(basePath.startsWith('/test/')){
+      // URL format: /test/path/to/testfile.js
+      const testPath = basePath.substring(6); // Remove '/test/' prefix
+      
+      try {
+        // Convert forward slashes back to OS-specific path separators for file reading
+        const normalizedFile = testPath.replace(/\//g, path.sep);
+        const filePath = path.resolve(process.cwd(), normalizedFile);
+        
+        // Security check: ensure the file is within the project directory
+        if (!filePath.startsWith(process.cwd())) {
+          res.writeHead(403, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Access denied' }));
+          return;
+        }
+        
+        const fileContent = await readFile(filePath, 'utf8');
+        res.writeHead(200, { 'Content-Type': 'application/javascript' });
+        res.end(fileContent);
+      } catch (error) {
+        console.error(`Error reading test file ${testPath}:`, error);
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Test file not found' }));
+      }
+    } 
+
+    /*
+      Run a testFile
+    */
+    else if(basePath == '/runTest'){
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const testFile = url.searchParams.get('testFile');
+      const testNamesParam = url.searchParams.get('testNames');
+      const testNames = testNamesParam ? testNamesParam.split(',') : [];
+      const showBrowserParam = url.searchParams.get('showBrowser');
+      const showBrowser = showBrowserParam === 'true';
+     const delayMs = Math.max(0, parseInt(url.searchParams.get('delayMs')||'0', 10) || 0);
+
+      try {
+        // Determine if this is a browser or node test based on file extension
+        const isBrowserTest = testFile.endsWith('.browser-test.js') || testFile.endsWith('.test.js');
+        const isNodeTest = testFile.endsWith('.node-test.js') || testFile.endsWith('.test.js');
+        
+        if (!isBrowserTest && !isNodeTest) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Unknown test file type' }));
+          return;
+        }
+
+        // Run the specific test file using the specificFiles parameter
+        const { nodeResults, browserResults } = await runTestFiles({
+          testFilter: (testNames && testNames.length === 1) ? testNames[0] : '',
+          shouldRunBrowser: isBrowserTest,
+          shouldRunNode: isNodeTest,
+          showBrowser, // pass through from query
+          port: 3001,
+          logLevel: 2,
+          delayMs,
+          specificFiles: [testFile]
+        });
+
+        // Return the results for the specific test file
+        const results = isBrowserTest ? browserResults : nodeResults;
+        const fileResults = results[testFile] || { tests: {} };
+        
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          testFile,
+          testNames,
+          results: fileResults
+        }));
+      } catch (error) {
+        console.error(`Error running test file ${testFile}:`, error);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Failed to run test file', details: error.message }));
+      }
+    }
+
+    /*
+      Return 404 for common browser requests that we don't need to handle
+    */
+    else if(['/favicon.ico', '/.well-known/appspecific/com.chrome.devtools.json'].includes(basePath)){
+      res.writeHead(404);
+      res.end('');
+    } 
+    
+    // Serve static files from the gui directory (HTML, JS, CSS, images, etc.)
+    else {
+      // Serve static files from gui directory
+      try {
+        let filePath;
+        
+        // If requesting root, serve index.html
+        if (basePath === '/') {
+          filePath = path.join(__dirname, '../gui/index.html');
+        } else {
+          // Remove leading slash and serve from gui directory
+          const requestedFile = basePath.substring(1);
+          filePath = path.join(__dirname, '../gui', requestedFile);
+        }
+        
+        // Security check: ensure the resolved path is within the gui directory
+        const guiDir = path.resolve(__dirname, '../gui');
+        const resolvedPath = path.resolve(filePath);
+        if (!resolvedPath.startsWith(guiDir)) {
+          res.writeHead(403, { 'Content-Type': 'text/plain' });
+          res.end('Access denied');
+          return;
+        }
+        
+        /*
+          Static File Content Type Mapping
+        */
+        const ext = path.extname(filePath).toLowerCase();
+        let contentType = 'text/plain';
+        switch (ext) {
+          case '.html': contentType = 'text/html'; break;
+          case '.js': contentType = 'application/javascript'; break;
+          case '.css': contentType = 'text/css'; break;
+          case '.json': contentType = 'application/json'; break;
+          case '.png': contentType = 'image/png'; break;
+          case '.jpg': case '.jpeg': contentType = 'image/jpeg'; break;
+          case '.svg': contentType = 'image/svg+xml'; break;
+        }
+        
+        const fileContent = await readFile(filePath, ext === '.png' || ext === '.jpg' || ext === '.jpeg' ? null : 'utf8');
+        res.writeHead(200, { 'Content-Type': contentType });
+        res.end(fileContent);
+      } catch (error) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('File not found');
+      }
+    }
+  });
+  
+  /*
+    Server Startup and Browser Launch
+  */
+  const port = flags['gui-port'] || 4000;
+  server.listen(port);
+  const startUrl = `http://localhost:${port}`;
+  console.log(`Server running at ${startUrl}`);
+  
+  // Show platform-specific instructions for stopping the server
+  const platformName = platform();
+  const stopKey = platformName === 'darwin' ? 'Cmd+C' : 'Ctrl+C';
+  console.log(`Press ${stopKey} to stop the testing ui`);
+  
+  const openBrowser = url => {
+    const platformName = platform();
+    let command;
+    
+    switch(platformName){
+      case 'win32':
+        command = `start ${url}`;
+        break;
+      case 'darwin':
+        command = `open ${url}`;
+        break;
+      case 'linux':
+        command = `xdg-open ${url}`;
+        break;
+      default:
+        console.log(`Unable to open browser automatically on this platform: ${platformName}`);
+        console.log(`Please manually open your browser and navigate to: ${url}`);
+        return;
+    }
+    
+    exec(command, error => {
+      if (error) {
+        console.log(`Failed to open browser: ${error.message}`);
+        console.log(`Please manually open your browser and navigate to: ${url}`);
+      }
+    });
+  };
+  
+  openBrowser(startUrl);
+};

package/src/runBrowserTests.js

@@ -45,9 +45,25 @@ export default async ({
       await sleep(delayMs);
     }
 
-  await page.goto(`${url}?testFile=${testFile}&testFilter=${filter}&delay=${delayMs}`);
-  await page.waitForFunction(() => document.readyState === 'complete' || document.readyState === 'interactive');
-  await page.waitForFunction(() => window.results !== undefined);
+    await page.goto(`${url}?testFile=${testFile}&testFilter=${filter}&delay=${delayMs}`);
+    await page.waitForFunction(() => document.readyState === 'complete' || document.readyState === 'interactive');
+    
+    // Ensure the test page has focus when browser is visible
+    if (showBrowser) {
+      await page.bringToFront();
+      if (logLevel >= LOG_LEVELS.VERBOSE) {
+        console.log(`\x1b[90m Bringing test page to front\x1b[0m`);
+      }
+    }
+    
+    // Check for any errors first
+    const hasError = await page.evaluate(() => window.error !== undefined);
+    if (hasError) {
+      const error = await page.evaluate(() => window.error);
+      throw new Error(`Browser test error: ${error}`);
+    }
+    
+    await page.waitForFunction(() => window.results !== undefined, { timeout: 20000 });
     const results = await page.evaluate(() => window.results);
 
     // Optional post-delay when a visible browser is requested

package/test.html

@@ -8,16 +8,24 @@
 <body>
   <script type="module">
     import runTests from './runTests.js';
-    const urlParams = new URLSearchParams(window.location.search);
-    const testFile = urlParams.get('testFile');
-    const testFilter = urlParams.get('testFilter');
-    const delay = parseInt(urlParams.get('delay') || '0', 10) || 0;
-    if(!testFile){
-      throw new Error('No test file provided');
-    }
-    const testsModule = await import(`/${testFile}`);
-    const results = await runTests(testsModule, testFilter, delay);
-    window.results = results;
+    
+    (async () => {
+      try {
+        const urlParams = new URLSearchParams(window.location.search);
+        const testFile = urlParams.get('testFile');
+        const testFilter = urlParams.get('testFilter');
+        const delay = parseInt(urlParams.get('delay') || '0', 10) || 0;
+        if(!testFile){
+          throw new Error('No test file provided');
+        }
+        const testsModule = await import(`/${testFile}`);
+        const results = await runTests(testsModule, testFilter, delay);
+        window.results = results;
+      } catch (error) {
+        console.error('Browser test error:', error);
+        window.error = error.message || String(error);
+      }
+    })();
   </script>
 </body>
 </html>

package/tests/cli-help.node-test.js

@@ -0,0 +1,61 @@
+import { spawn } from 'child_process';
+
+const runWithHelp = (args, timeoutMs = 3000) => new Promise((resolve) => {
+  const child = spawn(process.execPath, ['index.js', ...args], {
+    cwd: process.cwd(),
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  let out = '';
+  let resolved = false;
+
+  const finish = () => {
+    if (resolved) return;
+    resolved = true;
+    try { child.kill('SIGTERM'); } catch {}
+    resolve(out);
+  };
+
+  child.stdout.on('data', (chunk) => {
+    out += chunk.toString();
+    // Help should exit quickly, check for help content
+    if (out.includes('Kempo Testing Framework') && out.includes('USAGE:')) {
+      setTimeout(finish, 50);
+    }
+  });
+  child.stderr.on('data', (chunk) => { out += chunk.toString(); });
+  child.on('error', () => finish());
+  child.on('exit', () => finish());
+
+  setTimeout(finish, timeoutMs);
+});
+
+export default {
+  '--help shows help message and exits': async ({ pass, fail }) => {
+    const out = await runWithHelp(['--help']);
+    const hasHelp = out.includes('Kempo Testing Framework') && 
+                   out.includes('USAGE:') && 
+                   out.includes('OPTIONS:') &&
+                   out.includes('--help');
+    const noTestRun = !out.includes('kempo-test flags:') && !out.includes('Test Summary');
+    
+    if (hasHelp && noTestRun) {
+      pass('--help shows help message and exits without running tests');
+    } else {
+      fail(`Help output incorrect:\nHas help: ${hasHelp}\nNo test run: ${noTestRun}\nOutput:\n${out}`);
+    }
+  },
+  '-h shows help message and exits': async ({ pass, fail }) => {
+    const out = await runWithHelp(['-h']);
+    const hasHelp = out.includes('Kempo Testing Framework') && 
+                   out.includes('USAGE:') && 
+                   out.includes('OPTIONS:') &&
+                   out.includes('--help');
+    const noTestRun = !out.includes('kempo-test flags:') && !out.includes('Test Summary');
+    
+    if (hasHelp && noTestRun) {
+      pass('-h shows help message and exits without running tests');
+    } else {
+      fail(`Help output incorrect:\nHas help: ${hasHelp}\nNo test run: ${noTestRun}\nOutput:\n${out}`);
+    }
+  }
+};

package/tests/src-runBrowserTests.node-test.js

@@ -23,17 +23,17 @@ export default {
     try {
       // Use a single test to avoid between-test delays dominating timings
       const filter = 'Counter component should be defined';
-      const delay = 1000;
+      const delay = 500; // Reduced from 1000ms to avoid timeouts
       const start1 = Date.now();
       await runBrowserTests({ testFile: 'tests/counter.browser-test.js', filter, showBrowser: false, port: 3112, logLevel: 2, delayMs: delay });
       const t1 = Date.now() - start1;
       const start2 = Date.now();
       await runBrowserTests({ testFile: 'tests/counter.browser-test.js', filter, showBrowser: true, port: 3113, logLevel: 2, delayMs: delay });
       const t2 = Date.now() - start2;
-      // Headful should incur roughly +2000ms (pre+post). Allow slack for env variance.
-    log(`Timing — headless=${t1}ms, headful=${t2}ms, delta=${t2 - t1}ms`);
-    if (t2 - t1 >= 1500) pass('Headful mode applied pre/post delay as expected');
-    else fail(`Timing not increased as expected: headless=${t1}ms headful=${t2}ms`);
+      // Headful should incur roughly +1000ms (pre+post). Allow slack for env variance.
+      log(`Timing — headless=${t1}ms, headful=${t2}ms, delta=${t2 - t1}ms`);
+      if (t2 - t1 >= 800) pass('Headful mode applied pre/post delay as expected');
+      else fail(`Timing not increased as expected: headless=${t1}ms headful=${t2}ms`);
     } catch (e) {
       fail(e.stack || String(e));
     }