@c9up/helix 0.2.3 → 0.2.4

package/dist/runtime/emitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/runtime/emitter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/runtime/emitter.ts"],"names":[],"mappings":"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"}

package/dist/runtime/emitter.js

@@ -1,25 +1,25 @@
 /**
- * Runner events — the Japa `Emitter` surface.
+ * Runner events — the helix `Emitter` surface.
  *
- * Japa's plugin/reporter topology is built on an event emitter: a plugin
+ * helix's plugin/reporter topology is built on an event emitter: a plugin
  * receives `{ config, cliArgs, runner, emitter }` and subscribes to
  * `runner:start`, `suite:start`, `group:start`, `test:start`, … to observe the
  * run. Helix emits the SAME event names with the SAME node shapes
- * (`TestStartNode`, `TestEndNode`, `GroupStartNode`, …) so a Japa reporter or
+ * (`TestStartNode`, `TestEndNode`, `GroupStartNode`, …) so a helix reporter or
  * plugin can be ported without rewriting its listeners.
  *
- * One named deviation from `@japa/core`: `suite:start` / `suite:end` carry the
+ * One named deviation from `helix`: `suite:start` / `suite:end` carry the
  * test FILE name. Helix runs one process per file, so the file is what a
  * worker-side listener can see of a suite.
  *
- * `errors[].error` is the thrown `Error` itself, as in Japa — the emitter runs
+ * `errors[].error` is the thrown `Error` itself, as in helix — the emitter runs
  * in the worker, where the original is still around. Only an error rebuilt from
  * an IPC frame (which can carry data only) degrades to the {@link
  * SerializedError} shape, which keeps the same `name`/`message`/`stack` fields.
  */
 /**
  * A typed event emitter over {@link RunnerEvents}. Deliberately minimal — `on`
- * / `once` / `off` / `emit`, the surface a Japa reporter or plugin uses. A
+ * / `once` / `off` / `emit`, the surface a helix reporter or plugin uses. A
  * throwing listener is reported on stderr and never fails the run.
  */
 export class Emitter {

package/dist/runtime/global-hooks.d.ts

@@ -1,5 +1,5 @@
 /**
- * `runnerHooks` — run ONCE for the whole run, where Japa runs them.
+ * `runnerHooks` — run ONCE for the whole run, where helix runs them.
  *
  * These were running per worker process, which meant a migration in
  * `runnerHooks.setup` ran once per FILE. The reason given was that a resource

package/dist/runtime/global-hooks.js

@@ -1,5 +1,5 @@
 /**
- * `runnerHooks` — run ONCE for the whole run, where Japa runs them.
+ * `runnerHooks` — run ONCE for the whole run, where helix runs them.
  *
  * These were running per worker process, which meant a migration in
  * `runnerHooks.setup` ran once per FILE. The reason given was that a resource

package/dist/runtime/run.d.ts

@@ -14,7 +14,7 @@ export interface TestResult {
     status: "pass" | "fail" | "skip" | "todo";
     durationMs: number;
     error?: SerializedError;
-    /** Lifecycle phase `error` was raised in (Japa `test:end` parity). */
+    /** Lifecycle phase `error` was raised in (`test:end`). */
     errorPhase?: ErrorPhase;
 }
 export interface SuiteResult {
@@ -47,7 +47,7 @@ export interface FileResult {
     durationMs: number;
     /**
      * Full names of the tests marked `.pin()` — only populated under
-     * `--list-pinned`, where Japa collects the files, prints what is pinned, and
+     * `--list-pinned`, where helix collects the files, prints what is pinned, and
      * runs nothing.
      */
     pinned?: string[];
@@ -70,32 +70,32 @@ export interface ExecuteOptions {
      */
     grep?: string;
     /**
-     * Tag filter expressions (Japa `--tags`). A `~`-prefixed tag EXCLUDES (`!` is
+     * Tag filter expressions (`--tags`). A `~`-prefixed tag EXCLUDES (`!` is
      * also accepted). Required tags are OR-ed by default — a test runs when it
      * carries ANY of them — unless {@link ExecuteOptions.matchAll} is set, and
      * never when it carries an excluded tag.
      */
     tags?: string[];
-    /** Require ALL required tags instead of any (Japa `--match-all`). */
+    /** Require ALL required tags instead of any (`--match-all`). */
     matchAll?: boolean;
-    /** Exact test titles to run (Japa `--tests`). A test runs only if its leaf title is listed. */
+    /** Exact test titles to run (`--tests`). A test runs only if its leaf title is listed. */
     tests?: string[];
-    /** Exact group titles to run (Japa `--groups`). A test runs only if its enclosing group is listed. */
+    /** Exact group titles to run (`--groups`). A test runs only if its enclosing group is listed. */
     groups?: string[];
     /**
      * The suite these tests belong to — `ctx.test.options.meta.suite.name` and the
-     * `suite:*` event payloads. Defaults to `"default"`, Japa's implicit suite.
+     * `suite:*` event payloads. Defaults to `"default"`, the implicit suite.
      */
     suite?: string;
     /**
-     * Stop running once a test fails (Japa `--bail`). Everything after the
-     * failure is reported as SKIPPED, not dropped — same as Japa, so the counts
+     * Stop running once a test fails (`--bail`). Everything after the
+     * failure is reported as SKIPPED, not dropped — not dropped, so the counts
      * still add up.
      */
     bail?: boolean;
     /**
-     * How far a bail reaches (Japa `--bail-layer`): `"group"` stops the enclosing
-     * group only, `"suite"` the rest of the file, `"runner"` (Japa's default,
+     * How far a bail reaches (`--bail-layer`): `"group"` stops the enclosing
+     * group only, `"suite"` the rest of the file, `"runner"` (helix's default,
      * spelled `""` on its CLI) the rest of the run — the remaining FILES are
      * dropped by the pool, since helix runs one process per file and cannot skip
      * tests it never collected.
@@ -105,9 +105,9 @@ export interface ExecuteOptions {
 /** The value a {@link SerializedError} was built from, when it is still around. */
 export declare function thrownValue(error: SerializedError): unknown;
 /**
- * The suite a run belongs to (Japa `meta.suite`). Helix runs one process per
+ * The suite a run belongs to (`meta.suite`). Helix runs one process per
  * FILE, so the suite is a name the run carries — `"default"` unless
- * `configure({ suite })` or `--suite` says otherwise, exactly like Japa's
+ * `configure({ suite })` or `--suite` says otherwise, exactly like the
  * implicit suite.
  */
 export interface SuiteIdentity {

package/dist/runtime/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAGN,KAAK,UAAU,EAGf,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAOX,SAAS,EAGT,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,sEAAsE;IACtE,UAAU,CAAC,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC,WAAW,GAAG,UAAU,CAAC,CAAC;IAC1C,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,UAAU,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,MAAM,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACb,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+FAA+F;IAC/F,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,sGAAsG;IACtG,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,EAAE,CAAC;CAC9C;AAmFD,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE3D;AAmQD;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAC;CACb;AAi2BD,wBAAsB,WAAW,CAChC,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC1B,OAAO,CAAC,UAAU,CAAC,CA2HrB"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAGN,KAAK,UAAU,EAGf,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAOX,SAAS,EAGT,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC,WAAW,GAAG,UAAU,CAAC,CAAC;IAC1C,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,UAAU,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,MAAM,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACb,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0FAA0F;IAC1F,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,iGAAiG;IACjG,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,EAAE,CAAC;CAC9C;AAmFD,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE3D;AAmQD;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAC;CACb;AAi2BD,wBAAsB,WAAW,CAChC,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC1B,OAAO,CAAC,UAAU,CAAC,CA2HrB"}

package/dist/runtime/run.js

@@ -20,7 +20,7 @@ function compileTagFilter(tags, matchAll) {
         const t = raw.trim();
         if (!t)
             continue;
-        // `~` is the Japa exclusion prefix; `!` is accepted too (helix legacy) so a
+        // `~` is the helix exclusion prefix; `!` is accepted too (legacy) so a
         // stray `!` never silently becomes an impossible required tag.
         if (t.startsWith("~") || t.startsWith("!"))
             excluded.push(t.slice(1));
@@ -55,7 +55,7 @@ function tagMatches(node, filter) {
         ? filter.required.every((r) => have.has(r))
         : filter.required.some((r) => have.has(r));
 }
-/** Nearest enclosing `test.group(...)` title, for the Japa `--groups` filter. */
+/** Nearest enclosing `test.group(...)` title, for the helix `--groups` filter. */
 function enclosingGroupTitle(node) {
     for (let s = node.parent; s !== undefined; s = s.parent) {
         if (s.isGroup)
@@ -73,7 +73,7 @@ function isInGroups(node, groups) {
  *
  * A result crosses the worker→CLI IPC boundary, so it can only hold plain data.
  * The EMITTER, though, runs in the worker — where the thrown `Error` still
- * exists, and where a Japa reporter or plugin expects `errors[].error` to be an
+ * exists, and where a helix reporter or plugin expects `errors[].error` to be an
  * `Error` instance. A symbol key is invisible to `JSON.stringify` and to
  * `Object.keys`, so the original rides along without ever reaching the frame.
  */
@@ -89,7 +89,7 @@ function withThrown(serialized, thrown) {
     });
     return serialized;
 }
-/** The reason Japa attaches to a test skipped because the run bailed. */
+/** The reason helix attaches to a test skipped because the run bailed. */
 const BAIL_SKIP_REASON = "Skipped due to bail mode";
 function serializeError(err) {
     if (err instanceof AssertionError) {
@@ -159,7 +159,7 @@ function collectHookChain(leaf, type) {
  * run-wide test timeout; `0` on either disables it, which is how a deliberately
  * long boot opts out.
  */
-/** A group hook's return that is a group-scoped cleanup (Japa parity). */
+/** A group hook's return that is a group-scoped cleanup. */
 function isCleanupFn(value) {
     return typeof value === "function";
 }
@@ -167,7 +167,7 @@ function isCleanupFn(value) {
 function asHooks(fns, type) {
     return (fns ?? []).map((fn) => ({ type, fn }));
 }
-/** A `beforeEach` return that is a cleanup callback (Vitest/Japa parity). */
+/** A `beforeEach` return that is a cleanup callback (Vitest parity). */
 function isTestCleanup(value) {
     return typeof value === "function";
 }
@@ -180,11 +180,11 @@ async function callHook(hook, subject, fallbackMs = 0) {
 async function runHooks(hooks, registerCleanups = false, subject, fallbackMs = 0) {
     for (const h of hooks) {
         try {
-            // Japa parity: test hooks receive the Test instance, group hooks the
+            // test hooks receive the Test instance, group hooks the
             // Group instance. Zero-arg hooks simply ignore it.
             const ret = await callHook(h, subject, fallbackMs);
             // A `beforeEach` returning a function registers it as a test-scoped
-            // cleanup (Vitest/Japa parity). Ignored for `afterEach`.
+            // cleanup (Vitest parity). Ignored for `afterEach`.
             if (registerCleanups && isTestCleanup(ret)) {
                 registerTestCleanup(ret);
             }
@@ -255,7 +255,7 @@ function makeTimeoutController(ms, label) {
     };
 }
 /**
- * Whether a test survives the run's filters (Japa's refiner). `--grep` is a
+ * Whether a test survives the run's filters (helix's refiner). `--grep` is a
  * helix extra applied per resolved title, so it lives at the call sites that
  * know the interpolated name rather than here.
  */
@@ -266,7 +266,7 @@ function isFilteredOut(node, ctx) {
         (ctx.onlyActive && !pathLeadsToOnly(node)));
 }
 /**
- * Whether any test under this suite survives the filters — Japa's
+ * Whether any test under this suite survives the filters — helix's
  * `Refiner#isGroupAllowed`: a group announces itself only when it has at least
  * one runnable test, so a fully filtered-out group is invisible to reporters.
  */
@@ -284,20 +284,20 @@ function suiteHasRunnableTest(node, ctx) {
 }
 /**
  * The `meta` bag exposed as `ctx.test.options.meta` and on the test events —
- * Japa's `{ suite, group, fileName, abort }`.
+ * helix's `{ suite, group, fileName, abort }`.
  */
 function testMeta(node, ctx) {
     return {
         suite: ctx.suite,
         group: enclosingGroup(node),
         fileName: ctx.file,
-        // Japa's escape hatch: fail the running test with a given message.
+        // helix's escape hatch: fail the running test with a given message.
         abort: (message) => {
             throw new Error(message);
         },
     };
 }
-/** Nearest enclosing `test.group(...)` instance, if any (Japa `meta.group`). */
+/** Nearest enclosing `test.group(...)` instance, if any (`meta.group`). */
 function enclosingGroup(node) {
     for (let s = node.parent; s !== undefined; s = s.parent) {
         if (s.isGroup)
@@ -307,15 +307,15 @@ function enclosingGroup(node) {
 }
 /**
  * The `test:start` payload for one concrete test (a plain test, or one dataset
- * row). `test:end` is this object plus the outcome — exactly how Japa builds
+ * row). `test:end` is this object plus the outcome — exactly how helix builds
  * the two nodes.
  */
 function buildTestStartNode(node, expandedTitle, ctx, dataset, flags) {
-    // Japa's `TestOptions`, field for field. `title`, `tags`, `timeout`, `meta`,
+    // helix's `TestOptions`, field for field. `title`, `tags`, `timeout`, `meta`,
     // `isPinned` — and, as its `Test` constructor initialises them, `isTodo` and
     // `retries` — always carry a value. The rest appear only when the matching
     // modifier was used, so a reporter reading `"isSkipped" in node` sees what
-    // Japa would show it. Pinned down by the golden tests, which compare the raw
+    // helix would show it. Pinned down by the golden tests, which compare the raw
     // key set of both runners' nodes.
     return {
         title: { original: node.name, expanded: expandedTitle },
@@ -338,19 +338,19 @@ function buildTestStartNode(node, expandedTitle, ctx, dataset, flags) {
 function toEmittedErrors(error, phase) {
     if (error === undefined)
         return [];
-    // Japa types `errors[].error` as `Error`; hand listeners the real one when
+    // helix types `errors[].error` as `Error`; hand listeners the real one when
     // this process still has it, and fall back to the serialized shape for a
     // result that was rebuilt from a frame.
     const thrown = thrownValue(error);
     return [{ phase, error: thrown instanceof Error ? thrown : error }];
 }
 /**
- * Emit the Japa `test:start` / `test:end` pair for a test that never runs a
+ * Emit the helix `test:start` / `test:end` pair for a test that never runs a
  * body — a `todo`, an explicit `.skip()`, or a test whose skip condition threw.
- * Japa announces those through its `DummyRunner`, back-to-back.
+ * helix announces those through its `DummyRunner`, back-to-back.
  *
  * Tests dropped by a FILTER (`--tags`/`--tests`/`--groups`/`--grep`/`.only`)
- * are deliberately NOT emitted: Japa's refiner removes them before they can
+ * are deliberately NOT emitted: helix's refiner removes them before they can
  * announce themselves, so a reporter never hears about them. They still show up
  * as `skip` in {@link FileResult}, which is what the (Vitest-shaped) CLI
  * reporter consumes.
@@ -370,13 +370,13 @@ function emitTestResult(node, result, ctx, dataset) {
 }
 async function runTest(node, parentFullName, ctx) {
     const baseFullName = joinName(parentFullName, node.name);
-    // Filter gates (Japa's refiner). Computed first because a filtered-out test
+    // Filter gates (helix's refiner). Computed first because a filtered-out test
     // emits NOTHING — not even the `test:start`/`test:end` pair a `.skip()` or a
     // `todo` still announces. `grep` is per-name (per row for datasets), so it
     // stays below.
     const filteredOut = isFilteredOut(node, ctx);
     // A dataset test with no body (`test('x').with(rows)` and no `.run(fn)` / no
-    // body in `test`) is a `todo` — same as a bodiless plain test (Japa parity).
+    // body in `test`) is a `todo` — same as a bodiless plain test.
     const datasetTodo = node.datasetFn !== undefined && node.datasetBody === undefined;
     if (node.mode === "todo" || datasetTodo) {
         const r = {
@@ -390,7 +390,7 @@ async function runTest(node, parentFullName, ctx) {
             emitTestResult(node, r, ctx);
         return [r];
     }
-    // Deferred skip condition (Japa: a `skip(fn)` callback — possibly async — is
+    // Deferred skip condition (helix: a `skip(fn)` callback — possibly async — is
     // evaluated here at run time, not eagerly at collection). A throwing
     // condition fails the test rather than silently skipping it.
     let deferredSkip = false;
@@ -415,9 +415,9 @@ async function runTest(node, parentFullName, ctx) {
     }
     // Node-level gates that apply to the whole test (and every dataset row).
     // `grep` is applied per-name below (per row for datasets). A bailed run skips
-    // what is left — Japa marks them `skip`, it does not drop them.
+    // what is left — helix marks them `skip`, it does not drop them.
     const nodeSkipped = node.mode === "skip" || deferredSkip || filteredOut || ctx.bailed;
-    // Japa marks a bailed-over test with `skip(true, "Skipped due to bail mode")`,
+    // helix marks a bailed-over test with `skip(true, "Skipped due to bail mode")`,
     // so the reason travels on the node and reaches `skipReason` on the events.
     // Mirrored here, on the same node, for the same reason.
     if (ctx.bailed && node.reason === undefined)
@@ -430,7 +430,7 @@ async function runTest(node, parentFullName, ctx) {
         return r;
     };
     const grepOut = (fullName) => ctx.grep !== undefined && !ctx.grep.test(fullName);
-    // Dataset expansion (Japa `test(name, fn).with(rows)`): resolve the rows at
+    // Dataset expansion (`test(name, fn).with(rows)`): resolve the rows at
     // run time (awaiting an async source), then run one test per row with an
     // interpolated title. The full resolved dataset is exposed as `ctx.test.dataset`.
     if (node.datasetFn !== undefined) {
@@ -496,7 +496,7 @@ async function runOneTest(node, title, fullName, ctx, dataset, row, datasetNode)
     const perTestRetries = node.retries ?? inheritedEach(node, "eachRetries") ?? ctx.retries;
     const attempts = 1 + Math.max(0, perTestRetries);
     const start = Date.now();
-    // Japa announces the test ONCE, before the first attempt; the retry loop
+    // helix announces the test ONCE, before the first attempt; the retry loop
     // lives inside the start/end pair and only the final attempt is reported.
     const startNode = buildTestStartNode(node, title, ctx, datasetNode, {
         isTodo: false,
@@ -507,7 +507,7 @@ async function runOneTest(node, title, fullName, ctx, dataset, row, datasetNode)
     // afterEach) inside its own per-test frame so cleanups / outcome hooks /
     // assertion counters reset between attempts. Passes on the first success.
     let last;
-    // 1-based number of the attempt that produced `last` (Japa counts the first
+    // 1-based number of the attempt that produced `last` (helix counts the first
     // run as attempt 1), and only reported when the test opted into retries.
     let attemptNumber = 1;
     for (let attempt = 0; attempt < attempts; attempt += 1) {
@@ -549,7 +549,7 @@ async function runAttempt(node, title, fullName, before, after, timeoutMs, retri
     // A re-armable body timeout so `ctx.test.resetTimeout()` can push the deadline.
     const timeoutCtl = makeTimeoutController(timeoutMs, `test "${fullName}"`);
     // The running test's instance — injected as `ctx.test`, passed to the test
-    // hooks (Japa parity), and threaded into the frame so cleanups receive it.
+    // hooks, and threaded into the frame so cleanups receive it.
     const testInstance = {
         title,
         fullName,
@@ -559,8 +559,8 @@ async function runAttempt(node, title, fullName, before, after, timeoutMs, retri
             retries,
             tags: node.tags ?? [],
             isTodo: false,
-            // `test.fails()` — a Japa plugin reads it to know an error was the
-            // point (`@japa/assert` skips its assertion check for such a test).
+            // `test.fails()` — a plugin reads it to know an error was the
+            // point (`helix's assert` skips its assertion check for such a test).
             isFailing: node.failing === true,
             meta,
         },
@@ -573,10 +573,10 @@ async function runAttempt(node, title, fullName, before, after, timeoutMs, retri
     };
     setFrameTest(testInstance);
     // Build the injected context BEFORE the `beforeEach` chain so hooks can reach
-    // it as `$test.context` (Japa parity) — the SAME context flows to the body.
+    // it as `$test.context` — the SAME context flows to the body.
     // Built inside the per-test frame so `ctx.cleanup` / getters bind here.
     const context = buildTestContext(testInstance);
-    // A Japa `Test.executed` hook reads `test.context` — `@japa/assert` validates
+    // A helix `Test.executed` hook reads `test.context` — `helix's assert` validates
     // its assertion count through it after every test.
     setFrameContext(context);
     testInstance.context = context;
@@ -594,7 +594,7 @@ async function runAttempt(node, title, fullName, before, after, timeoutMs, retri
         };
     }
     let testErr;
-    // Which phase produced `testErr` — surfaced on `test:end` (Japa parity).
+    // Which phase produced `testErr` — surfaced on `test:end`.
     let errorPhase;
     // Per-test setup hooks (`test.setup`) run after the group `each.setup` chain,
     // just before the body. A failing setup fails the test without running it.
@@ -606,7 +606,7 @@ async function runAttempt(node, title, fullName, before, after, timeoutMs, retri
     }
     else {
         try {
-            // `done` callback (Japa `waitForDone`): the test completes when the
+            // `done` callback (`waitForDone`): the test completes when the
             // body calls done()/done(error). Built even when unused (harmless).
             let doneResolve = noop;
             let doneReject = noop;
@@ -672,7 +672,7 @@ async function runAttempt(node, title, fullName, before, after, timeoutMs, retri
     // Record the outcome BEFORE the frame's cleanup drain (finally) fires, so
     // `ctx.cleanup((hasError, test) => …)` sees the right `hasError`.
     setFrameOutcome(finalErr !== undefined);
-    // A `Test.executed` hook is a verdict, not a teardown: `@japa/assert`
+    // A `Test.executed` hook is a verdict, not a teardown: `helix's assert`
     // validates `assert.plan(n)` there. Its throw has to reach the result, or a
     // plugin's whole reason for existing passes green.
     const executedErr = await drainTestOutcomeHooks(finalErr !== undefined);
@@ -756,7 +756,7 @@ async function runSuite(node, parentFullName, ctx) {
     if (skipEntire)
         return runSkippedSuite(node, fullName, ctx);
     const hookErrors = [];
-    // The group's instance (Japa parity) passed to group hooks, and cleanups a
+    // The group's instance passed to group hooks, and cleanups a
     // `group.setup()` returns — run in the afterAll phase with `(hadError, group)`.
     // For a `test.group()` this is the SAME object the body received and the call
     // returned (`self === group`); a plain `describe` suite has no group handle,
@@ -766,7 +766,7 @@ async function runSuite(node, parentFullName, ctx) {
         fullName,
     };
     const groupCleanups = [];
-    // A group with no runnable test announces nothing — Japa's refiner drops it
+    // A group with no runnable test announces nothing — helix's refiner drops it
     // before `Group.exec()` runs, so a reporter never sees it.
     const groupFiltered = !suiteHasRunnableTest(node, ctx);
     if (!groupFiltered) {
@@ -786,7 +786,7 @@ async function runSuite(node, parentFullName, ctx) {
     if (!beforeAllFailed) {
         for (const child of node.children) {
             if (child.kind === "test") {
-                // A dataset test expands to one result per row (Japa parity).
+                // A dataset test expands to one result per row.
                 for (const r of await runTest(child, fullName, ctx))
                     children.push(r);
             }
@@ -807,10 +807,10 @@ async function runSuite(node, parentFullName, ctx) {
             title: node.name,
             meta: { suite: ctx.suite, fileName: ctx.file },
             // True when ANYTHING under the group failed — a hook or a test — which
-            // is what Japa's GroupRunner reports.
+            // is what helix's GroupRunner reports.
             hasError: groupHadError || hookErrors.length > 0,
             // The group's own `errors` are its hook failures only; a test's failure
-            // travels on that test's `test:end` (Japa parity).
+            // travels on that test's `test:end`.
             errors: hookErrors.map((error, i) => ({
                 phase: i < setupErrorCount ? "setup" : "teardown",
                 error,
@@ -889,7 +889,7 @@ async function runBeforeAllHooks(node, parentFullName, ctx, hookErrors, group, g
         if (h.type !== "beforeAll")
             continue;
         try {
-            // Japa parity: group hooks receive the Group instance; a returned
+            // group hooks receive the Group instance; a returned
             // function becomes a group-scoped cleanup (run in the afterAll phase).
             const ret = await callHook(h, group, ctx.timeoutMs);
             if (isCleanupFn(ret))
@@ -912,7 +912,7 @@ async function runAfterAllHooks(node, hookErrors, group, groupCleanups, hadError
 /** Run-wide default, used when the hook declares no timeout of its own. */
 fallbackMs = 0) {
     // Group-scoped cleanups (returned by `group.setup()`) run first, in reverse
-    // insertion order, receiving `(hadError, group)` — Japa lifecycle parity.
+    // insertion order, receiving `(hadError, group)` — helix lifecycle parity.
     for (let i = groupCleanups.length - 1; i >= 0; i -= 1) {
         try {
             await groupCleanups[i](hadError, group);
@@ -999,16 +999,16 @@ export async function executeRoot(root, file, options = {}) {
         file,
         suite: { name: options.suite ?? "default" },
         bail: options.bail === true,
-        // Japa spells the runner layer as an empty string on its CLI.
+        // helix spells the runner layer as an empty string on its CLI.
         bailLayer: options.bailLayer === undefined || options.bailLayer === ""
             ? "runner"
             : options.bailLayer,
         bailed: false,
     };
     const suites = [];
-    // Japa's runner/suite frame. Helix has no named-suite layer (one process per
+    // helix's runner/suite frame. Helix has no named-suite layer (one process per
     // file), so the FILE is the suite — `suite:start` carries its name.
-    // Japa skips a suite whose every test is filtered out — the suite never
+    // helix skips a suite whose every test is filtered out — the suite never
     // announces itself, though the runner still opens and closes the run.
     const suiteRunnable = suiteHasRunnableTest(root, ctx);
     emitter.emit("runner:start", {});
@@ -1043,7 +1043,7 @@ export async function executeRoot(root, file, options = {}) {
     if (!rootBeforeAllFailed) {
         for (const child of root.children) {
             if (child.kind === "test") {
-                // A dataset test expands to one result per row (Japa parity).
+                // A dataset test expands to one result per row.
                 const trs = await runTest(child, "", ctx);
                 suites.push({
                     name: "",