qunitx 1.0.2 → 1.0.4

package/README.md

@@ -170,16 +170,29 @@ import { module, test } from 'qunitx';
 
 ---
 
-## Concurrency options
+## QUnit compatibility
 
-`module()` and `test()` accept an optional options object forwarded directly to the underlying
-Node / Deno test runner:
+qunitx follows the same test-environment model as QUnit:
+
+- **Fresh context per test** — each test gets its own `this` object. Writes in one test never bleed into a sibling.
+- **Prototype-chain inheritance** — a parent module's `before()` hook sets properties on the module context. Each test inherits those properties, so reads work naturally (`this.x`) while writes stay local to the test.
+- **`before()` assertions** — attributed to the first test in the module (matching QUnit's attribution model).
+- **`after()` assertions** — attributed to the last test in the module.
+- **Hook ordering** — `before`/`beforeEach` run FIFO; `afterEach`/`after` run LIFO, exactly as in QUnit.
+
+> **Known difference:** In QUnit's browser runner, `before()` hook assertions are attributed to the first test in the *entire subtree* (including nested modules). In the Node/Deno adapters, they are attributed to the first *direct* test of the module. In the common case where direct tests appear before nested modules, the behavior is identical.
+
+---
+
+## Concurrency
+
+Tests run **sequentially by default** — matching QUnit's browser behavior where tests run one at a time. You can enable concurrency by passing options to the underlying Node / Deno runner:
 
 ```js
 import { module, test } from 'qunitx';
 
-// Run tests in this module serially
-module('Serial suite', { concurrency: false }, (hooks) => {
+// Enable parallel execution for this module (Node/Deno only)
+module('Parallel suite', { concurrency: true }, (hooks) => {
   test('first', (assert) => { assert.ok(true); });
   test('second', (assert) => { assert.ok(true); });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -91,8 +91,8 @@
   "devDependencies": {
     "prettier": "^3.8.1",
     "qunit": "^2.25.0",
-    "qunitx": "^0.9.3",
-    "qunitx-cli": "^0.5.0"
+    "qunitx": "^1.0.3",
+    "qunitx-cli": "^0.5.3"
   },
   "volta": {
     "node": "24.14.0"

package/shims/deno/module.js

@@ -1,10 +1,6 @@
 import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
 import ModuleContext from '../shared/module-context.js';
 
-// NOTE: node.js beforeEach & afterEach is buggy because the TestContext it has is NOT correct reference when called, it gets the last context
-// NOTE: QUnit expect() logic is buggy in nested modules
-// NOTE: after gets the last direct children test of the module, not last defined context of a module(last defined context is a module)
-
 /**
  * Defines a test module (suite) for Deno's BDD test runner.
  *
@@ -37,40 +33,31 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
   const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
   const moduleContext = new ModuleContext(moduleName);
 
-  describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, function () {
+  describe(moduleName, { ...targetRuntimeOptions }, function () {
     const beforeHooks = [];
     const afterHooks = [];
 
     beforeAll(async function () {
-      Object.assign(moduleContext.context, moduleContext.moduleChain.reduce((result, module) => {
-        return Object.assign(result, module.context, {
-          steps: result.steps.concat(module.context.steps),
-          expectedAssertionCount: module.context.expectedAssertionCount
-            ? module.context.expectedAssertionCount
-            : result.expectedAssertionCount
-        });
-      }, { steps: [], expectedAssertionCount: undefined }));
+      // before() assertions are attributed to the first direct test only (matching QUnit's model).
+      // Tests inherit parent context via prototype chain, so no Object.assign needed.
+      const firstTest = moduleContext.tests[0];
+      const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
 
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.context, moduleContext.assert);
-      }
-
-      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-        Object.assign(moduleContext.tests[i], moduleContext.context, {
-          steps: moduleContext.context.steps,
-          totalExecutedAssertions: moduleContext.context.totalExecutedAssertions,
-          expectedAssertionCount: moduleContext.context.expectedAssertionCount,
-        });
+        await hook.call(moduleContext.userContext, beforeAssert);
       }
     });
+
     afterAll(async () => {
-      for (const assert of moduleContext.tests.map(testContext => testContext.assert)) {
-        await assert.waitForAsyncOps();
+      for (const testContext of moduleContext.tests) {
+        await testContext.assert.waitForAsyncOps();
       }
 
-      const targetContext = moduleContext.tests[moduleContext.tests.length - 1];
-      for (let j = afterHooks.length - 1; j >= 0; j--) {
-        await afterHooks[j].call(targetContext, targetContext.assert);
+      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      if (lastTest) {
+        for (let j = afterHooks.length - 1; j >= 0; j--) {
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+        }
       }
 
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -78,7 +65,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
       }
     });
 
-    targetModuleContent.call(moduleContext.context, {
+    targetModuleContent.call(moduleContext.userContext, {
       before(beforeFn) {
         beforeHooks[beforeHooks.length] = beforeFn;
       },

package/shims/deno/test.js

@@ -41,25 +41,30 @@ export default function test(testName, runtimeOptions, testContent) {
   const targetTestContent = testContent ? testContent : runtimeOptions;
   const context = new TestContext(testName, moduleContext);
 
-  it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+  // Each test gets a fresh plain object inheriting from the module's user context.
+  // This matches QUnit's prototype-chain model: before() sets props on the module context,
+  // tests inherit them, and each test's own writes don't pollute sibling tests.
+  const userContext = Object.create(moduleContext.userContext);
+  context.userContext = userContext;
+
+  it(testName, { ...targetRuntimeOptions }, async function () {
     for (const module of context.module.moduleChain) {
       for (const hook of module.beforeEachHooks) {
-        await hook.call(context, context.assert);
+        await hook.call(userContext, context.assert);
       }
     }
 
-    const result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
 
     await context.assert.waitForAsyncOps();
 
     for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
       const module = context.module.moduleChain[i];
       for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-        await module.afterEachHooks[j].call(context, context.assert);
+        await module.afterEachHooks[j].call(userContext, context.assert);
       }
     }
 
     return result;
   });
 }
-

package/shims/node/module.js

@@ -1,49 +1,36 @@
 import { describe, before as beforeAll, after as afterAll } from 'node:test';
 import ModuleContext from '../shared/module-context.js';
 
-// NOTE: node.js beforeEach & afterEach is buggy because the TestContext it has is NOT correct reference when called, it gets the last context
-// NOTE: QUnit expect() logic is buggy in nested modules
-// NOTE: after gets the last direct children test of the module, not last defined context of a module(last defined context is a module)
-
 export default function module(moduleName, runtimeOptions, moduleContent) {
   const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
   const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
   const moduleContext = new ModuleContext(moduleName);
 
-  return describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, function () {
+  return describe(moduleName, { ...targetRuntimeOptions }, function () {
     const beforeHooks = [];
     const afterHooks = [];
 
     beforeAll(async function () {
-      Object.assign(moduleContext.context, moduleContext.moduleChain.reduce((result, module) => {
-        return Object.assign(result, module.context, {
-          steps: result.steps.concat(module.context.steps),
-          expectedAssertionCount: module.context.expectedAssertionCount
-            ? module.context.expectedAssertionCount
-            : result.expectedAssertionCount
-        });
-      }, { steps: [], expectedAssertionCount: undefined }));
+      // before() assertions are attributed to the first direct test only (matching QUnit's model).
+      // Tests inherit parent context via prototype chain, so no Object.assign needed.
+      const firstTest = moduleContext.tests[0];
+      const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
 
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.context, moduleContext.assert);
-      }
-
-      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-        Object.assign(moduleContext.tests[i], moduleContext.context, {
-          steps: moduleContext.context.steps,
-          totalExecutedAssertions: moduleContext.context.totalExecutedAssertions,
-          expectedAssertionCount: moduleContext.context.expectedAssertionCount,
-        });
+        await hook.call(moduleContext.userContext, beforeAssert);
       }
     });
+
     afterAll(async () => {
       for (const testContext of moduleContext.tests) {
         await testContext.assert.waitForAsyncOps();
       }
 
-      const targetContext = moduleContext.tests[moduleContext.tests.length - 1];
-      for (let j = afterHooks.length - 1; j >= 0; j--) {
-        await afterHooks[j].call(targetContext, targetContext.assert);
+      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      if (lastTest) {
+        for (let j = afterHooks.length - 1; j >= 0; j--) {
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+        }
       }
 
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -51,7 +38,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
       }
     });
 
-    targetModuleContent.call(moduleContext.context, {
+    targetModuleContent.call(moduleContext.userContext, {
       before(beforeFn) {
         beforeHooks[beforeHooks.length] = beforeFn;
       },

package/shims/node/test.js

@@ -12,25 +12,30 @@ export default function test(testName, runtimeOptions, testContent) {
   const targetTestContent = testContent ? testContent : runtimeOptions;
   const context = new TestContext(testName, moduleContext);
 
-  return it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+  // Each test gets a fresh plain object inheriting from the module's user context.
+  // This matches QUnit's prototype-chain model: before() sets props on the module context,
+  // tests inherit them, and each test's own writes don't pollute sibling tests.
+  const userContext = Object.create(moduleContext.userContext);
+  context.userContext = userContext;
+
+  return it(testName, { ...targetRuntimeOptions }, async function () {
     for (const module of context.module.moduleChain) {
       for (const hook of module.beforeEachHooks) {
-        await hook.call(context, context.assert);
+        await hook.call(userContext, context.assert);
       }
     }
 
-    const result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
 
     await context.assert.waitForAsyncOps();
 
     for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
       const module = context.module.moduleChain[i];
       for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-        await module.afterEachHooks[j].call(context, context.assert);
+        await module.afterEachHooks[j].call(userContext, context.assert);
       }
     }
 
     return result;
   });
 }
-

package/shims/shared/assert.js

@@ -2,10 +2,6 @@ import '../../vendor/qunit.js';
 import { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException } from '../shared/index.js';
 import util from 'node:util';
 
-// More: contexts needed for timeout
-// NOTE: Another approach for a global report Make this._assertions.set(this.currentTest, (this._assertions.get(this.currentTest) || 0) + 1); for pushResult
-// NOTE: This should *always* be a singleton(?), passed around as an argument for hooks. Seems difficult with concurrency. Singleton needs to be a concurrent data structure.
-
 /**
  * The assertion object passed to every test callback and lifecycle hook.
  *

package/shims/shared/module-context.js

@@ -8,6 +8,7 @@ export default class ModuleContext {
     return this.currentModuleChain[this.currentModuleChain.length - 1];
   }
 
+  // Internal fallback assert for modules with no direct tests
   context = new TestContext();
 
   moduleChain = [];
@@ -24,6 +25,10 @@ export default class ModuleContext {
     this.name = parentModule ? `${parentModule.name} > ${name}` : name;
     this.assert = new ModuleContext.Assert(this);
 
+    // User context uses prototype chain from parent module for proper QUnit-style inheritance:
+    // parent before() sets props on parent userContext, child tests inherit via prototype.
+    this.userContext = parentModule ? Object.create(parentModule.userContext) : Object.create(null);
+
     return Object.freeze(this);
   }
 }

package/benches/assert.bench.js

@@ -1,115 +0,0 @@
-// Benchmarks for core assertion methods in shims/shared/assert.js.
-// Measures the hot path that runs for every assertion in every test.
-//
-// Run: deno bench --allow-read benches/assert.bench.js
-
-import '../vendor/qunit.js';
-import Assert from '../shims/shared/assert.js';
-import TestContext from '../shims/shared/test-context.js';
-
-class QXAssertionError extends Error {
-  constructor(obj) {
-    super(obj.message);
-  }
-}
-
-Assert.QUnit = globalThis.QUnit;
-Assert.AssertionError = QXAssertionError;
-TestContext.Assert = Assert;
-
-function makeAssert() {
-  const test = { totalExecutedAssertions: 0, steps: [], asyncOps: [] };
-  return new Assert(null, test);
-}
-
-// --- Truthy / falsy ---
-
-const assertOk = makeAssert();
-Deno.bench('ok - passing', () => {
-  assertOk.ok(true);
-});
-
-const assertNotOk = makeAssert();
-Deno.bench('notOk - passing', () => {
-  assertNotOk.notOk(false);
-});
-
-const assertTrue = makeAssert();
-Deno.bench('true - passing', () => {
-  assertTrue.true(true);
-});
-
-const assertFalse = makeAssert();
-Deno.bench('false - passing', () => {
-  assertFalse.false(false);
-});
-
-// --- Equality ---
-
-const assertEqual = makeAssert();
-Deno.bench('equal - passing', () => {
-  assertEqual.equal(1, 1);
-});
-
-const assertStrictEqual = makeAssert();
-Deno.bench('strictEqual - passing', () => {
-  assertStrictEqual.strictEqual('hello', 'hello');
-});
-
-const assertNotStrictEqual = makeAssert();
-Deno.bench('notStrictEqual - passing', () => {
-  assertNotStrictEqual.notStrictEqual(1, '1');
-});
-
-// --- Deep equality ---
-
-const flatObj = { a: 1, b: 2, c: 3 };
-const assertDeepFlat = makeAssert();
-Deno.bench('deepEqual - flat object', () => {
-  assertDeepFlat.deepEqual({ a: 1, b: 2, c: 3 }, flatObj);
-});
-
-const nestedObj = { a: { b: { c: 1 } }, d: [1, 2, 3] };
-const assertDeepNested = makeAssert();
-Deno.bench('deepEqual - nested object', () => {
-  assertDeepNested.deepEqual({ a: { b: { c: 1 } }, d: [1, 2, 3] }, nestedObj);
-});
-
-// --- Prop equality ---
-
-const assertPropEqual = makeAssert();
-Deno.bench('propEqual - flat object', () => {
-  assertPropEqual.propEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
-});
-
-const assertPropContains = makeAssert();
-Deno.bench('propContains - subset', () => {
-  assertPropContains.propContains({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 });
-});
-
-// --- Base method ---
-
-const assertPushResult = makeAssert();
-Deno.bench('pushResult - passing', () => {
-  assertPushResult.pushResult({ result: true, actual: 1, expected: 1, message: 'ok' });
-});
-
-// --- Step tracking ---
-
-const assertStep = makeAssert();
-Deno.bench('step + verifySteps', () => {
-  assertStep.test.steps = [];
-  assertStep.test.totalExecutedAssertions = 0;
-  assertStep.step('a');
-  assertStep.step('b');
-  assertStep.verifySteps(['a', 'b']);
-});
-
-// --- Exception assertion ---
-
-const assertThrows = makeAssert();
-Deno.bench('throws - passing', () => {
-  assertThrows.throws(() => {
-    throw new Error('boom');
-  });
-});

package/benches/context.bench.js

@@ -1,69 +0,0 @@
-// Benchmarks for TestContext and ModuleContext lifecycle.
-// These objects are created once per test/module, so their construction cost
-// adds directly to suite startup time at scale.
-//
-// Run: deno bench --allow-read benches/context.bench.js
-
-import '../vendor/qunit.js';
-import Assert from '../shims/shared/assert.js';
-import ModuleContext from '../shims/shared/module-context.js';
-import TestContext from '../shims/shared/test-context.js';
-
-class QXAssertionError extends Error {
-  constructor(obj) {
-    super(obj.message);
-  }
-}
-
-Assert.QUnit = globalThis.QUnit;
-Assert.AssertionError = QXAssertionError;
-ModuleContext.Assert = Assert;
-TestContext.Assert = Assert;
-
-// --- ModuleContext ---
-
-Deno.bench('ModuleContext - creation', () => {
-  new ModuleContext('SuiteName');
-  ModuleContext.currentModuleChain.pop();
-});
-
-// --- TestContext ---
-
-// Create a reusable parent module for TestContext benchmarks.
-const parentModule = new ModuleContext('Parent');
-ModuleContext.currentModuleChain.pop();
-
-Deno.bench('TestContext - creation', () => {
-  new TestContext('test name', parentModule);
-  parentModule.tests.pop();
-});
-
-// --- finish() ---
-
-// finish() runs after every test to validate assertion counts & steps.
-// Three paths: at-least-one assertion (fast path), zero assertions (fail), expect mismatch.
-
-function makeFinishableTest(expectedCount) {
-  const ctx = new TestContext('test', parentModule);
-  parentModule.tests.pop();
-  ctx.totalExecutedAssertions = 1;
-  if (expectedCount !== undefined) ctx.expectedAssertionCount = expectedCount;
-  return ctx;
-}
-
-const ctxFinishOk = makeFinishableTest();
-Deno.bench('TestContext - finish (1 assertion, no expect)', () => {
-  // Reset state so it doesn't accumulate across iterations.
-  ctxFinishOk.totalExecutedAssertions = 1;
-  ctxFinishOk.steps = [];
-  ctxFinishOk.expectedAssertionCount = undefined;
-  ctxFinishOk.finish();
-});
-
-const ctxFinishExpect = makeFinishableTest(1);
-Deno.bench('TestContext - finish (expect matches)', () => {
-  ctxFinishExpect.totalExecutedAssertions = 1;
-  ctxFinishExpect.steps = [];
-  ctxFinishExpect.expectedAssertionCount = 1;
-  ctxFinishExpect.finish();
-});

package/benches/results.json

@@ -1,35 +0,0 @@
-{
-  "ok - passing": 6.122285937882127,
-  "notOk - passing": 6.052994656027081,
-  "true - passing": 5.893691627414019,
-  "false - passing": 5.552377309526456,
-  "equal - passing": 6.067946223784695,
-  "strictEqual - passing": 5.416006859987021,
-  "notStrictEqual - passing": 5.483480087623222,
-  "deepEqual - flat object": 718.5170962962962,
-  "deepEqual - nested object": 2024.6826599999997,
-  "propEqual - flat object": 1080.7499910714284,
-  "propContains - subset": 1024.682773333333,
-  "pushResult - passing": 5.657819905052545,
-  "step + verifySteps": 407.4118619402984,
-  "throws - passing": 8620,
-  "ModuleContext - creation": 204.09858320312497,
-  "TestContext - creation": 45.03426628010711,
-  "TestContext - finish (1 assertion, no expect)": 16.970750253807086,
-  "TestContext - finish (expect matches)": 15.684375773679301,
-  "objectType - number": 36.452910065170144,
-  "objectType - string": 51.122222345803905,
-  "objectType - null": 5.467147286229134,
-  "objectType - plain object": 55.7791819184124,
-  "objectType - array": 46.39228097426468,
-  "objectType - Date": 188.61341527272734,
-  "objectType - RegExp": 60.643142703349355,
-  "objectValues - flat object (3 keys)": 146.51978607954544,
-  "objectValues - nested object": 403.55127537313405,
-  "objectValues - array (5 items)": 568.6339551020407,
-  "objectValuesSubset - 2 of 4 keys": 102.92081955645169,
-  "validateException - no expected (always passes)": 5.627593457733817,
-  "validateException - regexp match": 748.3865025641023,
-  "validateException - constructor (instanceof)": 63.09276811955177,
-  "validateException - function validator": 71.31606100981766
-}

package/benches/utils.bench.js

@@ -1,91 +0,0 @@
-// Benchmarks for shared utility functions in shims/shared/index.js.
-// These are called on every propEqual, propContains, throws, and rejects call.
-//
-// Run: deno bench --allow-read benches/utils.bench.js
-
-import {
-  objectType,
-  objectValues,
-  objectValuesSubset,
-  validateException,
-} from '../shims/shared/index.js';
-
-// --- objectType ---
-// Called in validateExpectedExceptionArgs and validateException on every
-// throws/rejects assertion, and internally in objectValues.
-
-Deno.bench('objectType - number', () => {
-  objectType(42);
-});
-
-Deno.bench('objectType - string', () => {
-  objectType('hello');
-});
-
-Deno.bench('objectType - null', () => {
-  objectType(null);
-});
-
-Deno.bench('objectType - plain object', () => {
-  objectType({});
-});
-
-Deno.bench('objectType - array', () => {
-  objectType([]);
-});
-
-Deno.bench('objectType - Date', () => {
-  objectType(new Date());
-});
-
-Deno.bench('objectType - RegExp', () => {
-  objectType(/foo/);
-});
-
-// --- objectValues ---
-// Called on every propEqual / propContains invocation to clone own props.
-
-const flatObj = { a: 1, b: 2, c: 3 };
-Deno.bench('objectValues - flat object (3 keys)', () => {
-  objectValues(flatObj);
-});
-
-const nestedObj = { a: { b: 1, c: { d: 2 } }, e: 3 };
-Deno.bench('objectValues - nested object', () => {
-  objectValues(nestedObj);
-});
-
-const arrayObj = [1, 2, 3, 4, 5];
-Deno.bench('objectValues - array (5 items)', () => {
-  objectValues(arrayObj);
-});
-
-// --- objectValuesSubset ---
-// Called on every propContains / notPropContains.
-
-const fullObj = { a: 1, b: 2, c: 3, d: 4 };
-const model = { a: 1, b: 2 };
-Deno.bench('objectValuesSubset - 2 of 4 keys', () => {
-  objectValuesSubset(fullObj, model);
-});
-
-// --- validateException ---
-// Called on every throws / rejects assertion after the error is caught.
-
-const err = new TypeError('bad value');
-
-Deno.bench('validateException - no expected (always passes)', () => {
-  validateException(err, undefined, 'message');
-});
-
-Deno.bench('validateException - regexp match', () => {
-  validateException(err, /bad value/, 'message');
-});
-
-Deno.bench('validateException - constructor (instanceof)', () => {
-  validateException(err, TypeError, 'message');
-});
-
-Deno.bench('validateException - function validator', () => {
-  validateException(err, (e) => e instanceof TypeError, 'message');
-});

package/scripts/check-benchmarks.js

@@ -1,88 +0,0 @@
-#!/usr/bin/env -S deno run --allow-read --allow-write --allow-env
-// Regression checker for qunitx benchmarks.
-//
-// Usage:
-//   # Check against saved baseline (fails if any result regresses > threshold):
-//   deno bench --allow-read --json benches/*.bench.js | deno run --allow-read --allow-write --allow-env scripts/check-benchmarks.js
-//
-//   # Save current results as new baseline:
-//   deno bench --allow-read --json benches/*.bench.js | deno run --allow-read --allow-write --allow-env scripts/check-benchmarks.js --save
-
-import { red, green, yellow, dim } from 'jsr:@std/fmt/colors';
-
-const BASELINE_PATH = new URL('../benches/results.json', import.meta.url).pathname;
-const REGRESSION_THRESHOLD = Number(Deno.env.get('REGRESSION_THRESHOLD') ?? '20');
-const isSave = Deno.args.includes('--save');
-
-const raw = await new Response(Deno.stdin.readable).text();
-const data = JSON.parse(raw);
-
-// Flatten results: name → avg nanoseconds
-const current = {};
-for (const bench of data.benches) {
-  const ok = bench.results?.[0]?.ok;
-  if (ok) {
-    current[bench.name] = ok.avg;
-  }
-}
-
-if (isSave) {
-  await Deno.writeTextFile(BASELINE_PATH, JSON.stringify(current, null, 2) + '\n');
-  console.log(`Saved baseline → benches/results.json (${Object.keys(current).length} entries)`);
-  Deno.exit(0);
-}
-
-let baseline;
-try {
-  baseline = JSON.parse(await Deno.readTextFile(BASELINE_PATH));
-} catch {
-  console.log('No baseline found. Run with --save to create one.');
-  Deno.exit(0);
-}
-
-function fmt(ns) {
-  if (ns >= 1e9) return `${(ns / 1e9).toFixed(2)}s`;
-  if (ns >= 1e6) return `${(ns / 1e6).toFixed(2)}ms`;
-  if (ns >= 1e3) return `${(ns / 1e3).toFixed(2)}µs`;
-  return `${ns.toFixed(2)}ns`;
-}
-
-let hasRegression = false;
-const rows = [];
-
-for (const [name, avgNs] of Object.entries(current)) {
-  const baseNs = baseline[name];
-  if (baseNs == null) {
-    rows.push({ name, avgNs, status: 'new' });
-    continue;
-  }
-  const pct = ((avgNs - baseNs) / baseNs) * 100;
-  if (pct > REGRESSION_THRESHOLD) hasRegression = true;
-  rows.push({ name, avgNs, baseNs, pct, status: pct > REGRESSION_THRESHOLD ? 'fail' : 'ok' });
-}
-
-const maxName = Math.max(...rows.map((r) => r.name.length));
-
-for (const row of rows) {
-  const pad = row.name.padEnd(maxName);
-  if (row.status === 'new') {
-    console.log(`  ${yellow('NEW ')} ${pad}  ${fmt(row.avgNs)}`);
-  } else if (row.status === 'fail') {
-    console.log(
-      `  ${red('FAIL')} ${pad}  ${fmt(row.avgNs)}  ${red(`+${row.pct.toFixed(1)}%`)} vs ${dim(fmt(row.baseNs))}`
-    );
-  } else {
-    const sign = row.pct >= 0 ? '+' : '';
-    const pctStr = `${sign}${row.pct.toFixed(1)}%`;
-    console.log(
-      `  ${green('OK  ')} ${pad}  ${fmt(row.avgNs)}  ${row.pct < -5 ? green(pctStr) : dim(pctStr)} vs ${dim(fmt(row.baseNs))}`
-    );
-  }
-}
-
-if (hasRegression) {
-  console.error(`\n${red(`Regressions detected (threshold: ${REGRESSION_THRESHOLD}%)`)}`);
-  Deno.exit(1);
-} else {
-  console.log(`\n${green(`All benchmarks within threshold (${REGRESSION_THRESHOLD}%)`)}`);
-}

package/scripts/check-coverage.js

@@ -1,15 +0,0 @@
-import { readFile } from 'node:fs/promises';
-
-const THRESHOLD = 85;
-const lcov = await readFile('tmp/coverage/lcov.info', 'utf8');
-
-const lh = [...lcov.matchAll(/^LH:(\d+)/gm)].reduce((s, m) => s + parseInt(m[1]), 0);
-const lf = [...lcov.matchAll(/^LF:(\d+)/gm)].reduce((s, m) => s + parseInt(m[1]), 0);
-const pct = lf > 0 ? (lh / lf) * 100 : 0;
-
-console.log(`Coverage: ${pct.toFixed(1)}% (${lh}/${lf} lines)`);
-
-if (pct < THRESHOLD) {
-  console.error(`Error: coverage ${pct.toFixed(1)}% is below the ${THRESHOLD}% threshold.`);
-  process.exit(1);
-}