@kaiko.io/rescript-deser 6.0.1 → 7.0.0-alpha.2

package/rescript.json

@@ -10,16 +10,14 @@
       "type": "dev"
     }
   ],
-  "bs-dependencies": [
-    "@rescript/core"
-  ],
-  "uncurried": true,
   "package-specs": [
     {
-      "module": "esmodule"
+      "module": "esmodule",
+      "in-source": false
     },
     {
-      "module": "commonjs"
+      "module": "commonjs",
+      "in-source": false
     }
   ],
   "warnings": {

package/src/Deser.res

@@ -1,5 +1,3 @@
-open RescriptCore
-
 module FieldValue = {
   type t
   external string: string => t = "%identity"
@@ -7,8 +5,8 @@ module FieldValue = {
   external float: float => t = "%identity"
   external boolean: bool => t = "%identity"
   external array: array<t> => t = "%identity"
-  external object: Dict.t<t> => t = "%identity"
-  external mapping: Dict.t<t> => t = "%identity"
+  external object: dict<t> => t = "%identity"
+  external mapping: dict<t> => t = "%identity"
   external any: 'a => t = "%identity"
   @val external null: t = "undefined"
 
@@ -26,7 +24,7 @@ exception TypeError(string)
 module type Deserializer = {
   type t
   let name: string
-  let fromJSON: Js.Json.t => result<t, string>
+  let fromJSON: JSON.t => result<t, string>
   let checkFieldsSanity: unit => result<unit, string>
 }
 
@@ -39,37 +37,32 @@ module Field = {
     | Float
     | Boolean
     | Array(t)
-    /// These SHOULD strings in ISO format, but we only validate the string
-    /// can be represented in Js.Date without spewing NaN all over the place;
-    /// Js.Date.fromString("xxx") returns an object that is mostly unusable.
+    // These SHOULD strings in ISO format, but we only validate the string
+    // can be represented in Js.Date without spewing NaN all over the place;
+    // Js.Date.fromString("xxx") returns an object that is mostly unusable.
     ///
-    /// We also allow floats and then use Js.Date.fromFloat.
+    // We also allow floats and then use Date.fromTime
     | Date
     | Datetime // alias of Date
-
     | Tuple(array<t>)
     | Object(array<(string, t)>)
     | Optional(t)
     | OptionalWithDefault(t, FieldValue.t)
-    /// An arbitrary mapping from names to other arbitrary fields.  The
-    /// difference with Object, is that you don't know the names of the
-    /// expected entries.
+    // An arbitrary mapping from names to other arbitrary fields.  The
+    // difference with Object, is that you don't know the names of the
+    // expected entries.
     | Mapping(t)
-
     | Deserializer(module(Deserializer))
-
-    /// A specialized Array of deserialized items that ignores unparsable
-    /// items and returns the valid collection.  This saves the user from
-    /// writing 'Array(DefaultWhenInvalid(Optional(Deserializer(module(M)))))'
-    /// and then post-process the list of items with 'Array.keepSome'
+    // A specialized Array of deserialized items that ignores unparsable
+    // items and returns the valid collection.  This saves the user from
+    // writing 'Array(DefaultWhenInvalid(Optional(Deserializer(module(M)))))'
+    // and then post-process the list of items with 'Array.keepSome'
     | Collection(module(Deserializer))
     | DefaultWhenInvalid(t, FieldValue.t)
-
     // FIXME: this is used to add additional restrictions like variadictInt or
     // variadicString; but I find it too type-unsafe.  I might consider having
     // a Constraints for this in the future.
     | Morphism(t, FieldValue.t => FieldValue.t)
-
     | Self
 
   let usingString = (f: string => 'a) => value => value->FieldValue.asString->f->FieldValue.any
@@ -85,7 +78,7 @@ module Field = {
       switch i->fromJs {
       | Some(internalValue) => internalValue
       | None =>
-        raise(TypeError(`This Int(${i->Int.toString}) not a valid value here. Hint: ${hint}`))
+        throw(TypeError(`This Int(${i->Int.toString}) not a valid value here. Hint: ${hint}`))
       }
     }),
   )
@@ -94,7 +87,7 @@ module Field = {
     usingString(i => {
       switch i->fromJs {
       | Some(internalValue) => internalValue
-      | None => raise(TypeError(`This String("${i}") not a valid value here. Hint: ${hint}`))
+      | None => throw(TypeError(`This String("${i}") not a valid value here. Hint: ${hint}`))
       }
     }),
   )
@@ -135,104 +128,98 @@ module Field = {
     | DefaultWhenInvalid(t, _) => `Protected ${t->toString}`
     }
 
-  let _taggedToString = (tagged: Js.Json.tagged_t) => {
+  let _taggedToString = (tagged: JSON.t) => {
     switch tagged {
-    | Js.Json.JSONFalse => "Boolean(false)"
-    | Js.Json.JSONTrue => "Boolean(true)"
-    | Js.Json.JSONNull => "Null"
-    | Js.Json.JSONString(text) => `String("${text}")`
-    | Js.Json.JSONNumber(number) => `Number(${number->Float.toString})`
-    | Js.Json.JSONObject(obj) => `Object(${obj->Js.Json.stringifyAny->Option.getOr("...")})`
-    | Js.Json.JSONArray(array) => `Array(${array->Js.Json.stringifyAny->Option.getOr("...")})`
+    | Boolean(false) => "Boolean(false)"
+    | Boolean(true) => "Boolean(true)"
+    | Null => "Null"
+    | String(text) => `String("${text}")`
+    | Number(number) => `Number(${number->Float.toString})`
+    | Object(obj) => `Object(${obj->JSON.stringifyAny->Option.getOr("...")})`
+    | Array(array) => `Array(${array->JSON.stringifyAny->Option.getOr("...")})`
     }
   }
 
-  let rec extractValue = (
-    values: Dict.t<Js.Json.t>,
-    field: string,
-    shape: t,
-    self: t,
-  ): FieldValue.t => {
+  let rec extractValue = (values: dict<JSON.t>, field: string, shape: t, self: t): FieldValue.t => {
     switch values->Dict.get(field) {
     | Some(value) => value->fromUntagged(shape, self)
     | None =>
       switch shape {
-      | DefaultWhenInvalid(_, _) => Js.Json.null->fromUntagged(shape, self)
-      | Optional(_) => Js.Json.null->fromUntagged(shape, self)
+      | DefaultWhenInvalid(_, _) => JSON.Null->fromUntagged(shape, self)
+      | Optional(_) => JSON.Null->fromUntagged(shape, self)
       | OptionalWithDefault(_, default) => default
-      | _ => raise(TypeError(`Missing non-optional field '${field}'`))
+      | _ => throw(TypeError(`Missing non-optional field '${field}'`))
       }
     }
   }
-  and fromUntagged = (untagged: Js.Json.t, shape: t, self: t): FieldValue.t => {
-    switch (shape, untagged->Js.Json.classify) {
+  and fromUntagged: (JSON.t, t, t) => FieldValue.t = (untagged, shape, self) => {
+    switch (shape, untagged) {
     | (Any, _) => untagged->FieldValue.any
-    | (Literal(expected), Js.Json.JSONString(text)) =>
-      if text == expected {
-        FieldValue.string(text)
-      } else {
-        raise(TypeError(`Expecting literal ${expected}, got ${text}`))
-      }
-    | (String, Js.Json.JSONString(text)) => FieldValue.string(text)
-    | (Int, Js.Json.JSONNumber(number)) => FieldValue.int(number->Float.toInt)
-    | (Float, Js.Json.JSONNumber(number)) => FieldValue.float(number)
-    | (Boolean, Js.Json.JSONTrue) => FieldValue.boolean(true)
-    | (Boolean, Js.Json.JSONFalse) => FieldValue.boolean(false)
-    | (Tuple(bases), Js.Json.JSONArray(items)) => {
+
+    | (Literal(expected), String(text)) if text == expected => FieldValue.string(text)
+    | (Literal(expected), String(text)) =>
+      throw(TypeError(`Expecting literal ${expected}, got ${text}`))
+
+    | (String, String(text)) => FieldValue.string(text)
+
+    | (Int, Number(number)) => FieldValue.int(number->Float.toInt)
+
+    | (Float, Number(number)) => FieldValue.float(number)
+
+    | (Boolean, Boolean(v)) => FieldValue.boolean(v)
+
+    | (Tuple(bases), Array(items)) => {
         let lenbases = bases->Array.length
         let lenitems = items->Array.length
         if lenbases == lenitems {
           let values = Belt.Array.zipBy(items, bases, (i, b) => fromUntagged(i, b, self))
           values->FieldValue.array
         } else {
-          raise(
+          throw(
             TypeError(`Expecting ${lenbases->Int.toString} items, got ${lenitems->Int.toString}`),
           )
         }
       }
 
-    | (Datetime, Js.Json.JSONString(s))
-    | (Date, Js.Json.JSONString(s)) => {
-        let r = Js.Date.fromString(s)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${s}`))
-        }
-        r->FieldValue.any
+    | (Datetime | Date, String(s)) =>
+      let r = Date.fromString(s)
+      if r->Date.getDate->Int.toFloat->Float.isNaN {
+        throw(TypeError(`Invalid date ${s}`))
       }
+      r->FieldValue.any
 
-    | (Datetime, Js.Json.JSONNumber(f))
-    | (Date, Js.Json.JSONNumber(f)) => {
-        let r = Js.Date.fromFloat(f)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${f->Js.Float.toString}`))
-        }
-        r->FieldValue.any
+    | (Datetime | Date, Number(f)) =>
+      let r = Date.fromTime(f)
+      if r->Date.getDate->Int.toFloat->Float.isNaN {
+        throw(TypeError(`Invalid date ${f->Float.toString}`))
       }
+      r->FieldValue.any
 
-    | (Array(shape), Js.Json.JSONArray(items)) =>
+    | (Array(shape), Array(items)) =>
       FieldValue.array(items->Array.map(item => item->fromUntagged(shape, self)))
-    | (Mapping(f), Js.Json.JSONObject(values)) =>
+
+    | (Mapping(f), Object(values)) =>
       values->Dict.mapValues(v => v->fromUntagged(f, self))->FieldValue.mapping
-    | (Object(fields), Js.Json.JSONObject(values)) =>
-      FieldValue.object(
-        fields
-        ->Array.map(((field, shape)) => {
-          let value = switch extractValue(values, field, shape, self) {
-          | value => value
-          | exception TypeError(msg) => raise(TypeError(`Field "${field}": ${msg}`))
-          }
-          (field, value)
-        })
-        ->Dict.fromArray,
-      )
 
-    | (OptionalWithDefault(_, value), Js.Json.JSONNull) => value
+    | (Object(fields), Object(values)) =>
+      fields
+      ->Array.map(((field, shape)) => {
+        let value = switch extractValue(values, field, shape, self) {
+        | value => value
+        | exception TypeError(msg) => throw(TypeError(`Field "${field}": ${msg}`))
+        }
+        (field, value)
+      })
+      ->Dict.fromArray
+      ->FieldValue.object
+
+    | (OptionalWithDefault(_, value), Null) => value
     | (OptionalWithDefault(shape, _), _) => untagged->fromUntagged(shape, self)
-    | (Optional(_), Js.Json.JSONNull) => FieldValue.null
+    | (Optional(_), Null) => FieldValue.null
     | (Optional(shape), _) => untagged->fromUntagged(shape, self)
     | (Morphism(shape, f), _) => untagged->fromUntagged(shape, self)->f->FieldValue.any
 
-    | (Collection(m), Js.Json.JSONArray(items)) => {
+    | (Collection(m), Array(items)) => {
         module M = unpack(m: Deserializer)
         items
         ->Array.map(M.fromJSON)
@@ -252,7 +239,7 @@ module Field = {
         module M = unpack(m: Deserializer)
         switch untagged->M.fromJSON {
         | Ok(res) => res->FieldValue.any
-        | Error(msg) => raise(TypeError(msg))
+        | Error(msg) => throw(TypeError(msg))
         }
       }
 
@@ -260,13 +247,13 @@ module Field = {
       switch untagged->fromUntagged(t, self) {
       | res => res
       | exception TypeError(msg) => {
-          Js.Console.warn2("Detected and ignore (with default): ", msg)
+          Console.warn2("Detected and ignore (with default): ", msg)
           default
         }
       }
     | (Self, _) => untagged->fromUntagged(self, self)
     | (expected, actual) =>
-      raise(TypeError(`Expected ${expected->toString}, but got ${actual->_taggedToString} instead`))
+      throw(TypeError(`Expected ${expected->toString}, but got ${actual->_taggedToString} instead`))
     }
   }
 
@@ -296,21 +283,23 @@ module Field = {
 
     | (Object(fields), optional) =>
       fields
-      ->Array.map(((fieldName, field)) => () =>
-        checkFieldsSanity(`${name}::${fieldName}`, field, optional))
+      ->Array.map(((fieldName, field)) =>
+        () => checkFieldsSanity(`${name}::${fieldName}`, field, optional)
+      )
       ->Array.reduce(Ok([]), (res, nextitem) =>
         res->Result.flatMap(arr => nextitem()->Result.map(i => arr->Array.concat([i])))
       )
       ->Result.map(_ => ())
 
-    /// Mappings and arrays can be empty, so their payloads are
-    /// automatically optional.
+    // Mappings and arrays can be empty, so their payloads are
+    // automatically optional.
     | (Mapping(field), _) | (Array(field), _) => checkFieldsSanity(name, field, true)
 
     | (Tuple(fields), optional) =>
       fields
-      ->Array.mapWithIndex((field, index) => () =>
-        checkFieldsSanity(`${name}[${index->Int.toString}]`, field, optional))
+      ->Array.mapWithIndex((field, index) =>
+        () => checkFieldsSanity(`${name}[${index->Int.toString}]`, field, optional)
+      )
       ->Array.reduce(Ok([]), (res, nextitem) =>
         res->Result.flatMap(arr => nextitem()->Result.map(i => arr->Array.concat([i])))
       )
@@ -342,8 +331,8 @@ module MakeDeserializer = (S: Serializable): (Deserializer with type t = S.t) =>
   ")
   let checkFieldsSanity = () => Field.checkFieldsSanity(name, fields, false)
 
-  @doc("Parse a `Js.Json.t` into `result<t, string>`")
-  let fromJSON = (json: Js.Json.t): result<t, _> => {
+  @doc("Parse a `'a` into `result<t, string>`")
+  let fromJSON: JSON.t => result<t, _> = json => {
     switch json->Field.fromUntagged(fields, fields) {
     | res => Ok(res->_toNativeType)
     | exception TypeError(e) => Error(e)

package/tests/QUnit.res

@@ -48,12 +48,12 @@ type done = unit => unit
 
 @send external async: assertion => done = "async"
 @send external asyncMany: (assertion, int) => done = "async"
-@send external rejects: (assertion, Js.Promise.t<'a>, message) => unit = "rejects"
-@send external rejectsM: (assertion, Js.Promise.t<'a>, message) => unit = "rejects"
+@send external rejects: (assertion, promise<'a>, message) => unit = "rejects"
+@send external rejectsM: (assertion, promise<'a>, message) => unit = "rejects"
 @send
-external rejectMatches: (assertion, Js.Promise.t<'a>, matcher<'a>, message) => unit = "rejects"
+external rejectMatches: (assertion, promise<'a>, matcher<'a>, message) => unit = "rejects"
 @send
-external rejectMatchesM: (assertion, Js.Promise.t<'a>, matcher<'a>, message) => unit = "rejects"
+external rejectMatchesM: (assertion, promise<'a>, matcher<'a>, message) => unit = "rejects"
 @send external timeout: (assertion, int) => unit = "timeout"
 
 // Exceptions

package/tests/index.res

@@ -1,10 +1,9 @@
 open QUnit
-open RescriptCore
 
 module Appointment = {
   type t = {
     note: string,
-    date: Js.Date.t,
+    date: Date.t,
     extra: option<string>,
   }
   module Deserializer = Deser.MakeDeserializer({
@@ -21,7 +20,7 @@ module_("Basic deserializer", _ => {
       %raw(`{"note": "Bicentennial doctor's appointment", "date": "2100-01-01"}`),
       {
         note: "Bicentennial doctor's appointment",
-        date: Js.Date.fromString("2100-01-01"),
+        date: Date.fromString("2100-01-01"),
         extra: None,
       },
     ),
@@ -33,7 +32,7 @@ module_("Basic deserializer", _ => {
     }`),
       {
         note: "Bicentennial doctor's appointment",
-        date: Js.Date.fromString("2100-01-01"),
+        date: Date.fromString("2100-01-01"),
         extra: Some("Don't take your stop-aging pills the night before the appointment"),
       },
     ),
@@ -43,10 +42,10 @@ module_("Basic deserializer", _ => {
     qunit->expect(valid->Array.length)
     valid->Array.forEach(
       ((data, expected)) => {
-        Js.Console.log2("Running sample", data)
+        Console.log2("Running sample", data)
         switch Appointment.Deserializer.fromJSON(data) {
         | Ok(result) => qunit->deepEqual(result, expected, "result == expected")
-        | Error(msg) => Js.Console.error(msg)
+        | Error(msg) => Console.error(msg)
         }
       },
     )
@@ -63,11 +62,11 @@ module_("Basic deserializer", _ => {
     qunit->expect(invalid->Array.length)
     invalid->Array.forEach(
       ((message, data)) => {
-        Js.Console.log3("Running sample", message, data)
+        Console.log3("Running sample", message, data)
         switch Appointment.Deserializer.fromJSON(data) {
-        | Ok(result) => Js.Console.error2("Invalid being accepted: ", result)
+        | Ok(result) => Console.error2("Invalid being accepted: ", result)
         | Error(msg) => {
-            Js.Console.log2("Correctly detected:", msg)
+            Console.log2("Correctly detected:", msg)
             qunit->ok(true, true)
           }
         }
@@ -147,10 +146,10 @@ module_("Recursive deserializer", _ => {
     qunit->expect(valid->Array.length)
     valid->Array.forEach(
       ((data, expected)) => {
-        Js.Console.log2("Running sample", data)
+        Console.log2("Running sample", data)
         switch TrivialTree.Deserializer.fromJSON(data) {
         | Ok(result) => qunit->deepEqual(result, expected, "result == expected")
-        | Error(msg) => Js.Console.error(msg)
+        | Error(msg) => Console.error(msg)
         }
       },
     )
@@ -187,3 +186,27 @@ module_("Recursive deserializer", _ => {
     qunit->deepEqual(data->Ledger.fromJSON->Obj.magic, Ok(expected), "nice ledger")
   })
 })
+
+module_("Type safety limits", _ => {
+  test("ill-defined deserializer can cheat the type system", qunit => {
+    module X = Deser.MakeDeserializer({
+      type t = string
+      let fields = Deser.Field.Array(Int)
+    })
+
+    let data = %raw("[1]")
+    qunit->throws(
+      _ => {
+        let illString = data->X.fromJSON->Result.getOr("")
+        try {
+          Console.info3(__MODULE__, "This will fail with a type error", illString->String.charAt(0))
+        } catch {
+        | e =>
+          Console.error(e)
+          throw(e)
+        }
+      },
+      "Expected: TypeError: illString.charAt is not a function",
+    )
+  })
+})

package/tests/run-tests.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+/**
+ * Automated test runner for rescript-deser using Playwright
+ *
+ * This script starts a Vite dev server, runs QUnit tests in a headless browser,
+ * and reports the results to the console.
+ */
+
+const { chromium } = require('@playwright/test');
+const { spawn } = require('child_process');
+const http = require('http');
+
+const TEST_PORT = process.env.TEST_PORT || 4370;
+const TEST_URL = `http://localhost:${TEST_PORT}`;
+const STARTUP_TIMEOUT = 30000; // 30 seconds for server startup
+const TEST_TIMEOUT = 120000; // 2 minutes for all tests to complete
+
+async function waitForServer(url, timeout) {
+    const start = Date.now();
+
+    while (Date.now() - start < timeout) {
+        try {
+            await new Promise((resolve, reject) => {
+                const req = http.get(url, (res) => {
+                    resolve();
+                });
+                req.on('error', reject);
+                req.setTimeout(1000);
+            });
+            return true;
+        } catch (err) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    }
+
+    throw new Error(`Server did not start within ${timeout}ms`);
+}
+
+async function runTests() {
+    let viteProcess = null;
+    let browser = null;
+    let exitCode = 1;
+
+    try {
+        // Start Vite dev server
+        console.log(`Starting Vite server on port ${TEST_PORT}...`);
+        viteProcess = spawn('npx', ['vite', '--port', String(TEST_PORT), '--strictPort'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env }
+        });
+
+        // Capture server output for debugging
+        viteProcess.stdout.on('data', (data) => {
+            if (process.env.DEBUG) {
+                console.log('[vite]', data.toString());
+            }
+        });
+
+        viteProcess.stderr.on('data', (data) => {
+            if (process.env.DEBUG) {
+                console.error('[vite error]', data.toString());
+            }
+        });
+
+        // Wait for server to be ready
+        console.log('Waiting for server to start...');
+        await waitForServer(TEST_URL, STARTUP_TIMEOUT);
+        console.log('Server is ready!');
+
+        // Launch browser
+        console.log('Launching browser...');
+        browser = await chromium.launch({
+            headless: true,
+        });
+
+        const context = await browser.newContext();
+        const page = await context.newPage();
+
+        // Set up console message handling to show test output
+        page.on('console', msg => {
+            const type = msg.type();
+            if (process.env.DEBUG) {
+                console.log(`[browser ${type}]`, msg.text());
+            }
+        });
+
+        // Navigate to test page
+        console.log(`Navigating to ${TEST_URL}...`);
+        await page.goto(TEST_URL, { waitUntil: 'networkidle' });
+
+        // Wait for QUnit to complete and get results
+        console.log('Running tests...\n');
+        const results = await page.waitForFunction(
+            () => {
+                if (typeof QUnit !== 'undefined' && QUnit.config && QUnit.config.stats) {
+                    const done = QUnit.config.current === null || QUnit.config.current === undefined;
+                    if (done) {
+                        return {
+                            passed: QUnit.config.stats.all - QUnit.config.stats.bad,
+                            failed: QUnit.config.stats.bad,
+                            total: QUnit.config.stats.all,
+                            runtime: QUnit.config.stats.runtime
+                        };
+                    }
+                }
+                return false;
+            },
+            { timeout: TEST_TIMEOUT }
+        );
+
+        const testResults = await results.jsonValue();
+
+        // Print results
+        console.log('========================================');
+        console.log('           Test Results');
+        console.log('========================================');
+        console.log(`Total:   ${testResults.total}`);
+        console.log(`Passed:  ${testResults.passed} ✓`);
+        console.log(`Failed:  ${testResults.failed} ${testResults.failed > 0 ? '✗' : ''}`);
+        console.log(`Runtime: ${testResults.runtime}ms`);
+        console.log('========================================');
+
+        if (testResults.failed > 0) {
+            // Get detailed failure information
+            const failures = await page.evaluate(() => {
+                const failedTests = [];
+                const testItems = document.querySelectorAll('#qunit-tests > li.fail');
+
+                testItems.forEach(item => {
+                    const testName = item.querySelector('.test-name')?.textContent || 'Unknown test';
+                    const moduleName = item.querySelector('.module-name')?.textContent || '';
+                    const assertions = [];
+
+                    item.querySelectorAll('.fail').forEach(assertion => {
+                        const message = assertion.querySelector('.test-message')?.textContent || '';
+                        const expected = assertion.querySelector('.test-expected')?.textContent || '';
+                        const actual = assertion.querySelector('.test-actual')?.textContent || '';
+
+                        assertions.push({ message, expected, actual });
+                    });
+
+                    failedTests.push({ module: moduleName, test: testName, assertions });
+                });
+
+                return failedTests;
+            });
+
+            console.log('\nFailed Tests:');
+            failures.forEach((failure, index) => {
+                console.log(`\n${index + 1}. ${failure.module ? failure.module + ' > ' : ''}${failure.test}`);
+                failure.assertions.forEach(assertion => {
+                    if (assertion.message) console.log(`   ${assertion.message}`);
+                    if (assertion.expected) console.log(`   Expected: ${assertion.expected}`);
+                    if (assertion.actual) console.log(`   Actual: ${assertion.actual}`);
+                });
+            });
+
+            exitCode = 1;
+        } else {
+            console.log('\n✓ All tests passed!');
+            exitCode = 0;
+        }
+
+    } catch (error) {
+        console.error('\n✗ Test run failed:');
+        console.error(error.message);
+        exitCode = 1;
+    } finally {
+        // Cleanup
+        if (browser) {
+            await browser.close();
+        }
+
+        if (viteProcess) {
+            viteProcess.kill('SIGTERM');
+            // Give it a moment to shut down gracefully
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            if (!viteProcess.killed) {
+                viteProcess.kill('SIGKILL');
+            }
+        }
+    }
+
+    process.exit(exitCode);
+}
+
+// Run the tests
+runTests().catch(err => {
+    console.error('Unexpected error:', err);
+    process.exit(1);
+});