ostia 0.1.7 → 0.2.1

package/index.d.ts

@@ -1,16 +1,57 @@
-interface RunOptions {
-    commands: (string | string[])[];
-    runs?: number;
+export declare function defineConfig(config: Partial<OstiaConfig>): Partial<OstiaConfig>;
+
+export interface CommandSpec {
+    command: string | string[];
+    label?: string;
+    /** Overrides `TimeOptions.prepare` for this command. */
+    prepare?: PrepareHook;
+    /** Overrides `TimeOptions.timeSource` for this command. */
+    timeSource?: TimeSource;
+}
+
+export interface TimeOptions {
+    commands: (string | string[] | CommandSpec)[];
+    /** Runs before every trial of every command (warmup and instrumented
+     * trials included), unmeasured, in `cwd`/`env`: a command string / argv
+     * array spawned and awaited, or a function. hyperfine's `--prepare`. A
+     * `CommandSpec.prepare` overrides it per command. */
+    prepare?: PrepareHook;
+    /** Take every command's timing from a number in its own output instead of
+     * its wall clock (e.g. a build tool's `built in 342ms` line, which
+     * excludes runtime startup). A `CommandSpec.timeSource` overrides it per
+     * command. The parsed value becomes `timing.samples`; each trial keeps
+     * `wallNs` too. */
+    timeSource?: TimeSource;
+    /** Exact trial count. When set, `budgetMs` is ignored. */
+    samples?: number;
+    /** Wall-clock time budget for the sampling loop, ms (default: a
+     * hyperfine-style ~3s min-total-time loop when neither `samples` nor
+     * `budgetMs` is given). */
+    budgetMs?: number;
+    /** Hard floor on trials when no exact `samples` count is given. */
+    minSamples?: number;
     warmup?: number;
+    /** Round-robin trials across commands (one trial per command, repeated)
+     * instead of running each command's whole trial loop to completion before
+     * the next command starts. Default: true when 2+ commands are given (a
+     * single command has nothing to interleave against). Spreads any drift
+     * over the run's wall-clock span (thermal throttling, a noisy neighbor
+     * process) evenly across every command instead of favoring whichever ran
+     * first or last. */
+    interleave?: boolean;
     cwd?: string;
     env?: Record<string, string>;
     cpu?: boolean;
     heap?: boolean;
     cpuIntervalUs?: number;
     outDir?: string;
+    /** Measure this machine's noise floor before the first command (default:
+     * true) and stamp it on the document as `environment`. Set false to skip
+     * the ~200ms reference measurement. */
+    noiseCheck?: boolean;
 }
 
-export declare function run(opts: RunOptions): Promise<ProfileDocument>;
+export declare function time(opts: TimeOptions): Promise<ProfileDocument>;
 
 interface ProfileOptions {
     intervalUs?: number;
@@ -19,13 +60,76 @@ interface ProfileOptions {
 
 interface ProfileResult<T> {
     result: T;
-    run: Run;
+    measurement: Measurement;
+    document: ProfileDocument;
 }
 
 export declare function profile<T>(fn: () => T | Promise<T>, opts?: ProfileOptions): Promise<ProfileResult<T>>;
 
+export interface WorkloadConfig {
+    label?: string;
+    command?: string[];
+    suites?: string[];
+    inputs?: string[];
+    /** `command` only. Runs before every trial (warmup included), unmeasured:
+     * a command string / argv array in both `.ts` and JSON config, or a
+     * function in `ostia.config.ts`. A function-form hook makes the workload
+     * uncacheable for `ostia ci` (its effect can't be fingerprinted), so it
+     * always executes. */
+    prepare?: PrepareHook;
+    /** `command` only. Take timing from a number in the command's own output
+     * instead of its wall clock; see `TimeSource`. */
+    timeSource?: TimeSource;
+}
+
+interface BenchConfig {
+    /** Suite file globs, resolved with Bun.Glob against the config's directory
+     * (e.g. "bench/**\/*.bench.ts"). Ignored when suite files are also given
+     * on the command line - CLI args replace this list rather than merging
+     * with it. */
+    suites?: string[];
+    preload?: string[];
+    jobs?: number | "auto";
+    budgetMs?: number;
+    samples?: number;
+    minSamples?: number;
+    gc?: boolean;
+    cpu?: boolean;
+    alloc?: boolean;
+    filter?: string;
+    isolate?: boolean;
+    outDir?: string;
+}
+
+export interface OstiaConfig {
+    runs: number | null;
+    warmup: number;
+    outDir: string;
+    baselineDir: string;
+    baseline: string;
+    cpuIntervalUs: number;
+    thresholds: Thresholds;
+    workloads: WorkloadConfig[];
+    bench?: BenchConfig;
+}
+
+interface Thresholds {
+    timingPct: number;
+    frameSelfPct: number;
+    heapTypePct: number;
+    minFrameSelfUs: number;
+    /** Significance level for the Mann-Whitney p-value: a `regressed` /
+     * `improved` verdict also requires `pValue < alpha`. */
+    alpha: number;
+    /** Bootstrap resample rounds for the timing CI. Capped work regardless:
+     * see `bootstrapMedianDiffCi`. */
+    bootstrapIterations: number;
+}
+
+export declare function compareDocuments(base: ProfileDocument, cand: ProfileDocument, thresholds?: Thresholds): Comparison[];
+
 export interface ProfileDocument {
-    schemaVersion: 1;
+    schemaVersion: 2;
     toolVersion: string;
     bunVersion: string;
     platform: {
@@ -34,8 +138,41 @@ export interface ProfileDocument {
     };
     createdAt: string;
     workloads: Workload[];
-    runs: Run[];
+    measurements: Measurement[];
     comparisons?: Comparison[];
+    /** Machine conditions when this document was measured. Additive, no
+     * schema bump. Absent when `noiseCheck: false` (or `--no-noise-check`)
+     * skipped the reference measurement. */
+    environment?: Environment;
+    /** Repo state when this document was measured, from `git rev-parse` /
+     * `git status --porcelain` in the process's cwd. Additive, no schema
+     * bump. Absent outside a git repo (or when `git` itself isn't
+     * available). Metadata only: never part of any fingerprint or id, so a
+     * commit or a dirty working tree never orphans a cached run or baseline. */
+    git?: GitMetadata;
+}
+
+interface GitMetadata {
+    sha: string;
+    branch: string;
+    dirty: boolean;
+}
+
+interface NoiseFloor {
+    /** `mad / median` of the reference workload's trial times, as a percent -
+     * how noisy this machine is right now, independent of what's being
+     * measured. */
+    floorPct: number;
+    referenceMedianNs: number;
+    samples: number;
+}
+
+interface Environment {
+    cpuModel: string;
+    cores: number;
+    loadAvg1: number;
+    loadAvg5: number;
+    noise: NoiseFloor;
 }
 
 export interface Workload {
@@ -44,6 +181,22 @@ export interface Workload {
     label?: string;
     command?: string[];
     shell?: string;
+    /** Command form of the `prepare` hook that ran before every trial of this
+     * command (`ostia time --prepare`, `time({ prepare })`, config `prepare`).
+     * Part of the workload id: the same command with and without a prepare
+     * step measures different things. A function-form hook isn't
+     * serializable and is omitted here (its source text is still hashed into
+     * the id). */
+    prepare?: string[];
+    /** Where this command's timing samples came from when not the subprocess
+     * wall clock: a regex over the command's own output and the unit of the
+     * number it captures. Part of the workload id, so the same command timed
+     * by wall clock and by its own report are two workloads. */
+    timeSource?: {
+        pattern: string;
+        group?: number;
+        unit?: "ns" | "us" | "ms" | "s";
+    };
     /** `task` is the "group/name" id the bench registry assigns; `group` is the
      * enclosing `group()` name when there is one. Renderers prefer `group` over
      * splitting `task` on "/", so task names may contain slashes. */
@@ -67,11 +220,23 @@ export interface Workload {
      * on the task, its group, or the suite), vs. sharing its suite file's
      * subprocess with other tasks. */
     isolated?: boolean;
+    /** Structured parameters this task point represents (e.g. `{ size: 800,
+     * impl: "fast" }`), from `task(name, fn, { params })` or a `sweep()` point.
+     * Lets renderers pivot and `compare` match on them instead of only on the
+     * task name. Part of the workload id when present, so two points that
+     * share a task name (a `sweep()`'s whole point) don't collide. */
+    params?: Record<string, string | number | boolean>;
+    /** From `task.skip()` or a `group.skip()` this task was inside. The runner
+     * never measures it, so this workload has no matching `Measurement`; a
+     * renderer prints it as a "- skipped" row instead of omitting it, and
+     * `compare` treats it as `unchanged` (with a `skipped` warning) rather
+     * than silently passing or failing to match it. */
+    skipped?: boolean;
 }
 
 type Phase = "timing" | "cpu" | "heap" | "memstats";
 
-interface Run {
+interface Measurement {
     id: string;
     workloadId: string;
     phase: Phase;
@@ -86,12 +251,23 @@ interface Run {
     jit?: JitTierBreakdown;
     warnings: Warning[];
     artifacts: ArtifactRef[];
-    baselineRunId?: string;
+    baselineMeasurementId?: string;
+    /** True when this timing measurement's trials were run round-robin against
+     * the other commands in the same `time()` call (`--interleave`, default on
+     * for 2+ commands) rather than run to completion before the next command
+     * started, so drift over the run's wall-clock span (thermal throttling, a
+     * noisy neighbor process) lands on every command equally instead of
+     * favoring whichever ran first or last. */
+    interleaved?: boolean;
 }
 
 interface Trial {
     i: number;
     wallNs: number;
+    /** The command's self-reported time (ns) when the workload has a
+     * `timeSource`; `timing.samples` are these, not `wallNs`, in that case.
+     * `wallNs` stays alongside so a document keeps both. */
+    reportedNs?: number;
     exitCode?: number;
     userNs?: number;
     systemNs?: number;
@@ -110,6 +286,15 @@ interface TimingStats {
         mild: number;
         severe: number;
     };
+    /** 75th percentile, ns. Optional: absent on documents saved before this
+     * field existed (`loadDocument` never backfills it). */
+    p75?: number;
+    /** 99th percentile, ns. Same caveat as `p75`. */
+    p99?: number;
+    /** Median absolute deviation, ns: the median of `|sample - median|` across
+     * all samples. A robust spread measure that (unlike stddev) isn't skewed
+     * by the long right tail typical of wall-clock timings. */
+    mad?: number;
 }
 
 interface Frame {
@@ -166,6 +351,11 @@ interface MemoryEvidence {
     maxRssBytes?: number;
     peakCommitBytes?: number;
     pageFaults?: number;
+    /** Bytes allocated per call, from `ostia bench --alloc`: heap size delta
+     * (`bun:jsc`'s `heapStats().heapSize`, falling back to
+     * `process.memoryUsage().heapUsed`) around one `Bun.gc(true)`-bracketed
+     * batch, divided by the batch size. */
+    bytesPerOp?: number;
 }
 
 interface JitTierBreakdown {
@@ -183,7 +373,7 @@ interface JitTierBreakdown {
     }[];
 }
 
-export type WarningCode = "slow-first-run" | "outliers-detected" | "fast-command" | "nonzero-exit" | "instrumented-timing" | "artifact-missing" | "empty-profile" | "below-timer-resolution" | "cache-fallback-rerun" | "low-sample-count";
+export type WarningCode = "slow-first-run" | "outliers-detected" | "fast-command" | "nonzero-exit" | "instrumented-timing" | "artifact-missing" | "empty-profile" | "below-timer-resolution" | "cache-fallback-rerun" | "low-sample-count" | "thin-comparison" | "noisy-machine" | "skipped" | "jit-cold";
 
 export interface Warning {
     code: WarningCode;
@@ -201,13 +391,28 @@ interface ArtifactRef {
 
 interface Comparison {
     id: string;
-    baselineRunId: string;
-    candidateRunId: string;
+    baselineMeasurementId: string;
+    candidateMeasurementId: string;
     timing?: {
         medianDeltaPct: number;
         meanDeltaPct: number;
+        /** Same value as `medianDeltaPct`, named for what it is used for: the
+         * effect size the verdict rule tests against `thresholds.timingPct`. */
+        effectPct: number;
+        /** 95% bootstrap confidence interval on the difference of medians,
+         * percent of the baseline median. Absent when either side had fewer
+         * than 5 samples (see the `thin-comparison` warning). */
+        ci95?: [number, number];
+        /** Two-sided Mann-Whitney U p-value, tie-corrected normal approximation.
+         * Same absence condition as `ci95`. */
+        pValue?: number;
+        /** Seed for the bootstrap's PRNG, so `ci95` is reproducible. */
+        seed?: number;
         verdict: "improved" | "regressed" | "unchanged";
     };
+    /** Attached when timing fell back to the point-estimate rule (thin
+     * samples) or otherwise carries a caveat about this comparison. */
+    warnings?: Warning[];
     frames?: {
         frameKey: string;
         name: string;
@@ -228,15 +433,54 @@ interface Comparison {
         frameSelfPct: number;
         heapTypePct: number;
         minFrameSelfUs: number;
+        alpha: number;
+        bootstrapIterations: number;
+        /** `max(timingPct, base.environment.noise.floorPct,
+         * cand.environment.noise.floorPct)` - the threshold timing was actually
+         * tested against, once machine noise widens it past `timingPct`. */
+        effectiveTimingPct: number;
     };
     verdict: "pass" | "fail";
 }
 
+export interface PrepareRun {
+    phase: "warmup" | "timing" | "cpu" | "heap";
+    index: number;
+}
+
+export type PrepareFn = (run: PrepareRun) => unknown;
+
+export type PrepareHook = string | string[] | PrepareFn;
+
+export type TimeUnit = "ns" | "us" | "ms" | "s";
+
+export interface TimeSource {
+    pattern: string | RegExp;
+    group?: number;
+    unit?: TimeUnit;
+}
+
+export declare function keep(value: unknown): void;
+
 interface BenchOptions {
     suites: string[];
-    timeBudgetMs?: number;
+    /** Wall-clock sampling budget per task, ms (default 500). */
+    budgetMs?: number;
+    /** Exact trial count per task. When set, the budget is ignored - the
+     * in-process equivalent of `time()`'s `samples`. */
+    samples?: number;
     minSamples?: number;
     gc?: boolean;
+    /** Capture one extra `phase: "cpu"` measurement per task (200ms of the
+     * task looped under the JSC sampling profiler, JIT tiers included), never
+     * mixed into the timing numbers. `TaskOptions.cpu` / `GroupOptions.cpu`
+     * override this per task or group. */
+    cpu?: boolean;
+    /** Capture one extra `phase: "memstats"` measurement per task: bytes
+     * allocated per call, from a `Bun.gc(true)`-bracketed batch.
+     * `TaskOptions.alloc` / `GroupOptions.alloc` override this per task or
+     * group. */
+    alloc?: boolean;
     filter?: string;
     /** Suite files to run at once, each still in its own child process (default:
      * 1). Files are independent by design, so this is a wall-clock win for
@@ -270,27 +514,27 @@ interface BenchOptions {
      * resolution condition Bun doesn't set by default (e.g. Svelte/Vue's
      * `browser` vs `default` builds). */
     bunFlags?: string[];
+    /** Measure this machine's noise floor before the first task per suite
+     * subprocess (default: true) and stamp it on the document as
+     * `environment`. Set false to skip the ~200ms reference measurement. */
+    noiseCheck?: boolean;
 }
 
 export declare function bench(opts: BenchOptions): Promise<ProfileDocument>;
 
-interface Thresholds {
-    timingPct: number;
-    frameSelfPct: number;
-    heapTypePct: number;
-    minFrameSelfUs: number;
-}
-
-export declare function compareDocuments(base: ProfileDocument, cand: ProfileDocument, thresholds?: Thresholds): Comparison[];
-
 export declare function range(start: number, end: number, multiplier?: number): number[];
 
+type Hook = () => unknown | Promise<unknown>;
+
 export interface TaskOptions {
     /** Marks this task as the Relative reference for its group in the table
      * renderer, mirroring mitata's `baseline()`. At most one per group. */
     baseline?: boolean;
-    /** Per-task time budget; overrides the suite-wide `--time-budget` / `timeBudgetMs`. */
-    timeBudgetMs?: number;
+    /** Per-task time budget; overrides the suite-wide `--budget` / `budgetMs`. */
+    budgetMs?: number;
+    /** Per-task exact trial count; overrides the suite-wide `--samples` /
+     * `samples`. When set, the budget is ignored for this task. */
+    samples?: number;
     /** Per-task hard floor on trials; overrides the suite-wide `--min-samples` /
      * `minSamples`. */
     minSamples?: number;
@@ -305,6 +549,30 @@ export interface TaskOptions {
     /** Overrides the suite-wide `bench({ gc })` / `--gc` (and any
      * `GroupOptions.gc`) for this task only. */
     gc?: boolean;
+    /** Overrides the suite-wide `bench({ cpu })` / `--cpu` (and any
+     * `GroupOptions.cpu`) for this task only: after the timing measurement,
+     * capture one extra `phase: "cpu"` measurement (JIT tiers included) on
+     * the same workload, never mixed into the timing numbers. */
+    cpu?: boolean;
+    /** Overrides the suite-wide `bench({ alloc })` / `--alloc` (and any
+     * `GroupOptions.alloc`) for this task only: after the timing measurement,
+     * capture one extra `phase: "memstats"` measurement with bytes
+     * allocated per call. */
+    alloc?: boolean;
+    /** Structured parameters this task represents (e.g. `{ size: 800, impl:
+     * "fast" }`), written to `Workload.params` and folded into the workload id
+     * so points with the same task name don't collide. Inside `sweep()`, the
+     * current point is inherited automatically; an explicit `params` here
+     * merges over it (explicit keys win). */
+    params?: Record<string, string | number | boolean>;
+    /** Runs once, unmeasured, immediately before this task's warmup - in the
+     * task's own process, so it works with `isolate`. No per-trial hook: that
+     * would defeat batching. Use `gc` (Bun.gc between trials) or `isolate`
+     * (a fresh process per task) for per-trial concerns instead. */
+    before?: Hook;
+    /** Runs once, unmeasured, immediately after this task's last trial. Same
+     * process/no-per-trial caveats as `before`. */
+    after?: Hook;
 }
 
 export interface GroupOptions {
@@ -317,11 +585,57 @@ export interface GroupOptions {
     /** Default `gc` for every task in this group, unless a task overrides it
      * with its own `TaskOptions.gc`. */
     gc?: boolean;
+    /** Default `cpu` for every task in this group, unless a task overrides it
+     * with its own `TaskOptions.cpu`. */
+    cpu?: boolean;
+    /** Default `alloc` for every task in this group, unless a task overrides
+     * it with its own `TaskOptions.alloc`. */
+    alloc?: boolean;
+    /** Runs once, unmeasured, before the group's first task's warmup (not
+     * before every task) - in whichever process runs that task, so it works
+     * with `isolate`. */
+    before?: Hook;
+    /** Runs once, unmeasured, after the group's last task's last trial. */
+    after?: Hook;
 }
 
-export declare function group(name: string, fn: () => void, opts?: GroupOptions): void;
+interface GroupFn {
+    (name: string, fn: () => void, opts?: GroupOptions): void;
+    /** Registers every task inside as skipped: the runner never measures
+     * them, but the document still carries their workloads (marked
+     * `Workload.skipped`). */
+    skip: (name: string, fn: () => void, opts?: GroupOptions) => void;
+    /** When any task or group in the suite uses `.only`, the runner restricts
+     * the whole suite file to only those tasks (before `--filter` narrows
+     * further) and prints a one-line notice to stderr. */
+    only: (name: string, fn: () => void, opts?: GroupOptions) => void;
+}
+
+export declare const group: GroupFn;
+
+interface TaskFn {
+    (name: string, fn: () => unknown | Promise<unknown>, opts?: TaskOptions): void;
+    /** Registers the task as skipped: the runner never measures it, but the
+     * document still carries its workload (marked `Workload.skipped`) so a
+     * renderer or `compare` can say so explicitly instead of the task simply
+     * being absent. */
+    skip: (name: string, fn: () => unknown | Promise<unknown>, opts?: TaskOptions) => void;
+    /** When any task or group in the suite uses `.only`, the runner restricts
+     * the whole suite file to only those tasks (before `--filter` narrows
+     * further) and prints a one-line notice to stderr. */
+    only: (name: string, fn: () => unknown | Promise<unknown>, opts?: TaskOptions) => void;
+}
+
+export declare const task: TaskFn;
+
+type SweepPoint<T extends Record<string, readonly unknown[]>> = {
+    [K in keyof T]: T[K][number];
+};
 
-export declare function task(name: string, fn: () => unknown | Promise<unknown>, opts?: TaskOptions): void;
+export declare function sweep<T extends Record<string, readonly unknown[]>>(dims: T, fn: (point: SweepPoint<T>) => void): void;
+
+export declare function newDocument(workloads: Workload[], measurements: Measurement[], environment?: Environment): ProfileDocument;
+export { newDocument as createDocument };
 
 export declare function saveDocument(doc: ProfileDocument, path: string): Promise<void>;
 
@@ -349,14 +663,24 @@ export interface MinimalLine {
     group?: string;
     description?: string;
     groupDescription?: string;
-    unit: "ns";
-    samples: number;
-    mean: number;
-    median: number;
-    stddev: number;
-    stddevPct: number;
-    min: number;
-    max: number;
+    /** From `task(name, fn, { params })` or a `sweep()` point. */
+    params?: Record<string, string | number | boolean>;
+    /** From `task.skip()` / `group.skip()`: no measurement was taken, so every
+     * stats field below is absent on this line. */
+    skipped?: true;
+    unit?: "ns";
+    samples?: number;
+    mean?: number;
+    median?: number;
+    stddev?: number;
+    stddevPct?: number;
+    min?: number;
+    max?: number;
+    /** 75th/99th percentile and median absolute deviation, ns. Absent on
+     * documents saved before these fields existed. */
+    p75?: number;
+    p99?: number;
+    mad?: number;
     /** Median over the group's reference median (its baseline task, else its
      * fastest). Only present when the document has more than one timing run. */
     relative?: number;
@@ -372,5 +696,10 @@ export interface MinimalLine {
         meanPct: number;
         verdict: "improved" | "regressed" | "unchanged";
         pass: boolean;
+        /** 95% bootstrap CI on the difference of medians and the Mann-Whitney
+         * p-value behind the verdict. Absent on a thin (<5 samples/side)
+         * comparison, which falls back to a point-estimate threshold. */
+        ci95?: [number, number];
+        pValue?: number;
     };
 }

package/index.js

@@ -1,2 +1,2 @@
 // @bun
-import{d,f,S,n,k,B}from"./chunk-3qbcj1m9.js";import{o,t,U,M}from"./chunk-zrck2q0b.js";export{d as bench,f as compareDocuments,U as group,t as loadDocument,B as profile,S as range,n as renderers,k as run,o as saveDocument,M as task};
+import{c,b,J,V,r,G,C,z}from"./chunk-h6579788.js";import{n,s,t,T,q,K}from"./chunk-9dqf5cxf.js";export{c as bench,b as compareDocuments,n as createDocument,G as defineConfig,q as group,T as keep,t as loadDocument,z as profile,J as range,r as renderers,s as saveDocument,V as sweep,K as task,C as time};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ostia",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "description": "Fast profiling and benchmarking for Bun.",
   "type": "module",
   "exports": {

package/runner.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 // @bun
-import{r,C,i,s,o,l,p,N,v,m,R,D,F}from"./chunk-zrck2q0b.js";var z=500,H=20,A=3,j=10,X=2,q=0.1,K=1000,Q=1e4;function J(t){let a=Math.log10(Math.max(1,t)/1e6),c=Math.round(A+X*a);return Math.min(j,Math.max(A,c))}function V(t,a){let c=Math.floor(a/t);return Math.min(H,Math.max(c,J(t)))}var L=0;function O(t){if(typeof t==="number")L+=t;else if(t!==void 0&&t!==null)L+=1}function I(t){return t!==null&&typeof t==="object"&&typeof t.then==="function"}function G(t,a){return Math.max(1,Math.ceil(K/t),Math.ceil(a/(t*Q)))}async function U(t,a={}){let c=(a.timeBudgetMs??z)*1e6,e=c*(a.warmupFraction??q),S=Bun.nanoseconds(),g=0,B=0;while(B<e){let u=t();O(I(u)?await u:u),g++,B=Bun.nanoseconds()-S}let f;if(g>0)f=Math.max(1,B/g);else{let u=Bun.nanoseconds(),b=t();O(I(b)?await b:b),f=Math.max(1,Bun.nanoseconds()-u)}let d=G(f,c);if(d>1){let u=Bun.nanoseconds();for(let b=0;b<d;b++){let M=t();O(I(M)?await M:M)}f=Math.max(1,(Bun.nanoseconds()-u)/d),d=G(f,c)}let n=f*d,h=a.minSamples??V(n,c),w=[],k=Bun.nanoseconds(),T=0,x=0;while(x<h||T<c){let u=Bun.nanoseconds();for(let M=0;M<d;M++){let P=t();O(I(P)?await P:P)}let b=Bun.nanoseconds();if(w.push({i:x,wallNs:(b-u)/d}),x++,T=Bun.nanoseconds()-k,a.gc)Bun.gc(!0)}let W=w.map((u)=>u.wallNs),E=l(W),y=p(E,[],"inprocess"),_=J(n);if(w.length<_)y.push({code:"low-sample-count",message:`Only ${w.length} sample(s) at ~${Y(n)} per trial; ${_} is the floor for this cost class. Raise minSamples or the time budget for a steadier number.`,data:{samples:w.length,target:_,trialCostNs:n}});return{trials:w,timing:E,warnings:y}}function Y(t){if(t>=1e9)return`${(t/1e9).toFixed(2)}s`;if(t>=1e6)return`${(t/1e6).toFixed(1)}ms`;if(t>=1000)return`${(t/1000).toFixed(1)}\xB5s`;return`${t.toFixed(0)}ns`}async function Z(){let[t,a,c]=process.argv.slice(2);if(!t||!a)return process.stderr.write(`bench runner: usage: runner.ts <suiteFile> <outputPath> [optsJson]
-`),2;let e=c?JSON.parse(c):{};for(let n of e.preload??[])await import(n);v(),await import(t);let S=N();if(S.length===0)return process.stderr.write(`bench runner: ${t} registered no tasks (no task() calls found).
-`),2;let g=F(S,e.filter);if(e.taskIds){let n=new Set(e.taskIds);g=g.filter((h)=>n.has(m(h)))}if(g.length===0)return process.stderr.write(`bench runner: --filter ${JSON.stringify(e.filter)} matched zero of ${S.length} registered tasks in ${t}.
-`),2;if(e.planPath){let n=g.map((h)=>({id:m(h),isolate:R(h,e.isolate??!1)}));await Bun.write(e.planPath,JSON.stringify({tasks:n}))}let B=e.taskIds?g:g.filter((n)=>!R(n,e.isolate??!1)),f=[],d=[];for(let n of B){let h=m(n),w=C(t,h,{label:h,baseline:n.baseline,group:n.groupName,description:n.opts?.description,groupDescription:n.groupDescription,isolated:e.markIsolated});f.push(w);let k={...e,...n.opts?.timeBudgetMs!==void 0&&{timeBudgetMs:n.opts.timeBudgetMs},...n.opts?.minSamples!==void 0&&{minSamples:n.opts.minSamples},gc:D(n,e.gc??!1)},T=await U(n.fn,k);d.push(i({workload:w,configFingerprint:s({timeBudgetMs:k.timeBudgetMs??null,minSamples:k.minSamples??null,gc:k.gc??!1}),trials:T.trials,timing:T.timing,warnings:T.warnings}))}return await o(r(f,d),a),0}Z().then((t)=>process.exit(t));
+import{n,O,i,a,o,s,d,f,g,U,B,A,h,I,j,_,L,H}from"./chunk-9dqf5cxf.js";import{heapStats as X}from"bun:jsc";var Y=100;function z(){try{return X().heapSize}catch{return process.memoryUsage().heapUsed}}async function Z(l,m=Y){let w=Bun.nanoseconds();Bun.gc(!0);let t=z();for(let u=0;u<m;u++){let p=l();if(p instanceof Promise)await p}Bun.gc(!0);let k=z(),c=Bun.nanoseconds()-w;return{memory:{origin:"heapStats",bytesPerOp:Math.max(0,(k-t)/m)},diagnosticWallNs:c}}var ee=200,te=20;async function q(l,m=ee){let w=m*1e6,t=async()=>{let p=Bun.nanoseconds();while(Bun.nanoseconds()-p<w){let b=l();if(b instanceof Promise)await b}},{cpu:k,jit:c,diagnosticWallNs:u}=await d(t);return{cpu:k,jit:c,diagnosticWallNs:u}}function K(l){let{llint:m,baseline:w,dfg:t,ftl:k}=l.tiers,c=m+w+t+k;if(c===0)return;let u=m/c*100,p=w/c*100,b=t/c*100,S=k/c*100;if(u+p<=te)return;return{code:"jit-cold",message:`${(u+p).toFixed(1)}% of CPU samples were in the llint/baseline tiers: the JIT never warmed this task up.`,data:{llintPct:u,baselinePct:p,dfgPct:b,ftlPct:S}}}async function ne(){let[l,m,w]=process.argv.slice(2);if(!l||!m)return process.stderr.write(`bench runner: usage: runner.ts <suiteFile> <outputPath> [optsJson]
+`),2;let t=w?JSON.parse(w):{};for(let r of t.preload??[])await import(r);A(),await import(l);let k=B();if(k.length===0)return process.stderr.write(`bench runner: ${l} registered no tasks (no task() calls found).
+`),2;let c=k.filter((r)=>r.only),u=c.length>0?c:k;if(c.length>0)process.stderr.write(`bench: ${c.length} task(s) selected by .only
+`);let p=H(u,t.filter);if(t.taskIds){let r=new Set(t.taskIds);p=p.filter((e)=>r.has(h(e)))}if(p.length===0)return process.stderr.write(`bench runner: --filter ${JSON.stringify(t.filter)} matched zero of ${u.length} registered task(s) in ${l}.
+`),2;if(t.planPath){let r=p.map((e)=>({id:h(e),isolate:I(e,t.isolate??!1)}));await Bun.write(t.planPath,JSON.stringify({tasks:r}))}let b=t.taskIds?p:p.filter((r)=>!I(r,t.isolate??!1)),M=b.some((r)=>!r.skipped)&&t.noiseCheck!==!1?f():void 0,v=M?g(M):void 0,W=new Map,x=new Map;b.forEach((r,e)=>{if(r.groupName===void 0||r.skipped)return;if(!W.has(r.groupName))W.set(r.groupName,e);x.set(r.groupName,e)});let F=[],P=[];for(let r=0;r<b.length;r++){let e=b[r],R=h(e),T=O(l,R,{label:R,baseline:e.baseline,group:e.groupName,description:e.opts?.description,groupDescription:e.groupDescription,isolated:t.markIsolated,params:e.params,skipped:e.skipped});if(F.push(T),e.skipped)continue;let Q=e.groupName!==void 0&&W.get(e.groupName)===r,V=e.groupName!==void 0&&x.get(e.groupName)===r;if(Q&&e.groupBefore)await e.groupBefore();if(e.opts?.before)await e.opts.before();let E=e.opts?.budgetMs??t.budgetMs,J=e.opts?.samples??t.samples,D=e.opts?.minSamples??t.minSamples,N={...t,...E!==void 0&&{budgetMs:E},...J!==void 0&&{samples:J},...D!==void 0&&{minSamples:D},gc:j(e,t.gc??!1)},C=await U(e.fn,N);if(P.push(i({workload:T,configFingerprint:o({budgetMs:N.budgetMs??null,samples:N.samples??null,minSamples:N.minSamples??null,gc:N.gc??!1}),trials:C.trials,timing:C.timing,warnings:v&&P.length===0?[...C.warnings,v]:C.warnings})),_(e,t.cpu??!1)){let y=await q(e.fn),G=K(y.jit);P.push(a({workload:T,phase:"cpu",configFingerprint:o({cpu:!0}),diagnosticWallNs:y.diagnosticWallNs,cpu:y.cpu,jit:y.jit,warnings:G?[G]:[],artifacts:[]}))}if(L(e,t.alloc??!1)){let y=await Z(e.fn);P.push(a({workload:T,phase:"memstats",configFingerprint:o({alloc:!0}),diagnosticWallNs:y.diagnosticWallNs,memory:y.memory,warnings:[],artifacts:[]}))}if(e.opts?.after)await e.opts.after();if(V&&e.groupAfter)await e.groupAfter()}return await s(n(F,P,M),m),0}ne().then((l)=>process.exit(l));