@c9up/helix 0.1.8 → 0.1.9

package/dist/runtime/bootstrap.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `tests/bootstrap.ts` — the AdonisJS bootstrap module.
+ *
+ * Adonis puts the run's plugins, runner hooks and suite hooks in one file that
+ * `bin/test.ts` imports before anything else:
+ *
+ *     // tests/bootstrap.ts
+ *     export const plugins = [assert(), apiClient()]
+ *     export const runnerHooks = { setup: [() => …], teardown: [() => …] }
+ *     export const configureSuite = (suite) => {
+ *       if (["functional", "e2e"].includes(suite.name)) {
+ *         return suite.setup(() => testUtils.httpServer().start())
+ *       }
+ *     }
+ *
+ * helix loads the same file with the same three exports — plus `filters` and
+ * `importer`, the two Japa `Config` fields Adonis sets in `bin/test.ts`, which
+ * helix has no equivalent of — so an Adonis `tests/bootstrap.ts` ports over
+ * unchanged. The CLI resolves it once and
+ * forwards the absolute path as `HELIX_BOOTSTRAP`, so it reaches the worker
+ * through BOTH orchestrators (the Rust engine and the TS pool spawn children
+ * that inherit the CLI's env).
+ *
+ * `runnerHooks` run ONCE for the whole run, in the process that spawns the
+ * workers — Japa's semantics. See `global-hooks.ts`. Everything else here is
+ * per worker because it has to be: a context macro, a filter, an importer only
+ * mean anything in the process that loads the test file.
+ */
+/** File names probed under the project root when none is configured. */
+export declare const BOOTSTRAP_FILENAMES: string[];
+/**
+ * Resolve the bootstrap file for `root`: an explicit path (from
+ * `helix.config`), else the conventional `tests/bootstrap.*`. Returns
+ * `undefined` when the project has none — having no bootstrap is the norm, not
+ * an error.
+ */
+export declare function resolveBootstrap(root: string, configured?: string): string | undefined;
+/**
+ * Import the bootstrap module named by `HELIX_BOOTSTRAP` and hand its exports
+ * to {@link configure}. A no-op when the variable is unset — which is what
+ * every project without a bootstrap file, and every direct `runTestFile`
+ * caller, sees.
+ */
+export declare function loadBootstrap(suite: string): Promise<void>;
+/** Test seam: forget that a bootstrap was loaded in this process. */
+export declare function resetBootstrap(): void;
+//# sourceMappingURL=bootstrap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/runtime/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAeH,wEAAwE;AACxE,eAAO,MAAM,mBAAmB,UAI/B,CAAC;AAuEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAYpB;AAKD;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAShE;AAgCD,qEAAqE;AACrE,wBAAgB,cAAc,IAAI,IAAI,CAGrC"}

package/dist/runtime/bootstrap.js

@@ -0,0 +1,166 @@
+/**
+ * `tests/bootstrap.ts` — the AdonisJS bootstrap module.
+ *
+ * Adonis puts the run's plugins, runner hooks and suite hooks in one file that
+ * `bin/test.ts` imports before anything else:
+ *
+ *     // tests/bootstrap.ts
+ *     export const plugins = [assert(), apiClient()]
+ *     export const runnerHooks = { setup: [() => …], teardown: [() => …] }
+ *     export const configureSuite = (suite) => {
+ *       if (["functional", "e2e"].includes(suite.name)) {
+ *         return suite.setup(() => testUtils.httpServer().start())
+ *       }
+ *     }
+ *
+ * helix loads the same file with the same three exports — plus `filters` and
+ * `importer`, the two Japa `Config` fields Adonis sets in `bin/test.ts`, which
+ * helix has no equivalent of — so an Adonis `tests/bootstrap.ts` ports over
+ * unchanged. The CLI resolves it once and
+ * forwards the absolute path as `HELIX_BOOTSTRAP`, so it reaches the worker
+ * through BOTH orchestrators (the Rust engine and the TS pool spawn children
+ * that inherit the CLI's env).
+ *
+ * `runnerHooks` run ONCE for the whole run, in the process that spawns the
+ * workers — Japa's semantics. See `global-hooks.ts`. Everything else here is
+ * per worker because it has to be: a context macro, a filter, an importer only
+ * mean anything in the process that loads the test file.
+ */
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { configure, } from "./configure.js";
+import { globalHooksHandledByParent } from "./global-hooks.js";
+import { applySuiteConfigure } from "./suite-config.js";
+import { resetTaps } from "./suite-taps.js";
+/** File names probed under the project root when none is configured. */
+export const BOOTSTRAP_FILENAMES = [
+    "tests/bootstrap.ts",
+    "tests/bootstrap.js",
+    "tests/bootstrap.mjs",
+];
+/** `filters` as exported — every field optional, so read each defensively. */
+function readFilters(imported) {
+    const source = Reflect.get(Object(imported), "filters");
+    if (source === null || typeof source !== "object")
+        return undefined;
+    const matchAll = Reflect.get(source, "matchAll");
+    return {
+        tags: stringList(source, "tags"),
+        groups: stringList(source, "groups"),
+        tests: stringList(source, "tests"),
+        matchAll: typeof matchAll === "boolean" ? matchAll : undefined,
+    };
+}
+function stringList(source, key) {
+    const value = Reflect.get(source, key);
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((v) => typeof v === "string");
+}
+/** Everything about the module is optional — read defensively, never cast. */
+function readModule(imported) {
+    if (imported === null || typeof imported !== "object")
+        return {};
+    const plugins = Reflect.get(imported, "plugins");
+    const hooks = Reflect.get(imported, "runnerHooks");
+    const configureSuite = Reflect.get(imported, "configureSuite");
+    const importer = Reflect.get(imported, "importer");
+    return {
+        filters: readFilters(imported),
+        importer: typeof importer === "function"
+            ? (file) => importer(file)
+            : undefined,
+        plugins: Array.isArray(plugins)
+            ? plugins.filter((p) => typeof p === "function")
+            : undefined,
+        runnerHooks: hooks !== null && typeof hooks === "object"
+            ? {
+                setup: hookList(hooks, "setup"),
+                teardown: hookList(hooks, "teardown"),
+            }
+            : undefined,
+        configureSuite: typeof configureSuite === "function"
+            ? (suite) => configureSuite(suite)
+            : undefined,
+    };
+}
+function hookList(source, key) {
+    const value = Reflect.get(source, key);
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((fn) => typeof fn === "function");
+}
+/**
+ * Resolve the bootstrap file for `root`: an explicit path (from
+ * `helix.config`), else the conventional `tests/bootstrap.*`. Returns
+ * `undefined` when the project has none — having no bootstrap is the norm, not
+ * an error.
+ */
+export function resolveBootstrap(root, configured) {
+    if (configured !== undefined && configured !== "") {
+        const absolute = path.isAbsolute(configured)
+            ? configured
+            : path.resolve(root, configured);
+        return existsSync(absolute) ? absolute : undefined;
+    }
+    for (const name of BOOTSTRAP_FILENAMES) {
+        const candidate = path.resolve(root, name);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/** Memoised so a worker that runs several files bootstraps exactly once. */
+let loaded;
+/**
+ * Import the bootstrap module named by `HELIX_BOOTSTRAP` and hand its exports
+ * to {@link configure}. A no-op when the variable is unset — which is what
+ * every project without a bootstrap file, and every direct `runTestFile`
+ * caller, sees.
+ */
+export async function loadBootstrap(suite) {
+    const file = process.env.HELIX_BOOTSTRAP;
+    const hasSuiteConfig = (process.env.HELIX_SUITE_CONFIG ?? "") !== "";
+    // The suite's own `configure` is applied here too, so it reaches the same
+    // hook arrays before `configure()` drains them. That means this runs even
+    // with no bootstrap file — a project may declare one without the other.
+    if ((file === undefined || file === "") && !hasSuiteConfig)
+        return;
+    loaded ??= applyBootstrap(file ?? "", suite);
+    return loaded;
+}
+async function applyBootstrap(file, suite) {
+    const module = file === "" ? {} : readModule(await import(pathToFileURL(file).href));
+    // `runnerHooks` belong to the run, not to this file. When the parent ran
+    // them — which it does whenever a bootstrap exists — the worker must not run
+    // them again: that is the difference between migrating once and migrating
+    // once per test file.
+    const parentRanThem = globalHooksHandledByParent();
+    const setup = parentRanThem ? [] : [...(module.runnerHooks?.setup ?? [])];
+    const teardown = parentRanThem
+        ? []
+        : [...(module.runnerHooks?.teardown ?? [])];
+    // `configureSuite` is handed to `configure()` rather than called here, so it
+    // runs where Japa runs it: after the plugins, which is what lets a plugin
+    // read it or replace it. The per-suite callback chains onto it — both get
+    // the same handle, so hooks either registers reach the arrays below.
+    await configure({
+        plugins: module.plugins,
+        filters: module.filters,
+        importer: module.importer,
+        configureSuite: async (handle) => {
+            module.configureSuite?.(handle);
+            await applySuiteConfigure(suite, handle);
+        },
+        setup,
+        teardown,
+        suite,
+    });
+}
+/** Test seam: forget that a bootstrap was loaded in this process. */
+export function resetBootstrap() {
+    loaded = undefined;
+    resetTaps();
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/runtime/bootstrap.js.map

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

package/dist/runtime/cli-args.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The run's command-line arguments, as seen from inside a worker.
+ *
+ * `bin/helix.js` parses the flags in the CLI process and forwards them to every
+ * worker through the environment (`HELIX_TAGS`, `HELIX_TESTS`, …), because a
+ * worker is spawned by either orchestrator (Node pool or the Rust engine) with
+ * a fixed instruction shape. Reading them back here is what lets both the
+ * runtime and a plugin (`api.cliArgs`, Japa parity) see the same filters.
+ *
+ * One named deviation from Japa's `CLIArgs`: values are parsed (`string[]`,
+ * `number`, `boolean`) rather than kept as raw CLI strings. They have been
+ * through the parser once already, on the CLI side, and handing a plugin
+ * `"500"` to re-parse would be worse — Japa's own raw form exists because its
+ * CLI hands the config manager unparsed argv, which helix's does not.
+ */
+/** Parsed CLI flags for the current run. */
+export interface CLIArgs {
+    /** Positionals — the paths or suite names typed on the command line. */
+    _?: string[];
+    /** `--list-pinned` — collect and print the pinned tests, run nothing. */
+    listPinned?: boolean;
+    /** `--tags` — `~@tag`/`!@tag` entries exclude. */
+    tags?: string[];
+    /** `--tests` — exact test titles. */
+    tests?: string[];
+    /** `--groups` — exact group titles. */
+    groups?: string[];
+    /** `--match-all` — require every `--tags` entry instead of any. */
+    matchAll?: boolean;
+    /** `--timeout`, in ms. */
+    timeout?: number;
+    /** `--retries` — extra attempts on failure. */
+    retries?: number;
+    /** `--grep` — helix extra: regex/substring over the full test name. */
+    grep?: string;
+    /** `--suite` — the suite name these files belong to. */
+    suite?: string;
+    /** `--files` — substrings matched against the test file path (Japa `--files`). */
+    files?: string[];
+    /** `--reporters` — the reporters activated for this run. */
+    reporters?: string[];
+    /** `--bail` — stop at the first failure. */
+    bail?: boolean;
+    /** `--bail-layer` — how far a bail reaches. */
+    bailLayer?: string;
+    /** `--failed` — this run replays the previous run's failures. */
+    failed?: boolean;
+    /** `--force-exit` — the CLI will `process.exit()` once the run ends. */
+    forceExit?: boolean;
+    /**
+     * `--help`. Always absent in a worker: the CLI prints its help and exits
+     * before spawning anything, so nothing here could ever have seen it. Declared
+     * for the same reason Japa declares it — a plugin reading `cliArgs.help`
+     * should get `undefined`, not a type error.
+     */
+    help?: boolean;
+    /**
+     * Japa's open record. A host that forwards its own `HELIX_*` variable, or a
+     * plugin that stashes something for another, has somewhere to put it without
+     * the type standing in the way.
+     */
+    [flag: string]: string | string[] | number | boolean | undefined;
+}
+/** Comma-separated env list → trimmed non-empty entries, or undefined. */
+export declare function envList(name: string): string[] | undefined;
+/** A non-negative integer env var, or undefined when unset/invalid. */
+export declare function envCount(name: string): number | undefined;
+/** `--tags` as forwarded by the CLI. */
+export declare function envTags(): string[] | undefined;
+/** `--match-all` as forwarded by the CLI. */
+export declare function envMatchAll(): boolean | undefined;
+export declare function cliArgs(): CLIArgs;
+/** Test seam: rebuild from the environment on the next access. */
+export declare function resetCLIArgs(): void;
+/** Every CLI flag the current worker can see, read fresh from the environment. */
+export declare function readCLIArgs(): CLIArgs;
+//# sourceMappingURL=cli-args.d.ts.map

package/dist/runtime/cli-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-args.d.ts","sourceRoot":"","sources":["../../src/runtime/cli-args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,4CAA4C;AAC5C,MAAM,WAAW,OAAO;IACvB,wEAAwE;IACxE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IACb,yEAAyE;IACzE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0BAA0B;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACjE;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAQ1D;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKzD;AAED,wCAAwC;AACxC,wBAAgB,OAAO,IAAI,MAAM,EAAE,GAAG,SAAS,CAE9C;AAED,6CAA6C;AAC7C,wBAAgB,WAAW,IAAI,OAAO,GAAG,SAAS,CAEjD;AAiBD,wBAAgB,OAAO,IAAI,OAAO,CAGjC;AAED,kEAAkE;AAClE,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,kFAAkF;AAClF,wBAAgB,WAAW,IAAI,OAAO,CAmBrC"}

package/dist/runtime/cli-args.js

@@ -0,0 +1,85 @@
+/**
+ * The run's command-line arguments, as seen from inside a worker.
+ *
+ * `bin/helix.js` parses the flags in the CLI process and forwards them to every
+ * worker through the environment (`HELIX_TAGS`, `HELIX_TESTS`, …), because a
+ * worker is spawned by either orchestrator (Node pool or the Rust engine) with
+ * a fixed instruction shape. Reading them back here is what lets both the
+ * runtime and a plugin (`api.cliArgs`, Japa parity) see the same filters.
+ *
+ * One named deviation from Japa's `CLIArgs`: values are parsed (`string[]`,
+ * `number`, `boolean`) rather than kept as raw CLI strings. They have been
+ * through the parser once already, on the CLI side, and handing a plugin
+ * `"500"` to re-parse would be worse — Japa's own raw form exists because its
+ * CLI hands the config manager unparsed argv, which helix's does not.
+ */
+/** Comma-separated env list → trimmed non-empty entries, or undefined. */
+export function envList(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === "")
+        return undefined;
+    const items = raw
+        .split(",")
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0);
+    return items.length > 0 ? items : undefined;
+}
+/** A non-negative integer env var, or undefined when unset/invalid. */
+export function envCount(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === "")
+        return undefined;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+/** `--tags` as forwarded by the CLI. */
+export function envTags() {
+    return envList("HELIX_TAGS");
+}
+/** `--match-all` as forwarded by the CLI. */
+export function envMatchAll() {
+    return process.env.HELIX_MATCH_ALL === "1" ? true : undefined;
+}
+/** A boolean flag as forwarded by the CLI — absent stays `undefined`, as in Japa. */
+function envFlag(name) {
+    return process.env[name] === "1" ? true : undefined;
+}
+/**
+ * The run's flags, as ONE object.
+ *
+ * Japa hands its plugins a `cliArgs` they may edit — that is a documented way
+ * to steer a run from a plugin. Rebuilding it from the environment on every
+ * access would silently drop those edits, so it is built once and every reader
+ * (the plugin API, and the runtime's own filter resolution) shares it.
+ */
+let materialised;
+export function cliArgs() {
+    materialised ??= readCLIArgs();
+    return materialised;
+}
+/** Test seam: rebuild from the environment on the next access. */
+export function resetCLIArgs() {
+    materialised = undefined;
+}
+/** Every CLI flag the current worker can see, read fresh from the environment. */
+export function readCLIArgs() {
+    return {
+        tags: envTags(),
+        tests: envList("HELIX_TESTS"),
+        groups: envList("HELIX_GROUPS"),
+        matchAll: envMatchAll(),
+        timeout: envCount("HELIX_TIMEOUT"),
+        retries: envCount("HELIX_RETRIES"),
+        grep: process.env.HELIX_GREP,
+        suite: process.env.HELIX_SUITE,
+        files: envList("HELIX_FILES"),
+        reporters: envList("HELIX_REPORTERS"),
+        bail: envFlag("HELIX_BAIL"),
+        bailLayer: process.env.HELIX_BAIL_LAYER,
+        failed: envFlag("HELIX_FAILED"),
+        forceExit: envFlag("HELIX_FORCE_EXIT"),
+        listPinned: envFlag("HELIX_LIST_PINNED"),
+        _: envList("HELIX_POSITIONALS"),
+    };
+}
+//# sourceMappingURL=cli-args.js.map

package/dist/runtime/cli-args.js.map

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

package/dist/runtime/configure.d.ts

@@ -0,0 +1,214 @@
+/**
+ * `configure({ plugins })` — the Japa/AdonisJS bootstrap entry.
+ *
+ * Following Japa precisely: the runtime core is plugin-agnostic, and every
+ * capability (HTTP `client`, `db`, fakes, …) ships as a PLUGIN that extends the
+ * injected test context. A plugin is a function handed a {@link PluginApi};
+ * it registers context properties via `api.context.macro` / `.getter` (the
+ * `TestContext.macro`/`getter` of Japa) and pairs that with a `declare module`
+ * augmentation for the types.
+ *
+ *   // tests/bootstrap.ts
+ *   import { configure } from "@c9up/helix";
+ *   import { apiClient } from "@c9up/ream/testing";
+ *   await configure({ plugins: [apiClient({ baseUrl })] });
+ *
+ * This keeps `@c9up/helix` (the core) free of any ecosystem dependency: the
+ * plugins live in each package's `/testing` subpath and depend on helix, never
+ * the other way round — the Japa "runner + plugins" topology.
+ */
+import { type CLIArgs } from "./cli-args.js";
+import { type TestContext } from "./context.js";
+import { type Emitter } from "./emitter.js";
+import { Runner } from "./runner.js";
+import { type SuiteHandle, type SuiteHook, type SuiteHookCleanup } from "./suite-taps.js";
+/**
+ * What a plugin uses to extend the test context. Mirrors Japa's
+ * `TestContext.macro(name, value)` / `TestContext.getter(name, fn)`.
+ */
+export interface PluginContext {
+    /** Add a shared property present on every test context. */
+    macro(name: string, value: unknown): void;
+    /** Add a lazily-computed, per-context property (cached per context). */
+    getter(name: string, fn: (ctx: TestContext) => unknown): void;
+}
+/** A runner-level hook — Japa's shape, defined once in `suite-taps.ts`. */
+export type RunnerHook = SuiteHook;
+export type RunnerHookCleanup = SuiteHookCleanup;
+/**
+ * The API handed to each plugin at {@link configure} time.
+ *
+ * Japa hands its plugins `{ config, cliArgs, runner, emitter }`; helix passes
+ * the same four, so a Japa plugin's body ports over unchanged, plus two helix
+ * additions — `context` (Japa reaches the same registry through the imported
+ * `TestContext` class) and `cleanup` (Japa uses `config.teardown`).
+ */
+export interface PluginApi {
+    /**
+     * The options this run was configured with (Japa `config`). Mutable: Japa
+     * plugins edit it, and helix reads it back once every plugin has run.
+     */
+    config: ConfigureOptions;
+    /** The flags the CLI forwarded to this worker (Japa `cliArgs`). */
+    cliArgs: CLIArgs;
+    /** Run-level counters, readable once the run ends (Japa `runner`). */
+    runner: Runner;
+    /** Lifecycle events — `test:start`, `group:end`, … (Japa `emitter`). */
+    emitter: Emitter;
+    /** Extend the injected test context. */
+    context: PluginContext;
+    /**
+     * Register a teardown that runs ONCE after all tests in the run finish
+     * (reverse registration order) — the place to close a booted server, a DB
+     * pool, etc. (Japa runner-teardown parity). Without this, a plugin that boots
+     * a resource at `configure()` has no clean shutdown point.
+     */
+    cleanup(fn: RunnerHook): void;
+}
+/**
+ * A helix plugin — the Japa plugin shape adapted to helix. Runs once at
+ * bootstrap; may be async (e.g. to boot a server before registering `client`).
+ */
+export type Plugin = (api: PluginApi) => void | Promise<void>;
+/**
+ * Filters applied to the tests a file declares (Japa `config.filters`).
+ *
+ * `files` and `suites` are reported, not honoured: they select which FILES run,
+ * and helix settles that list in the CLI process before any worker — and
+ * therefore any bootstrap — exists. Setting them here cannot un-spawn a worker
+ * that is already running, so they carry what the CLI decided and the CLI-side
+ * flags (`--files`, a suite positional) remain the way to decide it.
+ */
+export interface ConfigureFilters {
+    /**
+     * Path fragments the CLI matched files against (Japa `filters.files`).
+     * Read-only here: helix settles the file list before a worker exists, so
+     * this reports what was selected rather than selecting.
+     */
+    files?: string[];
+    /** Suite names the run was limited to (Japa `filters.suites`). Read-only. */
+    suites?: string[];
+    /** Only tests carrying one of these tags (`~@tag`/`!@tag` excludes). */
+    tags?: string[];
+    /** Only groups with these exact titles. */
+    groups?: string[];
+    /** Only tests with these exact titles. */
+    tests?: string[];
+    /** Require EVERY tag in `tags` instead of any (Japa `--match-all`). */
+    matchAll?: boolean;
+}
+/**
+ * Japa's `Refiner`, as much of it as means anything here: a handle that ADDS
+ * filters. It writes straight into {@link ConfigureOptions.filters}, so a
+ * plugin calling `refiner.add("tags", [...])` steers the run exactly as setting
+ * the filter would — the object is a different door to the same room, not a
+ * second mechanism.
+ */
+export interface Refiner {
+    /** Add filter values for a layer (Japa `refiner.add`). */
+    add(layer: "tests" | "groups" | "tags", values: string[]): void;
+    /** Require every tag instead of any (Japa `refiner.matchAllTags`). */
+    matchAllTags(toggle?: boolean): void;
+}
+/** Runtime configuration passed to {@link configure}. */
+export interface ConfigureOptions {
+    /** Plugins to install — each extends the test context (Japa parity). */
+    plugins?: Plugin[];
+    /**
+     * The directory the run was launched from (Japa `cwd`). Filled in by the
+     * runtime, so a plugin resolving a path against the project reads the same
+     * root the CLI discovered from.
+     */
+    cwd?: string;
+    /**
+     * Configure the suite before it runs (Japa `configureSuite`). Applied AFTER
+     * the plugins, which is both Japa's order and what lets a plugin read it or
+     * put its own in place.
+     *
+     * May return a promise — Japa's is synchronous, but helix's per-suite
+     * `configure` has to re-import the config module, and hooks it registers must
+     * exist before the setup hooks are drained.
+     */
+    configureSuite?: (suite: SuiteHandle) => void | Promise<void>;
+    /**
+     * The reporters this run activated (Japa `reporters.activated`). Read-only
+     * truth: reporters live in the CLI process, so naming one here would not
+     * make it run.
+     */
+    reporters?: {
+        activated: string[];
+    };
+    /** `process.exit()` once the run ends (Japa `forceExit`). */
+    forceExit?: boolean;
+    /** Directories discovery skipped (Japa `exclude`). */
+    exclude?: string[];
+    /**
+     * The filter object (Japa `refiner`). Writes through to
+     * {@link ConfigureOptions.filters}, so `refiner.add("tags", [...])` from a
+     * plugin steers the run exactly as setting the filter would.
+     */
+    refiner?: Refiner;
+    /**
+     * Filters to apply to this file's tests (Japa `config.filters`). The CLI
+     * flags win: a filter typed at the prompt overrides the configured one.
+     */
+    filters?: ConfigureFilters;
+    /**
+     * How a test file is imported (Japa `config.importer`). Defaults to
+     * `import(file.href)`. Receives the URL helix would have imported —
+     * cache-busting query included, so repeated runs still re-evaluate.
+     */
+    importer?: (file: URL) => void | Promise<void>;
+    /** Run once before the tests (Japa runner `setup`). */
+    setup?: RunnerHook[];
+    /** Run once after the tests, reverse order (Japa runner `teardown`). */
+    teardown?: RunnerHook[];
+    /**
+     * Default per-test timeout in ms for this file's tests (Japa `configure({
+     * timeout })`). `0` disables. Overridden by `--timeout` and by a per-test
+     * `test.timeout(ms)` / `{ timeout }`.
+     */
+    timeout?: number;
+    /**
+     * Default extra attempts on failure for this file's tests (Japa `configure({
+     * retries })`). Overridden by `--retries` and by a per-test `test.retry(n)`.
+     */
+    retries?: number;
+    /**
+     * The name of the suite these tests belong to — surfaced as
+     * `ctx.test.options.meta.suite.name` and on the `suite:*` events. Defaults to
+     * `"default"`, the name Japa gives its implicit suite. Overridden by
+     * `--suite`.
+     */
+    suite?: string;
+}
+/** Run-level defaults from `configure({ timeout, retries, suite, filters })`. */
+interface ConfiguredDefaults {
+    timeout?: number;
+    retries?: number;
+    suite?: string;
+    filters?: ConfigureFilters;
+    importer?: (file: URL) => void | Promise<void>;
+}
+/** The defaults set by {@link configure}, if any. */
+export declare function getConfiguredDefaults(): Readonly<ConfiguredDefaults>;
+/**
+ * Install plugins + runner hooks. Call once from a bootstrap file
+ * (Japa/AdonisJS `bin/test.ts` / `tests/bootstrap.ts`).
+ *
+ * Order follows Japa: PLUGINS first, then the run's `setup` hooks, then the
+ * `teardown` hooks are parked for after the run (see {@link
+ * drainRunnerTeardowns}). That ordering is what makes a plugin's edits count —
+ * it can raise `config.timeout`, push a `setup` hook, or reach for
+ * `runner.onSuite`, and the run picks all of it up because nothing has been
+ * read yet.
+ */
+export declare function configure(options: ConfigureOptions): Promise<void>;
+/**
+ * Run every registered runner teardown (reverse order), then clear them — called
+ * by the runtime after a file's tests finish. Failures are logged, not thrown,
+ * so one bad teardown can't hide the test results.
+ */
+export declare function drainRunnerTeardowns(): Promise<void>;
+export {};
+//# sourceMappingURL=configure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../src/runtime/configure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAW,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,KAAK,OAAO,EAAW,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAEN,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,gBAAgB,EAErB,MAAM,iBAAiB,CAAC;AAEzB;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B,2DAA2D;IAC3D,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1C,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,GAAG,IAAI,CAAC;CAC9D;AAED,2EAA2E;AAC3E,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC;AACnC,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACzB;;;OAGG;IACH,MAAM,EAAE,gBAAgB,CAAC;IACzB,mEAAmE;IACnE,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC;IACjB,wCAAwC;IACxC,OAAO,EAAE,aAAa,CAAC;IACvB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACvB,0DAA0D;IAC1D,GAAG,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAChE,sEAAsE;IACtE,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CACrC;AAcD,yDAAyD;AACzD,MAAM,WAAW,gBAAgB;IAChC,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D;;;;OAIG;IACH,SAAS,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACpC,6DAA6D;IAC7D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,uDAAuD;IACvD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAQD,iFAAiF;AACjF,UAAU,kBAAkB;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C;AAID,qDAAqD;AACrD,wBAAgB,qBAAqB,IAAI,QAAQ,CAAC,kBAAkB,CAAC,CAEpE;AAgCD;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuDxE;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAoB1D"}