@effect-bench/core 0.0.0-stage → 0.0.1

package/README.md

@@ -1,3 +1,88 @@
-# Temporary Holding Version
+# effect-bench
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Benchmarks for [Effect](https://effect.website) code, with JSON output and baseline verdicts built for agents and CI.
+
+Community project, not affiliated with the Effect team.
+
+```ts
+// bench/schema.bench.ts
+import { Bench } from '@effect-bench/core'
+import { Effect } from 'effect'
+
+export default Bench.suite('workflowCompiler', { layer: NodeRegistry.layer })(
+  Bench.params('compile', { nodes: [10, 100, 1000] }, {
+    prepare: ({ nodes }) => Effect.succeed(makeDraft(nodes)),   // untimed
+    run: draft => compile(draft),                                // timed
+  }),
+  Bench.group('decode', { baseline: 'sync' })(
+    Bench.sync('sync', () => decodeSync(lead)),
+    Bench.make('effect', () => decodeEffect(lead)),
+  ),
+  Bench.sync('encode', () => encode(payload), { budget: { p99: '5 millis' } }),
+)
+```
+
+```bash
+effect-bench list
+effect-bench run --save before          # store a baseline
+effect-bench run --compare before --json
+effect-bench check --compare before     # exit 1 on a regression or blown budget
+effect-bench run --rigorous --forks 8   # more processes for a tighter interval
+```
+
+## Writing benches
+
+| Constructor | Measures |
+| --- | --- |
+| `Bench.make(name, effect)` | re-runs one Effect value |
+| `Bench.make(name, ctx => effect)` | builds and runs a fresh Effect per operation |
+| `Bench.sync(name, ctx => value)` | a plain function |
+| `Bench.params(name, matrix, { prepare?, run \| sync })` | one bench per combination, ids like `compile[nodes=100]` |
+| `Bench.group(name, { baseline })(...)` | alternatives, reported as a ratio to the baseline |
+
+`Bench.suite(name, { layer, setup, ...options })` builds `layer` once per suite and runs `setup` in the suite's scope; its result is the `ctx` each bench receives. Benches can only use services the layer provides — anything else is a type error.
+
+Options (suite or bench): `samples`, `minTime`, `warmup`, `memory` (GC + heap delta per sample), `budget: { p50, p99 }`, `tags`, and `check` (validates one result before timing).
+
+## Output
+
+`--json` prints one record per line on stdout: a `result` per bench and a final `summary`. Logs go to stderr.
+
+```json
+{"type":"result","schemaVersion":1,"status":"ok","id":"leadSchema/decode/effect","stats":{"medianNs":858,"p99Ns":943,"opsPerSec":1165161,...},"comparison":{"baseline":"before","change":0.051,"ci":[0.039,0.058],"verdict":"slower","stale":false},"relative":{"baselineId":"leadSchema/decode/sync","ratio":5.1}}
+{"type":"summary","schemaVersion":1,"total":4,"failed":0,"regressions":1,"budgetsExceeded":0,"stale":0,"exitCode":1}
+```
+
+## How verdicts work
+
+The CLI measures each suite in several fresh processes (`--forks`, default 3; 6 with `--rigorous`), interleaved fork by fork so slow drift spreads across suites. Drift between processes — JIT decisions, CPU frequency — is much larger than noise within one run, so each fork's median counts as one observation: the 95% interval for the change is a pooled t-interval on log medians.
+
+`faster`/`slower` only when the whole interval is beyond the noise threshold (`--threshold`, default 3%), `same` when it is inside, `inconclusive` otherwise. On a laptop with 3 forks per side, repeated comparisons of unchanged code gave no false verdicts in 96 tries; a 15% slowdown was flagged every time and a 5% one most of the time (otherwise `inconclusive`). Treat `inconclusive` as "measure more": `--rigorous` or more `--forks`.
+
+`--forks 0` measures in the CLI process, and `Runner.run` does the same when called from code. With a single fork on both sides the interval only sees within-run noise and will overstate confidence.
+
+Exit codes: `0` ok, `1` regression or blown budget, `2` failed bench or error, `3` baseline recorded on another runtime or machine.
+
+## Config
+
+Optional `effect-bench.config.ts` in the working directory:
+
+```ts
+import { BenchConfig } from '@effect-bench/cli'
+
+export default BenchConfig.make({
+  include: ['**/bench/*.bench.ts'],
+  modes: { ci: { samples: 50, minTime: '1 second', forks: 5 } },
+  noiseThreshold: 0.05,
+})
+```
+
+## Packages
+
+- `@effect-bench/core` — DSL, measuring loop, stats, comparison, runner, reporters. No platform imports.
+- `@effect-bench/node` — hrtime clock, GC and heap, environment fingerprint, file baseline store.
+- `@effect-bench/cli` — `effect-bench` command.
+
+## Known limitations
+
+- Bench files are loaded with Node's built-in type stripping, so they must use erasable TypeScript syntax only.

package/dist/src/Bench.d.ts

@@ -0,0 +1,82 @@
+import type { Duration, Scope } from 'effect';
+import { Effect, Layer } from 'effect';
+export type ParamValue = string | number | boolean;
+export type Params = Readonly<Record<string, ParamValue>>;
+export interface Budget {
+    readonly p50?: Duration.Input;
+    readonly p99?: Duration.Input;
+}
+export interface Options {
+    /** Minimum number of samples to collect. */
+    readonly samples?: number;
+    /** Keep sampling until at least this much time has passed. */
+    readonly minTime?: Duration.Input;
+    readonly warmup?: Duration.Input;
+    /** Force a GC before every sample and record the heap delta. Needs `--expose-gc`. */
+    readonly memory?: boolean;
+    readonly budget?: Budget;
+    readonly tags?: ReadonlyArray<string>;
+}
+export type Operation = {
+    readonly _tag: 'Sync';
+    readonly run: () => unknown;
+} | {
+    readonly _tag: 'Effect';
+    readonly run: Effect.Effect<unknown, unknown>;
+};
+export interface Bench<in Ctx = any, out R = any> {
+    readonly _tag: 'Bench';
+    readonly name: string;
+    readonly params: Params;
+    readonly group: {
+        readonly name: string;
+        readonly baseline: string;
+    } | undefined;
+    readonly options: Options;
+    readonly check: ((value: unknown) => boolean) | undefined;
+    readonly prepare: (ctx: Ctx) => Effect.Effect<Operation, unknown, R>;
+}
+/** Type relations between layer, setup and benches are enforced by `suite`; the runner only needs the erased shape. */
+export interface Suite {
+    readonly _tag: 'Suite';
+    readonly name: string;
+    readonly layer: Layer.Layer<never, unknown>;
+    readonly setup: Effect.Effect<unknown, unknown, any>;
+    readonly options: Options;
+    readonly benches: ReadonlyArray<Bench>;
+}
+export interface SuiteOptions<Ctx, ROut> extends Options {
+    readonly layer?: Layer.Layer<ROut, unknown>;
+    readonly setup?: Effect.Effect<Ctx, unknown, ROut | Scope.Scope>;
+}
+type Entry<Ctx, R> = Bench<Ctx, R> | ReadonlyArray<Bench<Ctx, R>>;
+export declare const suite: <Ctx = undefined, ROut = never>(name: string, options?: SuiteOptions<Ctx, ROut>) => (...entries: ReadonlyArray<Entry<Ctx, ROut>>) => Suite;
+type BenchOptions<A> = Options & {
+    readonly check?: (value: A) => boolean;
+};
+/**
+ * An Effect value is re-run as is; a function is called for every operation, so building the Effect is measured too.
+ */
+export declare const make: <Ctx = unknown, A = unknown, E = never, R = never>(name: string, run: Effect.Effect<A, E, R> | ((ctx: Ctx) => Effect.Effect<A, E, R>), options?: BenchOptions<A>) => Bench<Ctx, R>;
+export declare const sync: <Ctx = unknown, A = unknown>(name: string, run: (ctx: Ctx) => A, options?: BenchOptions<A>) => Bench<Ctx, never>;
+type Matrix = Readonly<Record<string, ReadonlyArray<ParamValue>>>;
+export type ParamsOf<M extends Matrix> = {
+    readonly [K in keyof M]: M[K][number];
+};
+interface ParamsPrepare<M extends Matrix, Ctx, I, R> {
+    readonly prepare?: (params: ParamsOf<M>, ctx: Ctx) => Effect.Effect<I, unknown, R>;
+}
+export declare const params: {
+    <const M extends Matrix, Ctx = unknown, I = ParamsOf<M>, A = unknown, E = never, R = never>(name: string, matrix: M, spec: ParamsPrepare<M, Ctx, I, R> & BenchOptions<A> & {
+        readonly run: (input: I, ctx: Ctx) => Effect.Effect<A, E, R>;
+    }): ReadonlyArray<Bench<Ctx, R>>;
+    <const M extends Matrix, Ctx = unknown, I = ParamsOf<M>, A = unknown, R = never>(name: string, matrix: M, spec: ParamsPrepare<M, Ctx, I, R> & BenchOptions<A> & {
+        readonly sync: (input: I, ctx: Ctx) => A;
+    }): ReadonlyArray<Bench<Ctx, R>>;
+};
+export declare const group: (name: string, options: {
+    readonly baseline: string;
+}) => <Ctx, R>(...entries: ReadonlyArray<Entry<Ctx, R>>) => ReadonlyArray<Bench<Ctx, R>>;
+export declare const benchId: (suiteName: string, bench: Pick<Bench, 'name' | 'params' | 'group'>) => string;
+export {};
+//# sourceMappingURL=Bench.d.ts.map

package/dist/src/Bench.d.ts.map

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

package/dist/src/Bench.js

@@ -0,0 +1,36 @@
+import { Effect, Layer } from 'effect';
+export const suite = (name, options = {}) => (...entries) => {
+    const { layer, setup, ...defaults } = options;
+    return {
+        _tag: 'Suite',
+        name,
+        layer: layer ?? Layer.empty,
+        setup: setup ?? Effect.undefined,
+        options: defaults,
+        benches: entries.flat(),
+    };
+};
+const makeBench = (name, prepare, { check, ...options }, params = {}) => ({ _tag: 'Bench', name, params, group: undefined, options, check, prepare });
+/**
+ * An Effect value is re-run as is; a function is called for every operation, so building the Effect is measured too.
+ */
+export const make = (name, run, options = {}) => makeBench(name, ctx => Effect.map(Effect.context(), context => ({
+    _tag: 'Effect',
+    run: Effect.provideContext(Effect.isEffect(run) ? run : Effect.suspend(() => run(ctx)), context),
+})), options);
+export const sync = (name, run, options = {}) => makeBench(name, ctx => Effect.succeed({ _tag: 'Sync', run: () => run(ctx) }), options);
+const combinations = (matrix) => Object.entries(matrix).reduce((acc, [key, values]) => acc.flatMap(combo => values.map(value => ({ ...combo, [key]: value }))), [{}]);
+export const params = (name, matrix, { prepare, run, sync: runSync, ...options }) => combinations(matrix).map(combo => makeBench(name, ctx => Effect.gen(function* () {
+    const input = prepare === undefined ? combo : yield* prepare(combo, ctx);
+    if (runSync !== undefined)
+        return { _tag: 'Sync', run: () => runSync(input, ctx) };
+    const context = yield* Effect.context();
+    return { _tag: 'Effect', run: Effect.provideContext(run(input, ctx), context) };
+}), options, combo));
+export const group = (name, options) => (...entries) => entries.flat().map(bench => ({ ...bench, group: { name, baseline: options.baseline } }));
+const paramsSuffix = (params) => {
+    const entries = Object.entries(params);
+    return entries.length === 0 ? '' : `[${entries.map(([key, value]) => `${key}=${value}`).join(',')}]`;
+};
+export const benchId = (suiteName, bench) => [suiteName, bench.group?.name, `${bench.name}${paramsSuffix(bench.params)}`].filter(Boolean).join('/');
+//# sourceMappingURL=Bench.js.map

package/dist/src/Bench.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bench.js","sourceRoot":"","sources":["../../src/Bench.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAsDtC,MAAM,CAAC,MAAM,KAAK,GAChB,CAAgC,IAAY,EAAE,OAAO,GAA4B,EAAE,EAAE,EAAE,CACvF,CAAC,GAAG,OAAwC,EAAS,EAAE;IACrD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,QAAQ,EAAE,GAAG,OAAO,CAAA;IAC7C,OAAO;QACL,IAAI,EAAE,OAAO;QACb,IAAI;QACJ,KAAK,EAAE,KAAK,IAAI,KAAK,CAAC,KAAK;QAC3B,KAAK,EAAE,KAAK,IAAI,MAAM,CAAC,SAAS;QAChC,OAAO,EAAE,QAAQ;QACjB,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE;KACxB,CAAA;AACH,CAAC,CAAA;AAIH,MAAM,SAAS,GAAG,CAChB,IAAY,EACZ,OAA2D,EAC3D,EAAE,KAAK,EAAE,GAAG,OAAO,EAAqB,EACxC,MAAM,GAAW,EAAE,EACJ,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAA;AAEhG;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,IAAY,EACZ,GAAoE,EACpE,OAAO,GAAoB,EAAE,EACd,EAAE,CACjB,SAAS,CACP,IAAI,EACJ,GAAG,CAAC,EAAE,CACJ,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,EAAK,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IAC1C,IAAI,EAAE,QAAiB;IACvB,GAAG,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC;CACjG,CAAC,CAAC,EACL,OAAO,CACR,CAAA;AAEH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,IAAY,EACZ,GAAoB,EACpB,OAAO,GAAoB,EAAE,EACV,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAA;AAM9G,MAAM,YAAY,GAAG,CAAmB,MAAS,EAA8B,EAAE,CAC/E,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAC3B,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAC/F,CAAC,EAAE,CAAC,CACyB,CAAA;AAMjC,MAAM,CAAC,MAAM,MAAM,GAYf,CACF,IAAY,EACZ,MAAc,EACd,EACE,OAAO,EACP,GAAG,EACH,IAAI,EAAE,OAAO,EACb,GAAG,OAAO,EAKa,EACO,EAAE,CAClC,YAAY,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAC/B,SAAS,CACP,IAAI,EACJ,GAAG,CAAC,EAAE,CACJ,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,KAAK,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IACxE,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,MAAe,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAA;IAC3F,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,EAAW,CAAA;IAChD,OAAO,EAAE,IAAI,EAAE,QAAiB,EAAE,GAAG,EAAE,MAAM,CAAC,cAAc,CAAC,GAAI,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,CAAA;AAC3F,CAAC,CAAC,EACJ,OAAO,EACP,KAAK,CACN,CACF,CAAA;AAEH,MAAM,CAAC,MAAM,KAAK,GAChB,CAAC,IAAY,EAAE,OAAsC,EAAE,EAAE,CACzD,CAAS,GAAG,OAAqC,EAAgC,EAAE,CACjF,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAA;AAE5F,MAAM,YAAY,GAAG,CAAC,MAAc,EAAU,EAAE;IAC9C,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;IACtC,OAAO,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;AACtG,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,SAAiB,EAAE,KAA+C,EAAU,EAAE,CACpG,CAAC,SAAS,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA"}

package/dist/src/BenchResult.d.ts

@@ -0,0 +1,280 @@
+import { Schema } from 'effect';
+export declare const schemaVersion = 2;
+export declare const Stats: Schema.Struct<{
+    readonly samples: Schema.Number;
+    readonly outliers: Schema.Number;
+    readonly meanNs: Schema.Number;
+    readonly medianNs: Schema.Number;
+    readonly p75Ns: Schema.Number;
+    readonly p99Ns: Schema.Number;
+    readonly minNs: Schema.Number;
+    readonly maxNs: Schema.Number;
+    readonly madNs: Schema.Number;
+    readonly rme: Schema.Number;
+    /** Null when the median is below what the clock can resolve. */
+    readonly opsPerSec: Schema.NullOr<Schema.Number>;
+}>;
+export type Stats = typeof Stats.Type;
+export declare const Environment: Schema.Struct<{
+    readonly runtime: Schema.String;
+    readonly runtimeVersion: Schema.String;
+    readonly platform: Schema.String;
+    readonly arch: Schema.String;
+    readonly cpu: Schema.String;
+    readonly cpus: Schema.Number;
+    readonly gitSha: Schema.NullOr<Schema.String>;
+    readonly gitDirty: Schema.NullOr<Schema.Boolean>;
+}>;
+export type Environment = typeof Environment.Type;
+export declare const Verdict: Schema.Literals<readonly ["faster", "slower", "same", "inconclusive"]>;
+export type Verdict = typeof Verdict.Type;
+export declare const Comparison: Schema.Struct<{
+    readonly baseline: Schema.String;
+    readonly baselineMedianNs: Schema.Number;
+    readonly change: Schema.Number;
+    readonly ci: Schema.Tuple<readonly [Schema.Number, Schema.Number]>;
+    readonly verdict: Schema.Literals<readonly ["faster", "slower", "same", "inconclusive"]>;
+    /** The baseline was recorded on a different runtime or machine. */
+    readonly stale: Schema.Boolean;
+}>;
+export type Comparison = typeof Comparison.Type;
+export declare const BudgetCheck: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["ok", "exceeded"]>;
+    readonly violations: Schema.$Array<Schema.String>;
+}>;
+export type BudgetCheck = typeof BudgetCheck.Type;
+export declare const Relative: Schema.Struct<{
+    readonly baselineId: Schema.String;
+    readonly ratio: Schema.Number;
+}>;
+export type Relative = typeof Relative.Type;
+export declare const OkResult: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly suite: Schema.String;
+    readonly name: Schema.String;
+    readonly group: Schema.NullOr<Schema.String>;
+    readonly params: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literal<"ok">;
+    readonly stats: Schema.Struct<{
+        readonly samples: Schema.Number;
+        readonly outliers: Schema.Number;
+        readonly meanNs: Schema.Number;
+        readonly medianNs: Schema.Number;
+        readonly p75Ns: Schema.Number;
+        readonly p99Ns: Schema.Number;
+        readonly minNs: Schema.Number;
+        readonly maxNs: Schema.Number;
+        readonly madNs: Schema.Number;
+        readonly rme: Schema.Number;
+        /** Null when the median is below what the clock can resolve. */
+        readonly opsPerSec: Schema.NullOr<Schema.Number>;
+    }>;
+    /** Fresh processes the samples came from; comparisons resample across them. */
+    readonly forks: Schema.Number;
+    readonly batchSize: Schema.Number;
+    readonly overheadNs: Schema.Number;
+    readonly heapDeltaBytes: Schema.NullOr<Schema.Number>;
+    readonly budget: Schema.NullOr<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["ok", "exceeded"]>;
+        readonly violations: Schema.$Array<Schema.String>;
+    }>>;
+    readonly comparison: Schema.NullOr<Schema.Struct<{
+        readonly baseline: Schema.String;
+        readonly baselineMedianNs: Schema.Number;
+        readonly change: Schema.Number;
+        readonly ci: Schema.Tuple<readonly [Schema.Number, Schema.Number]>;
+        readonly verdict: Schema.Literals<readonly ["faster", "slower", "same", "inconclusive"]>;
+        /** The baseline was recorded on a different runtime or machine. */
+        readonly stale: Schema.Boolean;
+    }>>;
+    readonly relative: Schema.NullOr<Schema.Struct<{
+        readonly baselineId: Schema.String;
+        readonly ratio: Schema.Number;
+    }>>;
+}>;
+export type OkResult = typeof OkResult.Type;
+export declare const FailedResult: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly suite: Schema.String;
+    readonly name: Schema.String;
+    readonly group: Schema.NullOr<Schema.String>;
+    readonly params: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literal<"failed">;
+    readonly phase: Schema.Literals<readonly ["setup", "prepare", "check", "run"]>;
+    readonly message: Schema.String;
+}>;
+export type FailedResult = typeof FailedResult.Type;
+export declare const BenchResult: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.String;
+    readonly suite: Schema.String;
+    readonly name: Schema.String;
+    readonly group: Schema.NullOr<Schema.String>;
+    readonly params: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literal<"ok">;
+    readonly stats: Schema.Struct<{
+        readonly samples: Schema.Number;
+        readonly outliers: Schema.Number;
+        readonly meanNs: Schema.Number;
+        readonly medianNs: Schema.Number;
+        readonly p75Ns: Schema.Number;
+        readonly p99Ns: Schema.Number;
+        readonly minNs: Schema.Number;
+        readonly maxNs: Schema.Number;
+        readonly madNs: Schema.Number;
+        readonly rme: Schema.Number;
+        /** Null when the median is below what the clock can resolve. */
+        readonly opsPerSec: Schema.NullOr<Schema.Number>;
+    }>;
+    /** Fresh processes the samples came from; comparisons resample across them. */
+    readonly forks: Schema.Number;
+    readonly batchSize: Schema.Number;
+    readonly overheadNs: Schema.Number;
+    readonly heapDeltaBytes: Schema.NullOr<Schema.Number>;
+    readonly budget: Schema.NullOr<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["ok", "exceeded"]>;
+        readonly violations: Schema.$Array<Schema.String>;
+    }>>;
+    readonly comparison: Schema.NullOr<Schema.Struct<{
+        readonly baseline: Schema.String;
+        readonly baselineMedianNs: Schema.Number;
+        readonly change: Schema.Number;
+        readonly ci: Schema.Tuple<readonly [Schema.Number, Schema.Number]>;
+        readonly verdict: Schema.Literals<readonly ["faster", "slower", "same", "inconclusive"]>;
+        /** The baseline was recorded on a different runtime or machine. */
+        readonly stale: Schema.Boolean;
+    }>>;
+    readonly relative: Schema.NullOr<Schema.Struct<{
+        readonly baselineId: Schema.String;
+        readonly ratio: Schema.Number;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly suite: Schema.String;
+    readonly name: Schema.String;
+    readonly group: Schema.NullOr<Schema.String>;
+    readonly params: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literal<"failed">;
+    readonly phase: Schema.Literals<readonly ["setup", "prepare", "check", "run"]>;
+    readonly message: Schema.String;
+}>]>;
+/** One fork's measurement of a bench, before stats and comparisons. */
+export declare const RawOk: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly suite: Schema.String;
+    readonly name: Schema.String;
+    readonly group: Schema.NullOr<Schema.String>;
+    readonly params: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literal<"ok">;
+    /** Id of the group baseline this bench is reported against. */
+    readonly relativeTo: Schema.NullOr<Schema.String>;
+    readonly samplesNs: Schema.$Array<Schema.Number>;
+    readonly batchSize: Schema.Number;
+    readonly overheadNs: Schema.Number;
+    readonly heapDeltaBytes: Schema.NullOr<Schema.Number>;
+    readonly budgetNs: Schema.NullOr<Schema.Struct<{
+        readonly p50: Schema.NullOr<Schema.Number>;
+        readonly p99: Schema.NullOr<Schema.Number>;
+    }>>;
+}>;
+export type RawOk = typeof RawOk.Type;
+export declare const RawResult: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.String;
+    readonly suite: Schema.String;
+    readonly name: Schema.String;
+    readonly group: Schema.NullOr<Schema.String>;
+    readonly params: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literal<"ok">;
+    /** Id of the group baseline this bench is reported against. */
+    readonly relativeTo: Schema.NullOr<Schema.String>;
+    readonly samplesNs: Schema.$Array<Schema.Number>;
+    readonly batchSize: Schema.Number;
+    readonly overheadNs: Schema.Number;
+    readonly heapDeltaBytes: Schema.NullOr<Schema.Number>;
+    readonly budgetNs: Schema.NullOr<Schema.Struct<{
+        readonly p50: Schema.NullOr<Schema.Number>;
+        readonly p99: Schema.NullOr<Schema.Number>;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly suite: Schema.String;
+    readonly name: Schema.String;
+    readonly group: Schema.NullOr<Schema.String>;
+    readonly params: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literal<"failed">;
+    readonly phase: Schema.Literals<readonly ["setup", "prepare", "check", "run"]>;
+    readonly message: Schema.String;
+}>]>;
+export type RawResult = typeof RawResult.Type;
+export type BenchResult = typeof BenchResult.Type;
+export declare const Summary: Schema.Struct<{
+    readonly total: Schema.Number;
+    readonly failed: Schema.Number;
+    readonly regressions: Schema.Number;
+    readonly budgetsExceeded: Schema.Number;
+    readonly stale: Schema.Number;
+    readonly exitCode: Schema.Number;
+}>;
+export type Summary = typeof Summary.Type;
+export declare const BaselineEntry: Schema.Struct<{
+    readonly id: Schema.String;
+    /** Samples per fork. */
+    readonly forks: Schema.$Array<Schema.$Array<Schema.Number>>;
+    readonly stats: Schema.Struct<{
+        readonly samples: Schema.Number;
+        readonly outliers: Schema.Number;
+        readonly meanNs: Schema.Number;
+        readonly medianNs: Schema.Number;
+        readonly p75Ns: Schema.Number;
+        readonly p99Ns: Schema.Number;
+        readonly minNs: Schema.Number;
+        readonly maxNs: Schema.Number;
+        readonly madNs: Schema.Number;
+        readonly rme: Schema.Number;
+        /** Null when the median is below what the clock can resolve. */
+        readonly opsPerSec: Schema.NullOr<Schema.Number>;
+    }>;
+}>;
+export type BaselineEntry = typeof BaselineEntry.Type;
+export declare const Baseline: Schema.Struct<{
+    readonly schemaVersion: Schema.Number;
+    readonly name: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly environment: Schema.Struct<{
+        readonly runtime: Schema.String;
+        readonly runtimeVersion: Schema.String;
+        readonly platform: Schema.String;
+        readonly arch: Schema.String;
+        readonly cpu: Schema.String;
+        readonly cpus: Schema.Number;
+        readonly gitSha: Schema.NullOr<Schema.String>;
+        readonly gitDirty: Schema.NullOr<Schema.Boolean>;
+    }>;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        /** Samples per fork. */
+        readonly forks: Schema.$Array<Schema.$Array<Schema.Number>>;
+        readonly stats: Schema.Struct<{
+            readonly samples: Schema.Number;
+            readonly outliers: Schema.Number;
+            readonly meanNs: Schema.Number;
+            readonly medianNs: Schema.Number;
+            readonly p75Ns: Schema.Number;
+            readonly p99Ns: Schema.Number;
+            readonly minNs: Schema.Number;
+            readonly maxNs: Schema.Number;
+            readonly madNs: Schema.Number;
+            readonly rme: Schema.Number;
+            /** Null when the median is below what the clock can resolve. */
+            readonly opsPerSec: Schema.NullOr<Schema.Number>;
+        }>;
+    }>>;
+}>;
+export type Baseline = typeof Baseline.Type;
+//# sourceMappingURL=BenchResult.d.ts.map

