zbench-js 0.1.0 → 0.2.0

package/dist/config.d.ts

@@ -1,70 +1,92 @@
+import * as z from 'zod';
 import { type Timespan } from './units.js';
+declare const Timespan: z.ZodLiteral<"ns" | "us" | "ms" | "s">;
 /** A measurement is either derived at an inferred timespan (`true`) or at an explicit one. */
-export type MeasureValue = boolean | Timespan;
+export declare const MeasureValue: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>;
+export type MeasureValue = z.infer<typeof MeasureValue>;
 /**
  * How to turn one of a test's quantities into a reported measurement.
  * The quantity's amount per iteration comes from what `test` returns, falling back to the configuration value.
  */
-export interface MeasureSpec {
-    /** `<unit>`s per `<timespan>` for each configuration, e.g. `MB/s` */
-    throughput?: MeasureValue;
-    /** `<unit>`s per `<timespan>` across every configuration in the matrix */
-    aggregate_throughput?: MeasureValue;
-    /** `<timespan>` per `<unit>` for each configuration, e.g. `ms/entry` */
-    cost?: MeasureValue;
-    /** `<timespan>` per `<unit>` across every configuration in the matrix */
-    aggregate_cost?: MeasureValue;
-    /** What the amount is counted in. Defaults to the quantity's key. */
-    unit?: string;
-    /**
-     * Multiplier from the raw amount to `unit`.
-     * Defaults to 1, except for byte units (`MB`, `MiB`, ...), where amounts are taken to be bytes.
-     */
-    scale?: number;
+export declare const MeasureConfig: z.ZodObject<{
+    throughput: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+    aggregate_throughput: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+    cost: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+    aggregate_cost: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+    unit: z.ZodOptional<z.ZodString>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    compare: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface MeasureConfig extends z.infer<typeof MeasureConfig> {
 }
 /** One point in a test's matrix. */
-export interface ConfigurationSpec {
-    /** Defaults to the configuration's values, e.g. `size=128, entries=1000` */
-    name?: string;
-    /**
-     * Minimum CPU level needed to run this configuration.
-     * Levels are logarithmic: `n + 1` costs about twice as much as `n`.
-     */
-    cpu?: number;
-    /** Minimum memory level needed to run this configuration. Also logarithmic. */
-    mem?: number;
-    /** Passed to the test, and the source of measurement amounts. */
-    value: Record<string, number>;
+export declare const CaseConfig: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    cpu: z.ZodOptional<z.ZodNumber>;
+    mem: z.ZodOptional<z.ZodNumber>;
+    value: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export interface CaseConfig extends z.infer<typeof CaseConfig> {
 }
-export interface TestSpec {
-    /** Resolved relative to the config file */
-    path: string;
-    /** Defaults to `path` */
-    name?: string;
-    measure?: Record<string, MeasureSpec>;
-    configurations: ConfigurationSpec[];
-    /** Flags from the suite's pool to apply, or flags declared inline. The matrix runs once per combination. */
-    flags?: string[] | Record<string, unknown[]>;
-    iterations?: number;
-    warmup?: number;
+export declare const TestConfig: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    measure: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        throughput: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+        aggregate_throughput: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+        cost: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+        aggregate_cost: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+        unit: z.ZodOptional<z.ZodString>;
+        scale: z.ZodOptional<z.ZodNumber>;
+        compare: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    configurations: z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        cpu: z.ZodOptional<z.ZodNumber>;
+        mem: z.ZodOptional<z.ZodNumber>;
+        value: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+    flags: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>]>>;
+    iterations: z.ZodOptional<z.ZodNumber>;
+    warmup: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface TestConfig extends z.infer<typeof TestConfig> {
 }
-export interface SuiteSpec {
-    /** Timed runs per configuration. @default 5 */
-    iterations?: number;
-    /** Untimed runs before the timed ones. @default 1 */
-    warmup?: number;
-    /** Flag pool that tests can draw from by name. */
-    flags?: Record<string, unknown[]>;
-    /** Shell command that makes a git reference's worktree runnable. */
-    build?: string;
-    /** Directory copied into a reference's worktree so every reference runs today's tests. Defaults to the config file's directory. */
-    root?: string;
-    tests: TestSpec[];
+export declare const SuiteConfig: z.ZodObject<{
+    iterations: z.ZodOptional<z.ZodNumber>;
+    warmup: z.ZodOptional<z.ZodNumber>;
+    flags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+    build: z.ZodOptional<z.ZodString>;
+    root: z.ZodOptional<z.ZodString>;
+    tests: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        measure: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            throughput: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+            aggregate_throughput: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+            cost: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+            aggregate_cost: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"ns" | "us" | "ms" | "s">]>>;
+            unit: z.ZodOptional<z.ZodString>;
+            scale: z.ZodOptional<z.ZodNumber>;
+            compare: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        configurations: z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            cpu: z.ZodOptional<z.ZodNumber>;
+            mem: z.ZodOptional<z.ZodNumber>;
+            value: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>>;
+        flags: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>]>>;
+        iterations: z.ZodOptional<z.ZodNumber>;
+        warmup: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface SuiteConfig extends z.infer<typeof SuiteConfig> {
 }
 /** Config files are looked for at these paths, in order, relative to the working directory. */
 export declare const configPaths: string[];
 export declare const defaultBuild = "npm install --no-audit --no-fund && npm run build";
-/** A single reported column, derived from one `MeasureSpec` entry. */
+/** A single reported column, derived from one `MeasureConfig` entry. */
 export interface Metric {
     /** The quantity this is derived from */
     key: string;
@@ -76,6 +98,8 @@ export interface Metric {
     scale: number;
     unit: string;
     higherIsBetter: boolean;
+    /** Whether the measurement asked to be the one comparisons report */
+    compare: boolean;
 }
 /** A test with its defaults filled in and its measurements flattened into metrics. */
 export interface Test {
@@ -86,7 +110,7 @@ export interface Test {
     /** Path as written, for display */
     path: string;
     metrics: Metric[];
-    configurations: Required<Pick<ConfigurationSpec, 'name' | 'cpu' | 'mem' | 'value'>>[];
+    configurations: Required<Pick<CaseConfig, 'name' | 'cpu' | 'mem' | 'value'>>[];
     flags: Record<string, unknown[]>;
     iterations: number;
     warmup: number;
@@ -101,10 +125,11 @@ export interface Suite {
 }
 /** Find the config file, starting from `from` and walking up to the filesystem root. */
 export declare function findConfig(from?: string): string | null;
-/** Parse and validate an already-loaded suite. `file` is used to resolve test paths. */
+/** Validate already-loaded config data. `file` is what test paths resolve against. */
 export declare function parseSuite(data: unknown, file: string): Suite;
 export declare function loadSuite(file: string): Suite;
 /** Every combination of the given flags, in declaration order. Always at least one (possibly empty) combination. */
 export declare function flagCombinations(flags: Record<string, unknown[]>): Record<string, unknown>[];
 /** A stable, human-readable label for a flag combination. Empty when there are no flags. */
 export declare function flagLabel(flags: Record<string, unknown>): string;
+export {};

package/dist/config.js

@@ -1,23 +1,114 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { existsSync, readFileSync } from 'node:fs';
+import * as io from 'ioium/node';
+import { existsSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { isTimespan, unitScale } from './units.js';
+import * as z from 'zod';
+import { timespanOrder, unitScale } from './units.js';
+const Timespan = z.literal(timespanOrder);
+/** A measurement is either derived at an inferred timespan (`true`) or at an explicit one. */
+export const MeasureValue = z.union([z.boolean(), Timespan], {
+    error: 'expected true, false, or a timespan ("ns", "us", "ms", "s")',
+});
+/** The four ways a quantity can be turned into a reported measurement. */
+const measurements = ['throughput', 'aggregate_throughput', 'cost', 'aggregate_cost'];
+/**
+ * How to turn one of a test's quantities into a reported measurement.
+ * The quantity's amount per iteration comes from what `test` returns, falling back to the configuration value.
+ */
+export const MeasureConfig = z
+    .object({
+    // `<unit>`s per `<timespan>` for each configuration, e.g. `MB/s`
+    throughput: MeasureValue.optional(),
+    // `<unit>`s per `<timespan>` across every configuration in the matrix
+    aggregate_throughput: MeasureValue.optional(),
+    // `<timespan>` per `<unit>` for each configuration, e.g. `ms/entry`
+    cost: MeasureValue.optional(),
+    // `<timespan>` per `<unit>` across every configuration in the matrix
+    aggregate_cost: MeasureValue.optional(),
+    // What the amount is counted in. Defaults to the quantity's key.
+    unit: z.string().optional(),
+    // Multiplier from the raw amount to `unit`. Defaults to 1, except for byte units, where amounts are bytes.
+    scale: z.number().optional(),
+    // If any of a test's measurements set this, comparisons report only those, and the first is
+    // the one speedup factors are computed from
+    compare: z.boolean().optional(),
+})
+    .refine(cfg => measurements.some(field => cfg[field] !== undefined && cfg[field] !== false), 'declares no measurements; set at least one of throughput, cost, aggregate_throughput, aggregate_cost');
+/** One point in a test's matrix. */
+export const CaseConfig = z.object({
+    // Defaults to the configuration's values, e.g. `size=128, entries=1000`
+    name: z.string().optional(),
+    // Minimum CPU level needed to run this configuration. Levels are logarithmic: `n + 1` costs about twice `n`.
+    cpu: z.number().optional(),
+    // Minimum memory level needed to run this configuration. Also logarithmic.
+    mem: z.number().optional(),
+    // Passed to the test, and the source of measurement amounts
+    value: z.record(z.string(), z.number()),
+});
+/** A non-empty list of values a flag can take. */
+const flagValues = z.array(z.unknown()).min(1, 'expected a non-empty array of values');
+export const TestConfig = z.object({
+    // Resolved relative to the config file
+    path: z.string(),
+    // Defaults to `path`
+    name: z.string().optional(),
+    measure: z.record(z.string(), MeasureConfig).optional(),
+    configurations: z.array(CaseConfig).min(1, 'expected at least one configuration'),
+    // Flags from the suite's pool to apply, or flags declared inline. The matrix runs once per combination.
+    flags: z
+        .union([z.array(z.string()), z.record(z.string(), flagValues)], {
+        error: 'expected an array of flag names or an object of flag values',
+    })
+        .optional(),
+    iterations: z.number().optional(),
+    warmup: z.number().optional(),
+});
+export const SuiteConfig = z
+    .object({
+    // Timed runs per configuration. @default 5
+    iterations: z.number().optional(),
+    // Untimed runs before the timed ones. @default 1
+    warmup: z.number().optional(),
+    // Flag pool that tests can draw from by name
+    flags: z.record(z.string(), flagValues).optional(),
+    // Shell command that makes a git reference's worktree runnable
+    build: z.string().optional(),
+    // Directory copied into a reference's worktree so every reference runs today's tests.
+    // Defaults to the config file's directory.
+    root: z.string().optional(),
+    tests: z.array(TestConfig),
+})
+    // Neither of these is about one test's shape: a flag name is only meaningful against the pool,
+    // and a duplicate id only shows up once the other tests are known
+    .superRefine((spec, ctx) => {
+    const pool = spec.flags ?? {};
+    const seen = new Set();
+    for (const [i, test] of spec.tests.entries()) {
+        if (Array.isArray(test.flags)) {
+            for (const [j, name] of test.flags.entries()) {
+                if (name in pool)
+                    continue;
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['tests', i, 'flags', j],
+                    message: `no flag named ${JSON.stringify(name)} is declared by the suite`,
+                });
+            }
+        }
+        // Results are keyed by id, so a duplicate would silently merge two tests' numbers
+        const id = test.name ?? test.path;
+        if (seen.has(id))
+            ctx.addIssue({
+                code: 'custom',
+                path: ['tests', i, test.name === undefined ? 'path' : 'name'],
+                message: `more than one test is named ${JSON.stringify(id)}`,
+            });
+        seen.add(id);
+    }
+});
 /** Config files are looked for at these paths, in order, relative to the working directory. */
 export const configPaths = ['tests/perf/config.json', 'tests/perf.json', 'tests/perf.config.json', 'zbench.json'];
 export const defaultBuild = 'npm install --no-audit --no-fund && npm run build';
-class ConfigError extends Error {
-    constructor(path, message) {
-        super(`${path}: ${message}`);
-        this.name = 'ConfigError';
-    }
-}
-function check(condition, path, message) {
-    if (!condition)
-        throw new ConfigError(path, message);
-}
-function isRecord(value) {
-    return typeof value == 'object' && value !== null && !Array.isArray(value);
-}
 /** Find the config file, starting from `from` and walking up to the filesystem root. */
 export function findConfig(from = process.cwd()) {
     for (let dir = resolve(from);; dir = dirname(dir)) {
@@ -30,37 +121,29 @@ export function findConfig(from = process.cwd()) {
             return null;
     }
 }
-function parseMeasureValue(value, path) {
-    if (value === undefined || value === false)
-        return undefined;
-    if (value === true)
-        return null;
-    check(isTimespan(value), path, `expected true, false, or a timespan ("ns", "us", "ms", "s")`);
-    return value;
-}
-function parseMetrics(measure, path) {
-    if (measure === undefined)
-        return [];
-    check(isRecord(measure), path, 'expected an object');
+/** Flatten a test's measurements into one metric per declared timespan. */
+function parseMetrics(measure) {
     const metrics = [];
-    for (const [key, raw] of Object.entries(measure)) {
-        const at = `${path}.${key}`;
-        check(isRecord(raw), at, 'expected an object');
-        const spec = raw;
+    for (const [key, spec] of Object.entries(measure ?? {})) {
         const unit = spec.unit ?? key;
-        check(typeof unit == 'string', `${at}.unit`, 'expected a string');
-        check(spec.scale === undefined || typeof spec.scale == 'number', `${at}.scale`, 'expected a number');
         const scale = spec.scale ?? unitScale(unit);
         for (const kind of ['throughput', 'cost']) {
             for (const aggregate of [false, true]) {
-                const field = aggregate ? `aggregate_${kind}` : kind;
-                const span = parseMeasureValue(spec[field], `${at}.${field}`);
-                if (span === undefined)
+                const value = spec[aggregate ? `aggregate_${kind}` : kind];
+                if (value === undefined || value === false)
                     continue;
-                metrics.push({ key, kind, aggregate, span, scale, unit, higherIsBetter: kind == 'throughput' });
+                metrics.push({
+                    key,
+                    kind,
+                    aggregate,
+                    span: value === true ? null : value,
+                    scale,
+                    unit,
+                    higherIsBetter: kind == 'throughput',
+                    compare: spec.compare ?? false,
+                });
             }
         }
-        check(metrics.some(m => m.key == key), at, 'declares no measurements; set at least one of throughput, cost, aggregate_throughput, aggregate_cost');
     }
     return metrics;
 }
@@ -69,96 +152,57 @@ function defaultName(value) {
         .map(([k, v]) => `${k}=${v}`)
         .join(', ');
 }
-function parseFlags(flags, pool, path) {
-    if (flags === undefined)
-        return undefined;
-    if (Array.isArray(flags)) {
-        const selected = {};
-        for (const name of flags) {
-            check(typeof name == 'string', path, 'expected an array of flag names');
-            check(name in pool, path, `no flag named ${JSON.stringify(name)} is declared by the suite`);
-            selected[name] = pool[name];
-        }
-        return selected;
-    }
-    check(isRecord(flags), path, 'expected an array of flag names or an object of flag values');
-    const inline = {};
-    for (const [name, values] of Object.entries(flags)) {
-        check(Array.isArray(values) && values.length > 0, `${path}.${name}`, 'expected a non-empty array of values');
-        inline[name] = values;
-    }
-    return inline;
+/** A test's flags: the pool entries it named, the ones it declared inline, or none. */
+function parseFlags(flags, pool) {
+    if (!flags)
+        return {};
+    // Every name was checked against the pool while the suite was validated
+    if (Array.isArray(flags))
+        return Object.fromEntries(flags.map(name => [name, pool[name]]));
+    return flags;
 }
-/** Parse and validate an already-loaded suite. `file` is used to resolve test paths. */
-export function parseSuite(data, file) {
+const ConfigFile = z.preprocess(data => (Array.isArray(data) ? { tests: data } : data), SuiteConfig);
+/** Turn validated config data into a suite. `file` is what test paths resolve against. */
+function toSuite(cfg, file) {
     const dir = dirname(resolve(file));
-    const spec = Array.isArray(data) ? { tests: data } : data;
-    check(isRecord(spec), 'config', 'expected an array of tests or an object with a `tests` array');
-    check(Array.isArray(spec.tests), 'config.tests', 'expected an array');
-    const pool = {};
-    if (spec.flags !== undefined) {
-        check(isRecord(spec.flags), 'config.flags', 'expected an object of flag values');
-        for (const [name, values] of Object.entries(spec.flags)) {
-            check(Array.isArray(values) && values.length > 0, `config.flags.${name}`, 'expected a non-empty array of values');
-            pool[name] = values;
-        }
-    }
-    const iterations = spec.iterations ?? 5;
-    const warmup = spec.warmup ?? 1;
-    const tests = spec.tests.map((test, i) => {
-        const at = `config.tests[${i}]`;
-        check(isRecord(test), at, 'expected an object');
-        check(typeof test.path == 'string', `${at}.path`, 'expected a string');
-        check(Array.isArray(test.configurations), `${at}.configurations`, 'expected an array');
-        const configurations = test.configurations.map((config, j) => {
-            const cat = `${at}.configurations[${j}]`;
-            check(isRecord(config), cat, 'expected an object');
-            check(isRecord(config.value), `${cat}.value`, 'expected an object');
-            for (const [k, v] of Object.entries(config.value))
-                check(typeof v == 'number', `${cat}.value.${k}`, 'expected a number');
-            return {
-                name: config.name ?? defaultName(config.value),
-                cpu: config.cpu ?? 0,
-                mem: config.mem ?? 0,
-                value: config.value,
-            };
-        });
-        check(configurations.length > 0, `${at}.configurations`, 'expected at least one configuration');
-        return {
-            // The name, so one file can back several tests that differ only in their matrix
-            id: test.name ?? test.path,
-            name: test.name ?? test.path,
-            file: isAbsolute(test.path) ? test.path : resolve(dir, test.path),
-            path: test.path,
-            metrics: parseMetrics(test.measure, `${at}.measure`),
-            configurations,
-            flags: parseFlags(test.flags, pool, `${at}.flags`) ?? {},
-            iterations: test.iterations ?? iterations,
-            warmup: test.warmup ?? warmup,
-        };
-    });
-    // Results are keyed by id, so a duplicate would silently merge two tests' numbers
-    const seen = new Set();
-    for (const test of tests) {
-        check(!seen.has(test.id), `config.tests`, `more than one test is named ${JSON.stringify(test.id)}`);
-        seen.add(test.id);
-    }
+    const iterations = cfg.iterations ?? 5;
+    const warmup = cfg.warmup ?? 1;
+    const pool = cfg.flags ?? {};
+    const tests = cfg.tests.map((test) => ({
+        id: test.name ?? test.path,
+        name: test.name ?? test.path,
+        file: isAbsolute(test.path) ? test.path : resolve(dir, test.path),
+        path: test.path,
+        metrics: parseMetrics(test.measure),
+        configurations: test.configurations.map(config => ({
+            name: config.name ?? defaultName(config.value),
+            cpu: config.cpu ?? 0,
+            mem: config.mem ?? 0,
+            value: config.value,
+        })),
+        flags: parseFlags(test.flags, pool),
+        iterations: test.iterations ?? iterations,
+        warmup: test.warmup ?? warmup,
+    }));
     return {
         file: resolve(file),
-        root: spec.root ? resolve(dir, spec.root) : dir,
-        build: spec.build ?? defaultBuild,
+        root: cfg.root ? resolve(dir, cfg.root) : dir,
+        build: cfg.build ?? defaultBuild,
         tests,
     };
 }
-export function loadSuite(file) {
-    let data;
+/** Validate already-loaded config data. `file` is what test paths resolve against. */
+export function parseSuite(data, file) {
     try {
-        data = JSON.parse(readFileSync(file, 'utf-8'));
+        return toSuite(ConfigFile.parse(data), file);
     }
     catch (e) {
-        throw new ConfigError(file, e.message);
+        // eslint-disable-next-line @typescript-eslint/only-throw-error
+        throw io.errorText(e);
     }
-    return parseSuite(data, file);
+}
+export function loadSuite(file) {
+    return toSuite(io.readJSON(file, ConfigFile), file);
 }
 /** Every combination of the given flags, in declaration order. Always at least one (possibly empty) combination. */
 export function flagCombinations(flags) {

package/dist/index.d.ts

@@ -4,7 +4,6 @@ export * from './config.js';
 export * from './measure.js';
 export * from './refs.js';
 export * from './report.js';
-export * from './runner.js';
 export * from './stats.js';
 export * from './types.js';
 export * from './units.js';

package/dist/index.js

@@ -5,7 +5,6 @@ export * from './config.js';
 export * from './measure.js';
 export * from './refs.js';
 export * from './report.js';
-export * from './runner.js';
 export * from './stats.js';
 export * from './types.js';
 export * from './units.js';

package/dist/isolate.d.ts

@@ -1,7 +1,8 @@
-import { type CaseResult } from './runner.js';
-/** Everything a child process needs to run exactly one matrix. */
-export interface WorkerSpec {
-    /** Path to the config file, as seen from the child's working directory */
+import type { CaseResult } from './types.js';
+import type { Test } from './config.js';
+/** Everything a worker needs to run exactly one matrix. */
+export interface WorkerConfig {
+    /** Absolute path to the config file, inside the reference's worktree when there is one */
     config: string;
     /** The test's id */
     test: string;
@@ -12,16 +13,11 @@ export interface WorkerSpec {
     cpu?: number;
     mem?: number;
     all?: boolean;
-    /** Where the child writes its results */
-    out: string;
+    onCase?(test: Test, flags: Record<string, unknown>, configuration: string, index: number, total: number): void;
 }
-/** Run one matrix and write the results where the parent expects them. */
-export declare function runWorker(specPath: string): Promise<void>;
 /**
- * Run one matrix in a fresh process.
- * Every matrix gets its own heap and its own module graph, which is what keeps one configuration
- * from warming up (or poisoning) the next, and what lets a git reference's own build be loaded.
+ * Run one matrix in a fresh worker thread.
  */
-export declare function runIsolated(spec: Omit<WorkerSpec, 'out'>, cwd: string, cli: string, 
+export declare function runIsolated(spec: WorkerConfig, 
 /** Seconds before the worker is killed. 0 waits forever. */
 timeout?: number): Promise<CaseResult[]>;