@crvouga/atlas 0.4.0 → 0.6.0

package/dist/reports/src/test-catalog-entity.js

@@ -5,6 +5,12 @@ function packageOf(testId) {
     const name = cut < 0 ? source : source.slice(0, cut);
     return name.length > 0 ? name : 'report';
 }
+/**
+ * Flattens a recorded test into a `CatalogEntity`: its id, title, status and duration; the base name of its source
+ * file; the package (the part of the viewer test id's source before `--`, or `report`); its runtime; and the first
+ * line of its error as the detail. `search` joins the title, ids, paths, system, runtime, package and error for text
+ * matching. `href` is `null`; the caller sets where a row links to.
+ */
 export function testCatalogEntity(test) {
     const meta = test.report.meta;
     const file = fileLabel(meta.sourceFile);

package/dist/reports/src/types.d.ts

@@ -1,5 +1,10 @@
+/**
+ * @module Report viewer data
+ *
+ * The data shape the standalone and Solid report viewers render: a recorded run plus its title.
+ */
 import type { HtmlReportBundle } from './recording-bundle.js';
-/** Bundle plus document title for the standalone / Solid report viewer. */
+/** A run's tests (`HtmlReportBundle`) plus the document title shown for them, for the standalone / Solid report viewer. */
 export type ReportData = HtmlReportBundle & {
     readonly title: string;
 };

package/dist/reports/src/use-report-nav.d.ts

@@ -1,25 +1,60 @@
+/**
+ * @module Report viewer navigation state
+ *
+ * The Solid state behind the report viewer's navigation: the current route (kept in the URL hash), help and command
+ * palette visibility, frame stepping and auto-play, keyboard shortcuts and the document title. Everything outside the
+ * reactive state (the location, the keyboard, timers) is injected, so it runs the same in a browser and in tests. It
+ * creates signals and effects, so it must be called inside a Solid root, which also owns its cleanup.
+ */
 import type { Timers } from './clock.js';
 import type { FlatFrame } from './frames.js';
 import type { Route } from './hash.js';
 import type { ReportData } from './types.js';
 import type { Accessor } from 'solid-js';
 import type { ReportNavigation } from './navigation.js';
+/** What the viewer's views read and call to move around a report. */
 export type ReportNav = {
+    /** The current route: the list, or one test with its params. Updates at once, before the URL is written. */
     route: Accessor<Route>;
+    /** Whether the keyboard help is open. */
     showHelp: Accessor<boolean>;
+    /** Whether the command palette is open. */
     showPalette: Accessor<boolean>;
+    /** Whether frames are advancing on a timer. */
     playing: Accessor<boolean>;
+    /** Goes to `route`. A normal navigation adds a history entry and writes the URL now; with `replace` true it updates the route at once and writes the URL, replacing the entry, 200 ms after the last such call. */
     navigate: (route: Route, replace?: boolean) => void;
     /** Write the in-memory route to the URL now (end of a scrub drag). */
     commitHash: () => void;
+    /** Sets one param of the current test route (replacing history); does nothing on the list route. */
     setParam: (key: string, value: string) => void;
+    /** Selects a frame of the current test (its 1-based position goes into the `frame` param), or clears the selection with `null`; `node` also sets the `node` param. Does nothing on the list route. */
     goFrame: (frame: FlatFrame | null, node?: string | undefined) => void;
+    /** Moves the selected frame by `delta` (negative goes back); does nothing at either end or off a test route. */
     stepFrame: (delta: number) => void;
+    /** Opens the help if closed, else closes it. */
     toggleHelp: () => void;
+    /** Closes the help. */
     closeHelp: () => void;
+    /** Opens the palette if closed, else closes it. */
     togglePalette: () => void;
+    /** Closes the palette. */
     closePalette: () => void;
+    /** Starts advancing one frame every 700 ms, or stops if playing. Stops by itself at the last frame, or when the route stops being a test. */
     togglePlay: () => void;
+    /** Stops playback. */
     stopPlay: () => void;
 };
+/**
+ * Creates the navigation state for a report: the route from the URL hash (and kept in sync when it changes), help and
+ * palette state, playback, keyboard shortcuts and the page title (`<test title> · <report title>`).
+ *
+ * Reading the hash is the only way in: an unrecognised hash is the list route, and `parseHash` throws `URIError` on a
+ * malformed percent-escape. Subscriptions and timers are released when the surrounding Solid root is disposed. Must be
+ * called inside a Solid root.
+ *
+ * @param data the report whose tests the routes name.
+ * @param navigation where the hash, keys and title live (the browser, or a fake).
+ * @param timers timer functions for the hash-write debounce and playback.
+ */
 export declare function useReportNav(data: ReportData, navigation: ReportNavigation, timers: Timers): ReportNav;

package/dist/reports/src/use-report-nav.js

@@ -94,6 +94,18 @@ function createHashRoute(navigation, timers) {
     onCleanup(cancelHashWrite);
     return { route, setRoute, commitHash, navigate, cancelHashWrite };
 }
+/**
+ * Creates the navigation state for a report: the route from the URL hash (and kept in sync when it changes), help and
+ * palette state, playback, keyboard shortcuts and the page title (`<test title> · <report title>`).
+ *
+ * Reading the hash is the only way in: an unrecognised hash is the list route, and `parseHash` throws `URIError` on a
+ * malformed percent-escape. Subscriptions and timers are released when the surrounding Solid root is disposed. Must be
+ * called inside a Solid root.
+ *
+ * @param data the report whose tests the routes name.
+ * @param navigation where the hash, keys and title live (the browser, or a fake).
+ * @param timers timer functions for the hash-write debounce and playback.
+ */
 export function useReportNav(data, navigation, timers) {
     const { route, setRoute, commitHash, navigate, cancelHashWrite } = createHashRoute(navigation, timers);
     const [showHelp, setShowHelp] = createSignal(false);

package/dist/runners/src/codecept.d.ts

@@ -0,0 +1,14 @@
+/** @module CodeceptJS reporter
+ * CodeceptJS's Mocha reporter interface carries scenario outcomes and steps to the singleton Atlas server.
+ */
+import AtlasMochaReporter from './mocha.js';
+/**
+ * Use `codeceptjs run --reporter @crvouga/atlas/codecept` with ATLAS_SERVER_URL and ATLAS_PUBLISH_TOKEN.
+ * Upload failures fail the run; skipped scenarios remain not-run.
+ * @example
+ * // codecept.conf.js
+ * export const config = { tests: './tests/*_test.js', reporter: '@crvouga/atlas/codecept' };
+ */
+export default class AtlasCodeceptReporter extends AtlasMochaReporter {
+    constructor(...args: [ConstructorParameters<typeof AtlasMochaReporter>[0], ConstructorParameters<typeof AtlasMochaReporter>[1]?]);
+}

package/dist/runners/src/codecept.js

@@ -0,0 +1,16 @@
+/** @module CodeceptJS reporter
+ * CodeceptJS's Mocha reporter interface carries scenario outcomes and steps to the singleton Atlas server.
+ */
+import AtlasMochaReporter from './mocha.js';
+/**
+ * Use `codeceptjs run --reporter @crvouga/atlas/codecept` with ATLAS_SERVER_URL and ATLAS_PUBLISH_TOKEN.
+ * Upload failures fail the run; skipped scenarios remain not-run.
+ * @example
+ * // codecept.conf.js
+ * export const config = { tests: './tests/*_test.js', reporter: '@crvouga/atlas/codecept' };
+ */
+export default class AtlasCodeceptReporter extends AtlasMochaReporter {
+    constructor(...args) {
+        super(args[0], args[1], 'codeceptjs');
+    }
+}

package/dist/runners/src/jest.d.ts

@@ -0,0 +1,50 @@
+import { type ReporterOptions } from './publish.js';
+type Result = {
+    testFilePath: string;
+    testExecError?: {
+        message?: string;
+        stack?: string;
+    };
+    failureMessage?: string;
+    testResults: {
+        title: string;
+        fullName: string;
+        status: string;
+        duration?: number | null;
+        failureMessages: string[];
+        invocations?: number;
+    }[];
+};
+/**
+ * Jest's native reporter; retain `default` in the reporter list for console output. Upload errors fail Jest.
+ * @example
+ * export default { reporters: ['default', ['@crvouga/atlas/jest', { url: 'https://atlas.example.com' }]] };
+ */
+export default class AtlasJestReporter {
+    private readonly options;
+    private live;
+    private error;
+    constructor(_config: unknown, options?: ReporterOptions);
+    /** Reset publishing errors for each watch-mode invocation. */
+    onRunStart(result?: {
+        numTotalTests?: number;
+    }): void;
+    /** Publish the test as running before its body executes in a worker. */
+    onTestCaseStart(test: {
+        path: string;
+    }, info: {
+        fullName: string;
+        title: string;
+    }): void;
+    /** Stream each test outcome immediately, without waiting for other files to finish. */
+    onTestCaseResult(test: {
+        path: string;
+    }, result: Result['testResults'][number]): void;
+    /** Await uploading every final result, including test-file failures before any test ran. */
+    onRunComplete(_contexts: unknown, result: {
+        testResults: Result[];
+    }): Promise<void>;
+    /** Jest uses this to turn a publishing error into a failed invocation. */
+    getLastError(): Error | undefined;
+}
+export {};

package/dist/runners/src/jest.js

@@ -0,0 +1,52 @@
+import { testFile, runnerLive, finishRunner } from './publish.js';
+/**
+ * Jest's native reporter; retain `default` in the reporter list for console output. Upload errors fail Jest.
+ * @example
+ * export default { reporters: ['default', ['@crvouga/atlas/jest', { url: 'https://atlas.example.com' }]] };
+ */
+export default class AtlasJestReporter {
+    options;
+    live;
+    error;
+    constructor(_config, options = {}) {
+        this.options = options;
+    }
+    /** Reset publishing errors for each watch-mode invocation. */
+    onRunStart(result) { this.error = undefined; this.live = runnerLive('jest', this.options, result?.numTotalTests || undefined); }
+    /** Publish the test as running before its body executes in a worker. */
+    onTestCaseStart(test, info) {
+        this.live ??= runnerLive('jest', this.options);
+        this.live.check({ id: `${testFile(test.path, this.options.rootDir)} > ${info.fullName}`, title: info.title, status: 'running' });
+    }
+    /** Stream each test outcome immediately, without waiting for other files to finish. */
+    onTestCaseResult(test, result) {
+        this.live ??= runnerLive('jest', this.options);
+        this.live.check({ id: `${testFile(test.path, this.options.rootDir)} > ${result.fullName}`, title: result.title,
+            status: result.status === 'passed' ? 'passed' : result.status === 'failed' ? 'failed' : 'not-run', detail: result.failureMessages.join('\n') });
+    }
+    /** Await uploading every final result, including test-file failures before any test ran. */
+    async onRunComplete(_contexts, result) {
+        const checks = [];
+        for (const suite of result.testResults) {
+            const file = testFile(suite.testFilePath, this.options.rootDir);
+            for (const test of suite.testResults)
+                checks.push({ id: `${file} > ${test.fullName}`, title: test.title,
+                    status: test.status === 'passed' ? 'passed' : test.status === 'failed' ? 'failed' : 'not-run',
+                    detail: test.failureMessages.join('\n'), measurements: [],
+                    ...(typeof test.duration === 'number' && Number.isFinite(test.duration) && test.duration >= 0 ? { durationMs: test.duration } : {}),
+                    ...((test.invocations ?? 1) > 1 ? { labels: { retries: String(test.invocations - 1), ...(test.status === 'passed' ? { flaky: 'true' } : {}) } } : {}) });
+            if (suite.testExecError)
+                checks.push({ id: `${file} > [suite error]`, title: `${file}: suite error`, status: 'failed', detail: suite.testExecError.stack ?? suite.testExecError.message ?? suite.failureMessage ?? 'Suite did not execute', measurements: [] });
+        }
+        this.live ??= runnerLive('jest', this.options);
+        checks.forEach(check => this.live.check(check));
+        try {
+            await finishRunner(this.live, 'jest', checks, this.options);
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    /** Jest uses this to turn a publishing error into a failed invocation. */
+    getLastError() { return this.error; }
+}

package/dist/runners/src/mocha.d.ts

@@ -0,0 +1,40 @@
+import { type ReporterOptions } from './publish.js';
+type Test = {
+    title: string;
+    file?: string;
+    duration?: number;
+    fullTitle(): string;
+    err?: {
+        stack?: string;
+        message?: string;
+    };
+    steps?: {
+        name?: string;
+        status?: string;
+    }[];
+    currentRetry?(): number;
+};
+type Runner = {
+    total?: number;
+    on(event: string, listener: (test: Test, error?: Error) => void): unknown;
+};
+/**
+ * Mocha reporter; use `--reporter @crvouga/atlas/mocha` or CodeceptJS `--reporter @crvouga/atlas/codecept`.
+ * Reporter options go in `reporterOptions`; environment variables are supported by every runner.
+ * A failed upload adds a runner failure through Mocha's completion callback.
+ * @example
+ * // mocha configuration
+ * export default { reporter: '@crvouga/atlas/mocha', reporterOptions: { url: 'https://atlas.example.com' } };
+ */
+export default class AtlasMochaReporter {
+    private readonly checks;
+    private readonly options;
+    private readonly runnerName;
+    private readonly live;
+    constructor(runner: Runner, options?: {
+        reporterOptions?: ReporterOptions;
+    }, runnerName?: string);
+    /** Mocha waits for this callback before exiting. Publishing errors fail the invocation. */
+    done(failures: number, callback: (failures: number) => void): void;
+}
+export {};

package/dist/runners/src/mocha.js

@@ -0,0 +1,39 @@
+import { testFile, runnerLive, finishRunner } from './publish.js';
+/**
+ * Mocha reporter; use `--reporter @crvouga/atlas/mocha` or CodeceptJS `--reporter @crvouga/atlas/codecept`.
+ * Reporter options go in `reporterOptions`; environment variables are supported by every runner.
+ * A failed upload adds a runner failure through Mocha's completion callback.
+ * @example
+ * // mocha configuration
+ * export default { reporter: '@crvouga/atlas/mocha', reporterOptions: { url: 'https://atlas.example.com' } };
+ */
+export default class AtlasMochaReporter {
+    checks = new Map();
+    options;
+    runnerName;
+    live;
+    constructor(runner, options = {}, runnerName = 'mocha') {
+        this.options = options.reporterOptions ?? {};
+        this.runnerName = runnerName;
+        this.live = runnerLive(runnerName, this.options, runner.total);
+        const add = (test, status, error) => {
+            const file = testFile(test.file, this.options.rootDir);
+            const retry = test.currentRetry?.() ?? 0;
+            this.checks.set(test, { id: [file, test.fullTitle()].filter(Boolean).join(' > '), title: test.title, status,
+                detail: error?.stack ?? error?.message ?? (status === 'failed' ? test.err?.stack ?? test.err?.message ?? 'failed' : ''), measurements: [],
+                ...(typeof test.duration === 'number' && Number.isFinite(test.duration) && test.duration >= 0 ? { durationMs: test.duration } : {}),
+                ...(retry ? { labels: { retries: String(retry), ...(status === 'passed' ? { flaky: 'true' } : {}) } } : {}),
+                ...(test.steps?.length ? { steps: test.steps.map(step => ({ name: step.name ?? 'step', ...(step.status ? { status: step.status } : {}) })) } : {}) });
+            const check = this.checks.get(test);
+            this.live.check({ ...check, steps: check.steps?.map(step => ({ name: step.name, status: step.status })) });
+        };
+        runner.on('test', test => add(test, 'running'));
+        runner.on('pass', test => add(test, 'passed'));
+        runner.on('fail', (test, error) => add(test, 'failed', error));
+        runner.on('pending', test => add(test, 'not-run'));
+    }
+    /** Mocha waits for this callback before exiting. Publishing errors fail the invocation. */
+    done(failures, callback) {
+        void finishRunner(this.live, this.runnerName, [...this.checks.values()], this.options).then(() => callback(failures), error => { console.error(error instanceof Error ? error.message : String(error)); callback(failures + 1); });
+    }
+}

package/dist/runners/src/node-test.d.ts

@@ -0,0 +1,28 @@
+type Event = {
+    type: string;
+    data: {
+        name?: string;
+        file?: string;
+        nesting?: number;
+        type?: string;
+        skip?: boolean | string;
+        todo?: boolean | string;
+        details?: {
+            type?: string;
+            duration_ms?: number;
+            error?: {
+                stack?: string;
+                message?: string;
+                failureType?: string;
+            };
+        };
+    };
+};
+/**
+ * Async generator reporter. Use alongside Node's spec reporter to keep normal output.
+ * Upload errors reject the stream; skips and TODOs never count as passed. Successful suite containers are excluded; hook failures are retained.
+ * @example
+ * // node --test --test-reporter=spec --test-reporter=@crvouga/atlas/node-test
+ */
+export default function atlasNodeReporter(source: AsyncIterable<Event>): AsyncGenerator<string>;
+export {};

package/dist/runners/src/node-test.js

@@ -0,0 +1,44 @@
+import { testFile, runnerLive, finishRunner } from './publish.js';
+/**
+ * Async generator reporter. Use alongside Node's spec reporter to keep normal output.
+ * Upload errors reject the stream; skips and TODOs never count as passed. Successful suite containers are excluded; hook failures are retained.
+ * @example
+ * // node --test --test-reporter=spec --test-reporter=@crvouga/atlas/node-test
+ */
+export default async function* atlasNodeReporter(source) {
+    const checks = [];
+    const live = runnerLive('node-test');
+    const kinds = new Map();
+    try {
+        const parents = [];
+        for await (const { type, data } of source) {
+            const nesting = data.nesting ?? 0;
+            const identity = `${data.file ?? ''}|${nesting}|${data.name ?? ''}`;
+            if (type === 'test:enqueue' && data.type)
+                kinds.set(identity, data.type);
+            if (type === 'test:start') {
+                parents[nesting] = data.name ?? '';
+                parents.length = nesting + 1;
+                if (kinds.get(identity) === 'test')
+                    live.check({ id: [testFile(data.file), ...parents.slice(0, nesting), data.name].filter(Boolean).join(' > '), title: data.name ?? 'test', status: 'running' });
+            }
+            if (type !== 'test:pass' && type !== 'test:fail')
+                continue;
+            if (data.details?.type === 'suite' && (type === 'test:pass' || data.details.error?.failureType === 'subtestsFailed'))
+                continue;
+            const file = testFile(data.file);
+            const status = data.skip || data.todo ? 'not-run' : type === 'test:pass' ? 'passed' : 'failed';
+            checks.push({ id: [file, ...parents.slice(0, nesting), data.name].filter(Boolean).join(' > '), title: data.name ?? 'test', status,
+                detail: data.details?.error?.stack ?? data.details?.error?.message ?? '', measurements: [],
+                ...(typeof data.details?.duration_ms === 'number' && Number.isFinite(data.details.duration_ms) && data.details.duration_ms >= 0 ? { durationMs: data.details.duration_ms } : {}) });
+            live.check(checks.at(-1));
+        }
+        checks.forEach(check => live.check(check));
+        await finishRunner(live, 'node-test', checks);
+        yield `Atlas: uploaded ${checks.length} checks\n`;
+    }
+    catch (error) {
+        await live.finish('interrupted', 'The test event stream ended unexpectedly.').catch(() => { });
+        throw error;
+    }
+}

package/dist/runners/src/publish.d.ts

@@ -0,0 +1,30 @@
+import type { EvidenceCheck } from '../../reports/src/explorer-types.js';
+/** Reporter options; explicit values override ATLAS_SERVER_URL, ATLAS_PUBLISH_TOKEN, ATLAS_ENVIRONMENT, ATLAS_BRANCH and ATLAS_SHA. */
+export type ReporterOptions = {
+    /** Project namespace; defaults to ATLAS_PROJECT. */
+    readonly project?: string;
+    readonly url?: string;
+    readonly token?: string;
+    readonly producer?: string;
+    readonly environment?: string;
+    readonly branch?: string;
+    readonly sha?: string;
+    readonly timeoutMs?: number;
+    readonly rootDir?: string;
+    /** Explicit final evidence time; normally generated when publication finishes. */
+    readonly recordedAtMs?: number;
+};
+/** A portable check identity: paths relative to the project, using forward slashes on every OS. */
+export declare function testFile(file: string | undefined, root?: string): string;
+/**
+ * Upload one completed runner invocation. Unknown outcomes stay not-run, repeated identities are numbered.
+ * Throws on missing configuration, timeouts or refused uploads so CI cannot silently lose its evidence.
+ * No storage credentials or backend URL are needed by the runner.
+ * @example
+ * await uploadChecks('mocha', checks, { url: 'https://atlas.example.com', token: process.env.ATLAS_PUBLISH_TOKEN });
+ */
+export declare function uploadChecks(runner: string, checks: readonly EvidenceCheck[], options?: ReporterOptions): Promise<void>;
+/** Start the native runner's live feed with the same endpoint and identity as its final report. */
+export declare function runnerLive(runner: string, options?: ReporterOptions, plannedChecks?: number): import('../../reports/src/live-reporter.js').LiveReporter;
+/** Flush live progress, then publish the full final evidence even if the lease was interrupted. Reject either failure. */
+export declare function finishRunner(live: import('../../reports/src/live-reporter.js').LiveReporter, runner: string, checks: readonly EvidenceCheck[], options?: ReporterOptions): Promise<void>;

package/dist/runners/src/publish.js

@@ -0,0 +1,68 @@
+/** @module Publishing native runner results
+ * Native reporters send checks to the project's Atlas server. Only the server knows its storage backend.
+ */
+import path from 'node:path';
+import { createLiveReporter } from '../../reports/src/live-reporter.js';
+import { uniqueChecks } from '../../reports/src/ingest.js';
+/** A portable check identity: paths relative to the project, using forward slashes on every OS. */
+export function testFile(file, root = process.cwd()) {
+    return file ? path.relative(root, path.resolve(root, file)).replaceAll('\\', '/') : '';
+}
+/**
+ * Upload one completed runner invocation. Unknown outcomes stay not-run, repeated identities are numbered.
+ * Throws on missing configuration, timeouts or refused uploads so CI cannot silently lose its evidence.
+ * No storage credentials or backend URL are needed by the runner.
+ * @example
+ * await uploadChecks('mocha', checks, { url: 'https://atlas.example.com', token: process.env.ATLAS_PUBLISH_TOKEN });
+ */
+export async function uploadChecks(runner, checks, options = {}) {
+    const url = options.url ?? process.env.ATLAS_SERVER_URL;
+    if (!url)
+        throw new Error('Atlas reporter: set ATLAS_SERVER_URL to the project Atlas server');
+    const target = new URL(url);
+    if (!['http:', 'https:'].includes(target.protocol) || target.username || target.password || target.search || target.hash)
+        throw new Error('Atlas reporter: use an HTTP(S) server URL without credentials, query or fragment');
+    target.pathname = `${target.pathname.replace(/\/$/, '')}/api/checks`;
+    const token = options.token ?? process.env.ATLAS_PUBLISH_TOKEN ?? process.env.ATLAS_TOKEN;
+    const response = await fetch(target, {
+        method: 'POST', redirect: 'error', signal: AbortSignal.timeout(options.timeoutMs ?? 30_000),
+        headers: { 'content-type': 'application/json', ...((options.project ?? process.env.ATLAS_PROJECT) ? { 'x-atlas-project': options.project ?? process.env.ATLAS_PROJECT } : {}), ...(token ? { authorization: `Bearer ${token}` } : {}) },
+        body: JSON.stringify({ producer: options.producer ?? runner, recordedAtMs: options.recordedAtMs ?? Date.now(),
+            environment: options.environment ?? process.env.ATLAS_ENVIRONMENT,
+            branch: options.branch ?? process.env.ATLAS_BRANCH, sha: options.sha ?? process.env.ATLAS_SHA,
+            checks: uniqueChecks(checks) })
+    });
+    if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error(`Atlas reporter: upload refused (HTTP ${response.status})`);
+    }
+    await response.body?.cancel();
+}
+/** Start the native runner's live feed with the same endpoint and identity as its final report. */
+export function runnerLive(runner, options = {}, plannedChecks) {
+    const url = options.url ?? process.env.ATLAS_SERVER_URL;
+    if (!url)
+        throw new Error('Atlas reporter: set ATLAS_SERVER_URL to the project Atlas server');
+    return createLiveReporter({ producer: options.producer ?? runner, plannedChecks, title: `${runner} tests`, environment: options.environment ?? process.env.ATLAS_ENVIRONMENT,
+        branch: options.branch ?? process.env.ATLAS_BRANCH, sha: options.sha ?? process.env.ATLAS_SHA }, { url, project: options.project ?? process.env.ATLAS_PROJECT, token: options.token ?? process.env.ATLAS_PUBLISH_TOKEN ?? process.env.ATLAS_TOKEN, timeoutMs: options.timeoutMs });
+}
+/** Flush live progress, then publish the full final evidence even if the lease was interrupted. Reject either failure. */
+export async function finishRunner(live, runner, checks, options = {}) {
+    let error;
+    const finalChecks = uniqueChecks(checks);
+    finalChecks.forEach(check => live.check(check));
+    try {
+        await live.finish();
+    }
+    catch (caught) {
+        error = caught;
+    }
+    try {
+        await uploadChecks(runner, finalChecks, { ...options, recordedAtMs: Math.max(Date.now(), (live.finishedAtMs ?? 0) + 1) });
+    }
+    catch (caught) {
+        error ??= caught;
+    }
+    if (error)
+        throw error;
+}