@c9up/helix 0.1.7 → 0.1.9

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":"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"}

package/dist/runtime/configure.js

@@ -0,0 +1,164 @@
+/**
+ * `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 { cliArgs } from "./cli-args.js";
+import { TestContextRegistry } from "./context.js";
+import { emitter } from "./emitter.js";
+import { Runner } from "./runner.js";
+import { makeSuiteHandle, setCurrentSuite, } from "./suite-taps.js";
+/** Build a {@link Refiner} writing into `filters`. */
+function makeRefiner(filters) {
+    return {
+        add(layer, values) {
+            filters[layer] = [...(filters[layer] ?? []), ...values];
+        },
+        matchAllTags(toggle = true) {
+            filters.matchAll = toggle;
+        },
+    };
+}
+/** Teardowns to run after the run — from `configure({ teardown })` + `api.cleanup`. */
+const runnerTeardowns = [];
+/** Undos returned by `setup` hooks — drained BEFORE the teardowns. */
+const runnerCleanups = [];
+const configuredDefaults = {};
+/** The defaults set by {@link configure}, if any. */
+export function getConfiguredDefaults() {
+    return configuredDefaults;
+}
+/** Tracks the run by listening to {@link emitter} — handed to plugins. */
+const runner = new Runner(emitter);
+/** The options the last {@link configure} call resolved to (Japa `config`). */
+let resolvedConfig = {};
+const api = {
+    // A getter so a plugin reads the config of the `configure()` call it is
+    // running under, not an empty object captured at module load. Japa lets a
+    // plugin EDIT it (that is how a plugin raises the default timeout), so the
+    // object is handed over mutable and read back after every plugin has run.
+    get config() {
+        return resolvedConfig;
+    },
+    // The same object every access, for the same reason: a plugin that writes
+    // `api.cliArgs.tags = [...]` must actually steer the run.
+    get cliArgs() {
+        return cliArgs();
+    },
+    runner,
+    emitter,
+    context: {
+        macro: (name, value) => TestContextRegistry.macro(name, value),
+        getter: (name, fn) => TestContextRegistry.getter(name, fn),
+    },
+    cleanup: (fn) => {
+        runnerTeardowns.push(fn);
+    },
+};
+/**
+ * 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 async function configure(options) {
+    resolvedConfig = options;
+    // Hook arrays a plugin can append to (through `runner.onSuite`) — they must
+    // exist before the plugins run, and they are the very arrays drained below.
+    resolvedConfig.setup ??= [];
+    resolvedConfig.teardown ??= [];
+    const setup = resolvedConfig.setup;
+    const teardown = resolvedConfig.teardown;
+    const handle = makeSuiteHandle(options.suite ?? "default", setup, teardown);
+    setCurrentSuite(handle);
+    // The rest of Japa's `BaseConfig`, filled with what this run actually is, so
+    // a plugin reading `api.config` is told the truth rather than `undefined`.
+    const flags = cliArgs();
+    resolvedConfig.cwd ??= process.cwd();
+    resolvedConfig.reporters ??= { activated: flags.reporters ?? [] };
+    resolvedConfig.forceExit ??= flags.forceExit === true;
+    resolvedConfig.filters ??= {};
+    resolvedConfig.filters.files ??= flags.files;
+    resolvedConfig.filters.suites ??=
+        flags.suite === undefined ? undefined : [flags.suite];
+    resolvedConfig.refiner ??= makeRefiner(resolvedConfig.filters);
+    for (const plugin of resolvedConfig.plugins ?? []) {
+        await plugin(api);
+    }
+    // Japa order: plugins, THEN `runner.onSuite(config.configureSuite)`, then the
+    // setup hooks. Applying it here rather than earlier is what lets a plugin
+    // read it — or put its own in place — and still have it take effect.
+    await resolvedConfig.configureSuite?.(handle);
+    // Read the defaults back AFTER the plugins, so a plugin that edited the
+    // config steers the run rather than writing into a value already consumed.
+    if (resolvedConfig.timeout !== undefined)
+        configuredDefaults.timeout = resolvedConfig.timeout;
+    if (resolvedConfig.retries !== undefined)
+        configuredDefaults.retries = resolvedConfig.retries;
+    if (resolvedConfig.suite !== undefined)
+        configuredDefaults.suite = resolvedConfig.suite;
+    if (resolvedConfig.filters !== undefined)
+        configuredDefaults.filters = resolvedConfig.filters;
+    if (resolvedConfig.importer !== undefined)
+        configuredDefaults.importer = resolvedConfig.importer;
+    // Japa skips the global setup hooks under `--list-pinned`: nothing runs, so
+    // nothing should be opened.
+    const listing = cliArgs().listPinned === true;
+    for (const fn of listing ? [] : setup) {
+        // A `setup` hook may resolve to its own undo (the AdonisJS idiom); park it
+        // with the teardowns so it runs in reverse order with everything else.
+        const undo = await fn(runner);
+        if (typeof undo === "function")
+            runnerCleanups.push(undo);
+    }
+    for (const fn of teardown)
+        runnerTeardowns.push(fn);
+}
+/**
+ * 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 async function drainRunnerTeardowns() {
+    // Cleanups returned by `setup` unwind first — they are the innermost thing
+    // that was opened. `null` for the error: the drain only happens once the run
+    // itself has finished, so there is no setup failure left to report.
+    for (let i = runnerCleanups.length - 1; i >= 0; i -= 1) {
+        try {
+            await runnerCleanups[i](null, runner);
+        }
+        catch (err) {
+            console.error("[helix] runner cleanup failed:", err);
+        }
+    }
+    runnerCleanups.length = 0;
+    for (let i = runnerTeardowns.length - 1; i >= 0; i -= 1) {
+        try {
+            await runnerTeardowns[i](runner);
+        }
+        catch (err) {
+            console.error("[helix] runner teardown failed:", err);
+        }
+    }
+    runnerTeardowns.length = 0;
+}
+//# sourceMappingURL=configure.js.map

package/dist/runtime/configure.js.map

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

package/dist/runtime/context.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Injected test context — Japa's defining mechanism.
+ *
+ * Every test body (and, later, group hooks) receives a `TestContext` as its
+ * FIRST argument: `test("x", ({ assert, client, db, cleanup }) => …)`. The
+ * context is EXTENSIBLE via declaration merging: capability plugins (HTTP
+ * client, DB, fakes) both register a runtime property through
+ * {@link TestContextRegistry} AND augment the `TestContext` interface:
+ *
+ *     declare module "@c9up/helix" {
+ *       interface TestContext { client: ApiClient }
+ *     }
+ *
+ * This is what lets `@c9up/helix/http`, `@c9up/helix/db`, … graft `client`,
+ * `db`, … onto the context — fully typed — without the core depending on those
+ * packages.
+ *
+ * Backwards compatible: passing the context as the first arg is a no-op for
+ * existing zero-argument bodies (`test("x", () => …)`), which ignore it.
+ */
+import { type Assert } from "./assert.js";
+import type { TestInstance } from "./suite.js";
+import { type TestCleanup } from "./test-context.js";
+/**
+ * The per-test context. `cleanup` is always present; capability plugins add
+ * `assert`, `client`, `db`, … by augmenting this interface (declaration
+ * merging) alongside a matching {@link TestContextRegistry} registration.
+ */
+/**
+ * A CLASS (not an interface) so plugins can add REQUIRED properties via
+ * declaration merging — `declare module "@c9up/helix" { interface TestContext {
+ * client: ApiClient } }` — without breaking the core's construction (an external
+ * augmentation is not subject to helix's `strictPropertyInitialization`). This
+ * is exactly how Japa's `TestContext` works.
+ */
+export declare class TestContext {
+    /**
+     * Add a shared property to every test context — Japa's
+     * `TestContext.macro('sleep', fn)`, callable on the class itself so a Japa
+     * plugin's registration code ports over unchanged.
+     */
+    static macro(name: string, value: unknown): void;
+    /** Add a lazily-computed, per-context property (Japa `TestContext.getter`). */
+    static getter(name: string, fn: Getter): void;
+    /** Chai-flavored assertions (`@japa/assert` parity), alongside `expect`. */
+    readonly assert: Assert;
+    /** The running test's own instance — name, options, dataset (Japa `ctx.test`). */
+    readonly test: TestInstance;
+    constructor(test: TestInstance);
+    /**
+     * Register a teardown that runs at the end of THIS test, regardless of
+     * outcome (Japa `ctx.cleanup`). Reverse-insertion order, isolated failures.
+     */
+    cleanup(fn: TestCleanup): void;
+}
+export type Getter = (this: TestContext, ctx: TestContext) => unknown;
+/**
+ * Registry through which plugins extend the test context at runtime. Mirrors
+ * Japa's `TestContext.macro(name, value)` / `TestContext.getter(name, fn)`.
+ * Pair each call with a `declare module` augmentation for the types.
+ */
+export declare const TestContextRegistry: {
+    /** Add a shared property present on every test context. */
+    macro(name: string, value: unknown): void;
+    /**
+     * Add a lazily-computed, per-context property. The getter runs the first
+     * time the property is read on a given context (inside that test's frame),
+     * and the result is cached for that context.
+     */
+    getter(name: string, fn: Getter): void;
+    /** Remove a macro/getter (plugin teardown, tests). No arg clears all. */
+    clear(name?: string): void;
+    /** Whether any extension is registered under `name`. */
+    has(name: string): boolean;
+};
+/**
+ * Build a fresh `TestContext` for one test attempt. MUST be called inside the
+ * per-test frame (`withTestContext`) so `ctx.cleanup` reaches the right frame.
+ * Applies registered macros (own value), then getters (lazy, cached per
+ * context). Dynamic props are attached via `defineProperty` so no `cleanup`
+ * override and no cast are needed.
+ */
+export declare function buildTestContext(test: TestInstance): TestContext;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runtime/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE1E;;;;GAIG;AACH;;;;;;GAMG;AACH,qBAAa,WAAW;IACvB;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIhD,+EAA+E;IAC/E,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAI7C,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;gBAEhB,IAAI,EAAE,YAAY;IAK9B;;;OAGG;IACH,OAAO,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;CAK9B;AAID,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC;AAKtE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC/B,2DAA2D;gBAC/C,MAAM,SAAS,OAAO,GAAG,IAAI;IAGzC;;;;OAIG;iBACU,MAAM,MAAM,MAAM,GAAG,IAAI;IAGtC,yEAAyE;iBAC5D,MAAM,GAAG,IAAI;IAS1B,wDAAwD;cAC9C,MAAM,GAAG,OAAO;CAG1B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,CAqChE"}