package/dist/src/BenchResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BenchResult.d.ts","sourceRoot":"","sources":["../../src/BenchResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B,eAAO,MAAM,KAAK;;;;;;;;;;;IAWhB,gEAAgE;;EAEhE,CAAA;AACF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC,eAAO,MAAM,WAAW;;;;;;;;;EAStB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD,eAAO,MAAM,OAAO,wEAAgE,CAAA;AACpF,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC,eAAO,MAAM,UAAU;;;;;;IAMrB,mEAAmE;;EAEnE,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C,eAAO,MAAM,WAAW;;;EAGtB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD,eAAO,MAAM,QAAQ;;;EAGnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAW3C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;QApDnB,gEAAgE;;;IAwDhE,+EAA+E;;;;;;;;;;;;;;;QA9B/E,mEAAmE;;;;;;;EAsCnE,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;EAKvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;QA3EtB,gEAAgE;;;IAwDhE,+EAA+E;;;;;;;;;;;;;;;QA9B/E,mEAAmE;;;;;;;;;;;;;;;;;IAiDJ,CAAA;AAEjE,uEAAuE;AACvE,eAAO,MAAM,KAAK;;;;;;;;IAGhB,+DAA+D;;;;;;;;;;EAO/D,CAAA;AACF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC,eAAO,MAAM,SAAS;;;;;;;;IAVpB,+DAA+D;;;;;;;;;;;;;;;;;;;;IAUL,CAAA;AAC5D,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD,eAAO,MAAM,OAAO;;;;;;;EAOlB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC,eAAO,MAAM,aAAa;;IAExB,wBAAwB;;;;;;;;;;;;;QA3GxB,gEAAgE;;;EA8GhE,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;QANnB,wBAAwB;;;;;;;;;;;;;YA3GxB,gEAAgE;;;;EAuHhE,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA"}