package/dist/runtime/context.js

@@ -0,0 +1,146 @@
+/**
+ * Injected test context — Japa's defining mechanism.
+ *
+ * Every test body (and, later, group hooks) receives a `TestContext` as its
+ * FIRST argument: `test("x", ({ assert, client, db, cleanup }) => …)`. The
+ * context is EXTENSIBLE via declaration merging: capability plugins (HTTP
+ * client, DB, fakes) both register a runtime property through
+ * {@link TestContextRegistry} AND augment the `TestContext` interface:
+ *
+ *     declare module "@c9up/helix" {
+ *       interface TestContext { client: ApiClient }
+ *     }
+ *
+ * This is what lets `@c9up/helix/http`, `@c9up/helix/db`, … graft `client`,
+ * `db`, … onto the context — fully typed — without the core depending on those
+ * packages.
+ *
+ * Backwards compatible: passing the context as the first arg is a no-op for
+ * existing zero-argument bodies (`test("x", () => …)`), which ignore it.
+ */
+import { createAssert } from "./assert.js";
+import { registerTestCleanup } from "./test-context.js";
+/**
+ * The per-test context. `cleanup` is always present; capability plugins add
+ * `assert`, `client`, `db`, … by augmenting this interface (declaration
+ * merging) alongside a matching {@link TestContextRegistry} registration.
+ */
+/**
+ * A CLASS (not an interface) so plugins can add REQUIRED properties via
+ * declaration merging — `declare module "@c9up/helix" { interface TestContext {
+ * client: ApiClient } }` — without breaking the core's construction (an external
+ * augmentation is not subject to helix's `strictPropertyInitialization`). This
+ * is exactly how Japa's `TestContext` works.
+ */
+export class TestContext {
+    /**
+     * Add a shared property to every test context — Japa's
+     * `TestContext.macro('sleep', fn)`, callable on the class itself so a Japa
+     * plugin's registration code ports over unchanged.
+     */
+    static macro(name, value) {
+        TestContextRegistry.macro(name, value);
+    }
+    /** Add a lazily-computed, per-context property (Japa `TestContext.getter`). */
+    static getter(name, fn) {
+        TestContextRegistry.getter(name, fn);
+    }
+    /** Chai-flavored assertions (`@japa/assert` parity), alongside `expect`. */
+    assert;
+    /** The running test's own instance — name, options, dataset (Japa `ctx.test`). */
+    test;
+    constructor(test) {
+        this.assert = createAssert();
+        this.test = test;
+    }
+    /**
+     * Register a teardown that runs at the end of THIS test, regardless of
+     * outcome (Japa `ctx.cleanup`). Reverse-insertion order, isolated failures.
+     */
+    cleanup(fn) {
+        // Falls through to the active per-test frame; a false return means we were
+        // called outside a frame (defensive — the runner always wraps).
+        registerTestCleanup(fn);
+    }
+}
+const macros = new Map();
+const getters = new Map();
+/**
+ * Registry through which plugins extend the test context at runtime. Mirrors
+ * Japa's `TestContext.macro(name, value)` / `TestContext.getter(name, fn)`.
+ * Pair each call with a `declare module` augmentation for the types.
+ */
+export const TestContextRegistry = {
+    /** Add a shared property present on every test context. */
+    macro(name, value) {
+        macros.set(name, value);
+    },
+    /**
+     * Add a lazily-computed, per-context property. The getter runs the first
+     * time the property is read on a given context (inside that test's frame),
+     * and the result is cached for that context.
+     */
+    getter(name, fn) {
+        getters.set(name, fn);
+    },
+    /** Remove a macro/getter (plugin teardown, tests). No arg clears all. */
+    clear(name) {
+        if (name === undefined) {
+            macros.clear();
+            getters.clear();
+        }
+        else {
+            macros.delete(name);
+            getters.delete(name);
+        }
+    },
+    /** Whether any extension is registered under `name`. */
+    has(name) {
+        return macros.has(name) || getters.has(name);
+    },
+};
+/**
+ * Build a fresh `TestContext` for one test attempt. MUST be called inside the
+ * per-test frame (`withTestContext`) so `ctx.cleanup` reaches the right frame.
+ * Applies registered macros (own value), then getters (lazy, cached per
+ * context). Dynamic props are attached via `defineProperty` so no `cleanup`
+ * override and no cast are needed.
+ */
+export function buildTestContext(test) {
+    const ctx = new TestContext(test);
+    // `cleanup` and `test` are structural — the runtime hands them to the body
+    // and nothing may take their place. `assert` is NOT: helix ships one, and a
+    // project installing `@japa/assert` is asking for that one instead. Refusing
+    // the override left the plugin registered but never reached, which is how
+    // `plugins: [assert()]` could look wired and do nothing.
+    const reserved = new Set(["cleanup", "test"]);
+    for (const [name, value] of macros) {
+        if (reserved.has(name))
+            continue;
+        Object.defineProperty(ctx, name, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    for (const [name, fn] of getters) {
+        if (reserved.has(name))
+            continue;
+        let computed = false;
+        let cached;
+        Object.defineProperty(ctx, name, {
+            enumerable: true,
+            configurable: true,
+            get() {
+                if (!computed) {
+                    cached = fn.call(ctx, ctx);
+                    computed = true;
+                }
+                return cached;
+            },
+        });
+    }
+    return ctx;
+}
+//# sourceMappingURL=context.js.map

package/dist/runtime/context.js.map

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