package/dist/src/BenchResult.js

@@ -0,0 +1,107 @@
+import { Schema } from 'effect';
+export const schemaVersion = 2;
+export const Stats = Schema.Struct({
+    samples: Schema.Number,
+    outliers: Schema.Number,
+    meanNs: Schema.Number,
+    medianNs: Schema.Number,
+    p75Ns: Schema.Number,
+    p99Ns: Schema.Number,
+    minNs: Schema.Number,
+    maxNs: Schema.Number,
+    madNs: Schema.Number,
+    rme: Schema.Number,
+    /** Null when the median is below what the clock can resolve. */
+    opsPerSec: Schema.NullOr(Schema.Number),
+});
+export const Environment = Schema.Struct({
+    runtime: Schema.String,
+    runtimeVersion: Schema.String,
+    platform: Schema.String,
+    arch: Schema.String,
+    cpu: Schema.String,
+    cpus: Schema.Number,
+    gitSha: Schema.NullOr(Schema.String),
+    gitDirty: Schema.NullOr(Schema.Boolean),
+});
+export const Verdict = Schema.Literals(['faster', 'slower', 'same', 'inconclusive']);
+export const Comparison = Schema.Struct({
+    baseline: Schema.String,
+    baselineMedianNs: Schema.Number,
+    change: Schema.Number,
+    ci: Schema.Tuple([Schema.Number, Schema.Number]),
+    verdict: Verdict,
+    /** The baseline was recorded on a different runtime or machine. */
+    stale: Schema.Boolean,
+});
+export const BudgetCheck = Schema.Struct({
+    status: Schema.Literals(['ok', 'exceeded']),
+    violations: Schema.Array(Schema.String),
+});
+export const Relative = Schema.Struct({
+    baselineId: Schema.String,
+    ratio: Schema.Number,
+});
+const identity = {
+    id: Schema.String,
+    suite: Schema.String,
+    name: Schema.String,
+    group: Schema.NullOr(Schema.String),
+    params: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Number, Schema.Boolean])),
+    tags: Schema.Array(Schema.String),
+};
+export const OkResult = Schema.Struct({
+    status: Schema.Literal('ok'),
+    ...identity,
+    stats: Stats,
+    /** Fresh processes the samples came from; comparisons resample across them. */
+    forks: Schema.Number,
+    batchSize: Schema.Number,
+    overheadNs: Schema.Number,
+    heapDeltaBytes: Schema.NullOr(Schema.Number),
+    budget: Schema.NullOr(BudgetCheck),
+    comparison: Schema.NullOr(Comparison),
+    relative: Schema.NullOr(Relative),
+});
+export const FailedResult = Schema.Struct({
+    status: Schema.Literal('failed'),
+    ...identity,
+    phase: Schema.Literals(['setup', 'prepare', 'check', 'run']),
+    message: Schema.String,
+});
+export const BenchResult = Schema.Union([OkResult, FailedResult]);
+/** One fork's measurement of a bench, before stats and comparisons. */
+export const RawOk = Schema.Struct({
+    status: Schema.Literal('ok'),
+    ...identity,
+    /** Id of the group baseline this bench is reported against. */
+    relativeTo: Schema.NullOr(Schema.String),
+    samplesNs: Schema.Array(Schema.Number),
+    batchSize: Schema.Number,
+    overheadNs: Schema.Number,
+    heapDeltaBytes: Schema.NullOr(Schema.Number),
+    budgetNs: Schema.NullOr(Schema.Struct({ p50: Schema.NullOr(Schema.Number), p99: Schema.NullOr(Schema.Number) })),
+});
+export const RawResult = Schema.Union([RawOk, FailedResult]);
+export const Summary = Schema.Struct({
+    total: Schema.Number,
+    failed: Schema.Number,
+    regressions: Schema.Number,
+    budgetsExceeded: Schema.Number,
+    stale: Schema.Number,
+    exitCode: Schema.Number,
+});
+export const BaselineEntry = Schema.Struct({
+    id: Schema.String,
+    /** Samples per fork. */
+    forks: Schema.Array(Schema.Array(Schema.Number)),
+    stats: Stats,
+});
+export const Baseline = Schema.Struct({
+    schemaVersion: Schema.Number,
+    name: Schema.String,
+    createdAt: Schema.String,
+    environment: Environment,
+    entries: Schema.Array(BaselineEntry),
+});
+//# sourceMappingURL=BenchResult.js.map

package/dist/src/BenchResult.js.map

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

package/dist/src/Compare.d.ts

@@ -0,0 +1,22 @@
+import type { Verdict } from './BenchResult.ts';
+export interface CompareOptions {
+    /** Changes smaller than this fraction count as noise. */
+    readonly noiseThreshold: number;
+    readonly resamples?: number;
+    readonly seed?: number;
+}
+export interface Change {
+    readonly change: number;
+    readonly ci: readonly [number, number];
+    readonly verdict: Verdict;
+}
+export declare const verdictOf: ([low, high]: readonly [number, number], noiseThreshold: number) => Verdict;
+/** Two-sided 97.5% quantile of Student's t, conservative between table rows. */
+export declare const tQuantile: (df: number) => number;
+/**
+ * Drift between processes (JIT state, CPU frequency) dwarfs noise within one run, so each fork's median is one
+ * observation: a pooled t-interval on log medians. Only when both sides have a single fork does it fall back to a
+ * bootstrap over samples, which sees within-run noise only.
+ */
+export declare const compare: (current: ReadonlyArray<ReadonlyArray<number>>, baseline: ReadonlyArray<ReadonlyArray<number>>, { noiseThreshold, resamples, seed }: CompareOptions) => Change;
+//# sourceMappingURL=Compare.d.ts.map