ostia 0.2.1 → 0.2.3

package/index.d.ts

@@ -1,4 +1,4 @@
-export declare function defineConfig(config: Partial<OstiaConfig>): Partial<OstiaConfig>;
+export declare function defineConfig(config: OstiaConfigInput): OstiaConfigInput;
 
 export interface CommandSpec {
     command: string | string[];
@@ -7,6 +7,12 @@ export interface CommandSpec {
     prepare?: PrepareHook;
     /** Overrides `TimeOptions.timeSource` for this command. */
     timeSource?: TimeSource;
+    /** Overrides `TimeOptions.timeoutMs` for this command. */
+    timeoutMs?: number;
+    /** Overrides `TimeOptions.ignoreExitCodes` for this command. */
+    ignoreExitCodes?: number[];
+    /** Overrides `TimeOptions.failOnNonzero` for this command. */
+    failOnNonzero?: boolean;
 }
 
 export interface TimeOptions {
@@ -49,6 +55,28 @@ export interface TimeOptions {
      * true) and stamp it on the document as `environment`. Set false to skip
      * the ~200ms reference measurement. */
     noiseCheck?: boolean;
+    /** Kills a trial (or prepare hook) that hasn't finished after this many
+     * ms, with SIGKILL. No default: an unset `timeoutMs` never times out. A
+     * timed-out trial contributes no sample; if every trial of a command times
+     * out, that command has no timing stats. `CommandSpec.timeoutMs` overrides
+     * it per command. */
+    timeoutMs?: number;
+    /** Aborting cancels the run: in-flight trials are killed with SIGKILL, no
+     * further trials are scheduled, and `time()` resolves (never rejects)
+     * with the document built from whatever measurements had already
+     * completed, plus an `aborted` warning on the document's last
+     * measurement. */
+    signal?: AbortSignal;
+    /** Exit codes to treat as success (hyperfine's `--ignore-failure`): a
+     * trial exiting with one of these still contributes its sample and gets
+     * no `nonzero-exit` warning, as if it had exited 0. `CommandSpec.ignoreExitCodes`
+     * overrides it per command. */
+    ignoreExitCodes?: number[];
+    /** Stops a command's trial loop after its first non-zero, non-ignored
+     * exit (that trial's sample is still recorded) instead of running its
+     * full sample count regardless of exit code. `CommandSpec.failOnNonzero`
+     * overrides it per command. */
+    failOnNonzero?: boolean;
 }
 
 export declare function time(opts: TimeOptions): Promise<ProfileDocument>;
@@ -56,6 +84,12 @@ export declare function time(opts: TimeOptions): Promise<ProfileDocument>;
 interface ProfileOptions {
     intervalUs?: number;
     origin?: "inspector" | "jsc";
+    /** `profile()` runs `fn` in this process, so there's no child to kill: an
+     * already-aborted signal skips the profiler instrumentation entirely and
+     * just calls `fn` plain (still returning its `result`), with an `aborted`
+     * warning in place of CPU evidence. A signal that fires mid-capture can't
+     * interrupt `fn` once it's running. */
+    signal?: AbortSignal;
 }
 
 interface ProfileResult<T> {
@@ -80,6 +114,16 @@ export interface WorkloadConfig {
     /** `command` only. Take timing from a number in the command's own output
      * instead of its wall clock; see `TimeSource`. */
     timeSource?: TimeSource;
+    /** `command` only. Kills a trial (or prepare hook) that hasn't finished
+     * after this many ms. Overrides `ostia ci`'s 10-minute default per
+     * workload. */
+    timeoutMs?: number;
+    /** `command` only. Exit codes to treat as success; see
+     * `TimeOptions.ignoreExitCodes`. */
+    ignoreExitCodes?: number[];
+    /** `command` only. Stops this workload's trial loop after its first
+     * non-zero, non-ignored exit; see `TimeOptions.failOnNonzero`. */
+    failOnNonzero?: boolean;
 }
 
 interface BenchConfig {
@@ -99,6 +143,9 @@ interface BenchConfig {
     filter?: string;
     isolate?: boolean;
     outDir?: string;
+    /** Kills a suite file's (or isolated task's) subprocess if it hasn't
+     * finished after this many ms. Overrides `ostia ci`'s 10-minute default. */
+    timeoutMs?: number;
 }
 
 export interface OstiaConfig {
@@ -111,9 +158,28 @@ export interface OstiaConfig {
     thresholds: Thresholds;
     workloads: WorkloadConfig[];
     bench?: BenchConfig;
+    /** `ostia ci`'s policy when a configured workload has no matching row in
+     * the baseline (by workload id): `"fail"` exits 2 naming the baseline
+     * file, `"warn"` lists it in the report without affecting the exit code.
+     * Unset (the default): `"fail"` when *every* configured workload is
+     * missing, `"warn"` otherwise - a totally stale/wrong baseline is a hard
+     * error, a handful of new workloads next to an otherwise-matching
+     * baseline is not. `--on-missing-baseline` overrides this per invocation. */
+    onMissingBaseline?: "warn" | "fail";
+    /** Measures this machine's noise floor once per `ostia ci` invocation
+     * (default true) and stamps it on the candidate document as
+     * `environment`, the same reference measurement `time()`/`bench()` run -
+     * so `compare`'s noise-floor threshold widening applies to `ci` too, not
+     * only to ad hoc `time`/`bench` runs. `--no-noise-check` overrides this
+     * to false per invocation. */
+    noiseCheck?: boolean;
 }
 
-interface Thresholds {
+export type OstiaConfigInput = Omit<Partial<OstiaConfig>, "thresholds"> & {
+    thresholds?: Partial<Thresholds>;
+};
+
+export interface Thresholds {
     timingPct: number;
     frameSelfPct: number;
     heapTypePct: number;
@@ -126,7 +192,18 @@ interface Thresholds {
     bootstrapIterations: number;
 }
 
-export declare function compareDocuments(base: ProfileDocument, cand: ProfileDocument, thresholds?: Thresholds): Comparison[];
+export declare const DEFAULT_THRESHOLDS: Thresholds;
+
+export interface CompareResult {
+    comparisons: Comparison[];
+    unmatched: {
+        baseOnly: Workload[];
+        candOnly: Workload[];
+    };
+    summary: ComparisonSummary;
+}
+
+export declare function compareDocuments(base: ProfileDocument, cand: ProfileDocument, thresholds?: Thresholds): CompareResult;
 
 export interface ProfileDocument {
     schemaVersion: 2;
@@ -140,6 +217,18 @@ export interface ProfileDocument {
     workloads: Workload[];
     measurements: Measurement[];
     comparisons?: Comparison[];
+    /** Aggregate across `comparisons`, from `compareDocuments`/`ostia compare`/
+     * `ostia ci`. Additive, no schema bump. Absent wherever `comparisons` is. */
+    comparisonSummary?: ComparisonSummary;
+    /** Workload ids present on only one side of a `compareDocuments` call -
+     * candidates matched by id gone missing from the baseline, or vice versa.
+     * Additive, no schema bump; absent wherever `comparisons` is. Ids only
+     * (not full `Workload`s) to keep the document small; `ostia compare`'s
+     * printed report resolves labels from the two source documents directly. */
+    unmatched?: {
+        baseOnly: string[];
+        candOnly: string[];
+    };
     /** Machine conditions when this document was measured. Additive, no
      * schema bump. Absent when `noiseCheck: false` (or `--no-noise-check`)
      * skipped the reference measurement. */
@@ -176,6 +265,15 @@ interface Environment {
 }
 
 export interface Workload {
+    /** Identifies what is measured, not where or when it ran: for a
+     * `subprocess` workload, a hash of the command argv, `prepare`
+     * (command form or function source), and `timeSource` spec -
+     * deliberately excluding `process.cwd()`, so a baseline saved from one
+     * checkout (a CI runner, a different worktree) still matches a candidate
+     * measured from another. For an `inprocess` workload, a hash of the
+     * function source (or, for a registry entry, the file/task name plus
+     * `params`). `label`, `description`, and `baseline` are annotations and
+     * never affect it. */
     id: string;
     kind: "subprocess" | "inprocess";
     label?: string;
@@ -251,7 +349,6 @@ interface Measurement {
     jit?: JitTierBreakdown;
     warnings: Warning[];
     artifacts: ArtifactRef[];
-    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
@@ -272,6 +369,14 @@ interface Trial {
     userNs?: number;
     systemNs?: number;
     maxRssBytes?: number;
+    /** Set when the trial was killed by `timeoutMs` before it exited on its
+     * own. `exitCode` is absent in that case: the kill signal, not the
+     * command, decided how the process ended. Contributes no sample. */
+    timedOut?: true;
+    /** Set when the workload has a `timeSource` and this trial's output didn't
+     * match its pattern. `reportedNs` is absent in that case (never a
+     * fallback to `wallNs`). Contributes no sample. */
+    timeSourceNoMatch?: true;
 }
 
 interface TimingStats {
@@ -295,6 +400,12 @@ interface TimingStats {
      * all samples. A robust spread measure that (unlike stddev) isn't skewed
      * by the long right tail typical of wall-clock timings. */
     mad?: number;
+    /** In-process trials batched into one timed block (see
+     * `measure/inprocess.ts`'s `sizeBatch`), set only when batching occurred.
+     * Absent for every subprocess timing measurement, and for an in-process
+     * one whose single call already cleared the batching threshold - a
+     * renderer treats an absent value the same as `1`. */
+    batch?: number;
 }
 
 interface Frame {
@@ -339,7 +450,6 @@ interface HeapEvidence {
         count: number;
         retainedBytes?: number;
     }[];
-    snapshotArtifactId?: string;
 }
 
 interface MemoryEvidence {
@@ -373,7 +483,9 @@ 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" | "thin-comparison" | "noisy-machine" | "skipped" | "jit-cold";
+declare const WARNING_CODES: readonly ["slow-first-run", "outliers-detected", "fast-command", "nonzero-exit", "artifact-missing", "empty-profile", "below-timer-resolution", "low-sample-count", "thin-comparison", "noisy-machine", "skipped", "jit-cold", "timeout", "aborted", "time-source-no-match", "environment-mismatch"];
+
+export type WarningCode = (typeof WARNING_CODES)[number];
 
 export interface Warning {
     code: WarningCode;
@@ -389,7 +501,7 @@ interface ArtifactRef {
     bytes: number;
 }
 
-interface Comparison {
+export interface Comparison {
     id: string;
     baselineMeasurementId: string;
     candidateMeasurementId: string;
@@ -443,6 +555,24 @@ interface Comparison {
     verdict: "pass" | "fail";
 }
 
+interface ComparisonSummary {
+    /** `comparisons.length`: workloads present (and comparable) on both sides. */
+    matched: number;
+    regressed: number;
+    improved: number;
+    unchanged: number;
+    /** Geometric mean of `cand/base` median ratios over matched timing
+     * comparisons, as a signed percent (negative: candidate faster on
+     * average). `null` when no comparison had a finite timing ratio. */
+    geomeanPct: number | null;
+    /** Same value as `Comparison.thresholds.effectiveTimingPct` - one number
+     * for the whole document pair, since it depends only on `thresholds` and
+     * the two documents' `environment.noise.floorPct`, never per-workload. */
+    effectiveTimingPct: number;
+    /** `"fail"` when any comparison's verdict is `"fail"`. */
+    verdict: "pass" | "fail";
+}
+
 export interface PrepareRun {
     phase: "warmup" | "timing" | "cpu" | "heap";
     index: number;
@@ -460,6 +590,31 @@ export interface TimeSource {
     unit?: TimeUnit;
 }
 
+interface InprocessTimingOptions {
+    /** Wall-clock budget for the sampling loop, per task (default: 500). The loop
+     * always runs for at least this long, unless `samples` is set. */
+    budgetMs?: number;
+    /** Exact trial count. When set, the budget is ignored and the loop runs
+     * exactly this many trials, however slow each one is - the in-process
+     * equivalent of `time()`'s `samples`. */
+    samples?: number;
+    /** Hard floor on the number of trials when no exact `samples` count is
+     * given. When set, the loop keeps sampling past the time budget until this
+     * many trials exist, however slow each one is. When unset, the floor is
+     * cost-aware (see `defaultSampleFloor`): as many trials as fit in the
+     * budget, capped at 20, but never below the rigor floor the task's per-trial cost
+     * earns it (3 at ≤1ms, rising to 10 for multi-second calls). */
+    minSamples?: number;
+    /** Warmup budget as a fraction of `budgetMs` (default: 0.1) - a fraction,
+     * not a call count, named `warmup` for cross-surface consistency with
+     * `time()`'s trial-count `warmup`; the two are genuinely different units (a
+     * fraction here, a count there), not papered over. Warmup always runs at
+     * least one call; for a task slower than the warmup budget that single call
+     * is the whole warmup. */
+    warmup?: number;
+    gc?: boolean;
+}
+
 export declare function keep(value: unknown): void;
 
 interface BenchOptions {
@@ -518,6 +673,21 @@ interface BenchOptions {
      * subprocess (default: true) and stamp it on the document as
      * `environment`. Set false to skip the ~200ms reference measurement. */
     noiseCheck?: boolean;
+    /** Kills a suite file's subprocess (or, under `isolate`, one task's
+     * dedicated subprocess) with SIGKILL if it hasn't finished after this many
+     * ms. No default: an unset `timeoutMs` never times out. Applies to the
+     * whole subprocess, not per task - the same granularity `isolate` already
+     * runs at. */
+    timeoutMs?: number;
+    /** Aborting cancels the run: in-flight suite/isolated-task subprocesses
+     * are killed with SIGKILL, no new ones are started, and `bench()` resolves
+     * (never rejects) with whatever suites/tasks had already finished when the
+     * signal fired, plus an `aborted` warning on the document's last
+     * measurement. A suite subprocess killed mid-run contributes nothing (it
+     * only writes its result once, at the end), so a suite that was in flight
+     * when the signal fired is dropped entirely rather than partially
+     * represented. */
+    signal?: AbortSignal;
 }
 
 export declare function bench(opts: BenchOptions): Promise<ProfileDocument>;
@@ -628,6 +798,50 @@ interface TaskFn {
 
 export declare const task: TaskFn;
 
+export interface RunOptions extends MeasureTasksOpts {
+    /** Regex, matched against "group/name" task ids - same semantics as
+     * `ostia bench --filter` / `bench({ filter })`. */
+    filter?: string;
+    /** Skip printing the report to stdout; still returns the document. */
+    quiet?: boolean;
+    /** Renderer used for the printed report (default: `"table"`). */
+    format?: FormatName;
+}
+
+export declare function run(opts?: RunOptions): Promise<ProfileDocument>;
+
+type FormatName = "table" | "json" | "markdown" | "jsonl" | "minimal" | "collapsed" | "mermaid" | "speedscope" | "cpuprofile";
+
+interface RenderResult {
+    text?: string;
+    files?: {
+        path?: string;
+        content: string;
+    }[];
+}
+
+interface Renderer<O = unknown> {
+    name: FormatName;
+    render(doc: ProfileDocument, options: O): Promise<RenderResult>;
+}
+
+interface MeasureTasksOpts extends InprocessTimingOptions {
+    /** Suite-wide default for capturing an extra `phase: "cpu"` measurement
+     * per task (task/group `TaskOptions.cpu`/`GroupOptions.cpu` still win). */
+    cpu?: boolean;
+    /** Suite-wide default for capturing an extra `phase: "memstats"`
+     * measurement per task (task/group `TaskOptions.alloc`/`GroupOptions.alloc`
+     * still win). */
+    alloc?: boolean;
+    /** Stamped onto every workload this call produces, recording whether it
+     * ran in a subprocess dedicated to it alone. */
+    markIsolated?: boolean;
+    /** Measure this machine's noise floor before the first task (default:
+     * true) and stamp it on the document as `environment`. Set false to skip
+     * the ~200ms reference measurement. */
+    noiseCheck?: boolean;
+}
+
 type SweepPoint<T extends Record<string, readonly unknown[]>> = {
     [K in keyof T]: T[K][number];
 };
@@ -639,26 +853,52 @@ export { newDocument as createDocument };
 
 export declare function saveDocument(doc: ProfileDocument, path: string): Promise<void>;
 
+export declare class OstiaDocumentError extends Error {
+    readonly code: "invalid-json" | "not-a-document" | "unsupported-schema";
+    readonly path?: string;
+    readonly schemaVersion?: unknown;
+    constructor(code: OstiaDocumentError["code"], message: string, opts?: {
+        path?: string;
+        schemaVersion?: unknown;
+    });
+}
+
 export declare function loadDocument(path: string): Promise<ProfileDocument>;
 
 export declare const renderers: Record<FormatName, Renderer<any>>;
 
-type FormatName = "table" | "json" | "markdown" | "jsonl" | "minimal" | "collapsed" | "mermaid" | "speedscope" | "cpuprofile";
-
-interface RenderResult {
-    text?: string;
-    files?: {
-        path?: string;
-        content: string;
-    }[];
-}
+export declare const MINIMAL_PROTOCOL_VERSION: 1;
 
-interface Renderer<O = unknown> {
-    name: FormatName;
-    render(doc: ProfileDocument, options: O): Promise<RenderResult>;
+interface MinimalWarning {
+    code: string;
+    data?: Record<string, unknown>;
 }
 
-export interface MinimalLine {
+export interface MinimalDelta {
+    medianPct: number;
+    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;
+    /** The threshold this delta was actually tested against, once machine
+     * noise widened it past `thresholds.timingPct` - see
+     * `Comparison.thresholds.effectiveTimingPct`. */
+    effectiveTimingPct: number;
+    matched: true;
+}
+
+export interface MinimalRunLine {
+    event: "run";
+    protocolVersion: typeof MINIMAL_PROTOCOL_VERSION;
+    schemaVersion: ProfileDocument["schemaVersion"];
+    /** Join key back to `Workload.id` / `Comparison.candidateMeasurementId` -
+     * stable across a `time`/`compare`/`ci` invocation of the same command,
+     * unlike `task` (a label, not an identity). */
+    workloadId: string;
     task: string;
     group?: string;
     description?: string;
@@ -670,6 +910,12 @@ export interface MinimalLine {
     skipped?: true;
     unit?: "ns";
     samples?: number;
+    /** In-process trials batched into one timed block (see
+     * `measure/inprocess.ts`'s `sizeBatch`) so the timer's own resolution
+     * doesn't dominate a sub-microsecond task's reading. 1 when the timing
+     * engine never batched (every subprocess run, and any in-process run
+     * whose single call already clears the batching threshold). */
+    batch: number;
     mean?: number;
     median?: number;
     stddev?: number;
@@ -685,21 +931,77 @@ export interface MinimalLine {
      * fastest). Only present when the document has more than one timing run. */
     relative?: number;
     baseline?: true;
-    warnings: {
-        code: string;
-        data?: Record<string, unknown>;
-    }[];
+    /** `mad / median` of the machine's ~200ms reference measurement - how
+     * noisy this machine is right now, independent of what's being measured.
+     * From `document.environment`; absent when `noiseCheck: false` skipped it. */
+    noiseFloorPct?: number;
+    warnings: MinimalWarning[];
     /** From `comparisons` when present (ostia compare / ci): the change against
      * the baseline document for this task. */
-    delta?: {
-        medianPct: number;
-        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;
+    delta?: MinimalDelta;
+}
+
+export interface MinimalUnmatchedLine {
+    event: "unmatched";
+    protocolVersion: typeof MINIMAL_PROTOCOL_VERSION;
+    workloadId: string;
+    task: string;
+    side: "base" | "cand";
+}
+
+export interface MinimalSummaryLine {
+    event: "summary";
+    protocolVersion: typeof MINIMAL_PROTOCOL_VERSION;
+    command: "compare" | "ci";
+    matched: number;
+    regressed: number;
+    improved: number;
+    unchanged: number;
+    unmatched: number;
+    /** `ci` only. */
+    cached?: number;
+    executed?: number;
+    failed?: number;
+    missingBaseline?: number;
+    geomeanPct: number | null;
+    effectiveTimingPct: number;
+    noiseFloorPct?: number;
+    /** `ci` only. */
+    baseline?: {
+        name: string;
+        path: string;
     };
+    git?: {
+        base?: GitMetadata;
+        cand?: GitMetadata;
+    };
+    exportedTo?: string;
+    verdict: "pass" | "fail";
+    exitCode: number;
+}
+
+export type MinimalEvent = MinimalRunLine | MinimalUnmatchedLine | MinimalSummaryLine;
+
+export interface MinimalProtocolContext {
+    command: "compare" | "ci";
+    exitCode: number;
+    unmatched?: {
+        baseOnly: Workload[];
+        candOnly: Workload[];
+    };
+    baseGit?: GitMetadata;
+    candGit?: GitMetadata;
+    baseline?: {
+        name: string;
+        path: string;
+    };
+    cached?: number;
+    executed?: number;
+    failed?: number;
+    missingBaseline?: number;
+    exportedTo?: string;
+}
+
+export interface MinimalRenderOptions {
+    protocol?: MinimalProtocolContext;
 }

package/index.js

@@ -1,2 +1,2 @@
 // @bun
-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};
+import{u,M,f,Z,l,o,Q,ee,ne,_,te}from"./chunk-dpxy38mq.js";import{t,c,D,r,A,re,se}from"./chunk-2s4xk1mg.js";export{u as DEFAULT_THRESHOLDS,l as MINIMAL_PROTOCOL_VERSION,D as OstiaDocumentError,f as bench,M as compareDocuments,t as createDocument,ne as defineConfig,re as group,A as keep,r as loadDocument,te as profile,Z as range,o as renderers,Q as run,c as saveDocument,ee as sweep,se as task,_ as time};

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "ostia",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Fast profiling and benchmarking for Bun.",
   "type": "module",
+  "engines": {
+    "bun": ">=1.4.0"
+  },
   "exports": {
     ".": {
       "types": "./index.d.ts",

package/runner.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 // @bun
-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));
+import{c,x,Y,y,H,v,P}from"./chunk-2s4xk1mg.js";async function d(){let[s,i,l]=process.argv.slice(2);if(!s||!i)return process.stderr.write(`bench runner: usage: runner.ts <suiteFile> <outputPath> [optsJson]
+`),2;let e=l?JSON.parse(l):{};for(let t of e.preload??[])await import(t);Y(),await import(s);let a=x();if(a.length===0)return process.stderr.write(`bench runner: ${s} registered no tasks (no task() calls found).
+`),2;let r=a.filter((t)=>t.only),p=r.length>0?r:a;if(r.length>0)process.stderr.write(`bench: ${r.length} task(s) selected by .only
+`);let n=v(p,e.filter);if(e.taskIds){let t=new Set(e.taskIds);n=n.filter((o)=>t.has(y(o)))}if(n.length===0)return process.stderr.write(`bench runner: --filter ${JSON.stringify(e.filter)} matched zero of ${p.length} registered task(s) in ${s}.
+`),2;if(e.planPath){let t=n.map((o)=>({id:y(o),isolate:H(o,e.isolate??!1)}));await Bun.write(e.planPath,JSON.stringify({tasks:t}))}let f=e.taskIds?n:n.filter((t)=>!H(t,e.isolate??!1)),u=await P(s,f,e);return await c(u,i),0}d().then((s)=>process.exit(s));

package/chunk-9dqf5cxf.js

@@ -1,8 +0,0 @@
-// @bun
-var De={ns:1,us:1000,ms:1e6,s:1e9};async function D(r){let c=r.timeSource!==void 0,l=Bun.nanoseconds(),b=Bun.spawn(r.argv,{cwd:r.cwd,env:r.env,stdout:c?"pipe":"ignore",stderr:c?"pipe":"ignore",stdin:"ignore"}),R=c?Promise.all([new Response(b.stdout).text(),new Response(b.stderr).text()]):void 0,M=await b.exited,N=Bun.nanoseconds(),C=b.resourceUsage?.(),G={wallNs:N-l,exitCode:M,userNs:C?Number(C.cpuTime.user)*1000:void 0,systemNs:C?Number(C.cpuTime.system)*1000:void 0,maxRssBytes:C?.maxRSS};if(R&&r.timeSource){let[V,ee]=await R;G.reportedNs=_e(r.timeSource,V,ee,r.argv)}return G}function _e(r,c,l,b=[]){let R=typeof r.pattern==="string"?new RegExp(r.pattern):r.pattern,M=r.group??1,N=R.exec(c)??R.exec(l),C=b.length>0?` for "${b.join(" ")}"`:"";if(!N)throw Error(`timeSource pattern ${R} did not match the output${C}. Output was:
-${$e(c,l)}`);let G=N[M];if(G===void 0)throw Error(`timeSource pattern ${R} matched${C} but has no capture group ${M} (matched text: "${N[0]}").`);let V=Number(G);if(!Number.isFinite(V))throw Error(`timeSource pattern ${R} group ${M} captured "${G}"${C}, which is not a number.`);return V*De[r.unit??"ms"]}function $e(r,c){let b=(M)=>M.length>800?`${M.slice(0,800)}\u2026(${M.length-800} more)`:M,R=[];if(r.trim())R.push(`--- stdout ---
-${b(r.trimEnd())}`);if(c.trim())R.push(`--- stderr ---
-${b(c.trimEnd())}`);return R.length>0?R.join(`
-`):"(empty)"}async function k(r,c,l){if(typeof r==="function"){await r(c);return}let b=Array.isArray(r)?r:y(r),M=await Bun.spawn(b,{cwd:l.cwd,env:l.env,stdout:"ignore",stderr:"inherit",stdin:"ignore"}).exited;if(M!==0)throw Error(`prepare command "${b.join(" ")}" exited with code ${M} before ${c.phase} trial ${c.index}.`)}function Re(r){if(r===void 0||typeof r==="function")return;return Array.isArray(r)?r:y(r)}function Me(r){if(r===void 0)return;return{pattern:typeof r.pattern==="string"?r.pattern:r.pattern.source,...r.group!==void 0&&{group:r.group},...r.unit!==void 0&&{unit:r.unit}}}function y(r){return r.trim().split(/\s+/).filter(Boolean)}function x(r){return JSON.stringify(ge(r))}function ge(r){if(Array.isArray(r))return r.map(ge);if(r!==null&&typeof r==="object"){let c={};for(let l of Object.keys(r).sort())c[l]=ge(r[l]);return c}return r}function e(r,...c){let l=Bun.CryptoHasher.hash("sha256",x(c),"hex");return`${r}_${l.slice(0,16)}`}var be,Se=!1;function ke(r){let c=Bun.spawnSync(["git",...r],{timeout:200,stdout:"pipe",stderr:"ignore"});return c.success?c.stdout.toString().trim():void 0}function ve(){if(Se)return be;Se=!0;try{let r=ke(["rev-parse","--short","HEAD"]);if(r===void 0)be=void 0;else{let c=ke(["rev-parse","--abbrev-ref","HEAD"]),l=ke(["status","--porcelain"]);be={sha:r,branch:c??"HEAD",dirty:(l?.length??0)>0}}}catch{be=void 0}return be}var m="0.1.0";function n(r,c,l){let b=ve();return{schemaVersion:2,toolVersion:m,bunVersion:Bun.version,platform:{os:process.platform,arch:process.arch},createdAt:new Date().toISOString(),workloads:r,measurements:c,...l!==void 0&&{environment:l},...b!==void 0&&{git:b}}}function p(r,c,l={}){let b=Re(l.prepare),R=Me(l.timeSource),M=typeof l.prepare==="function"?l.prepare.toString():b;return{id:e("wl","subprocess",r,process.cwd(),...M!==void 0||R!==void 0?[M??null,R??null]:[]),kind:"subprocess",command:r,label:c,...b!==void 0&&{prepare:b},...R!==void 0&&{timeSource:R}}}function F(r,c){return{id:e("wl","inprocess",r.name,r.toString()),kind:"inprocess",label:c}}function O(r,c,l={}){return{id:l.params!==void 0?e("wl","inprocess-entry",r,c,l.params):e("wl","inprocess-entry",r,c),kind:"inprocess",entry:{file:r,task:c,...l.group!==void 0&&{group:l.group}},...l.label!==void 0&&{label:l.label},...l.baseline!==void 0&&{baseline:l.baseline},...l.description!==void 0&&{description:l.description},...l.groupDescription!==void 0&&{groupDescription:l.groupDescription},...l.isolated!==void 0&&{isolated:l.isolated},...l.params!==void 0&&{params:l.params},...l.skipped!==void 0&&{skipped:l.skipped}}}function i(r){return{id:e("run",r.workload.id,"timing",r.configFingerprint,Bun.version,m),workloadId:r.workload.id,phase:"timing",instrumented:!1,configFingerprint:r.configFingerprint,trials:r.trials,timing:r.timing,warnings:r.warnings,artifacts:[],memory:Ce(r.trials),...r.interleaved!==void 0&&{interleaved:r.interleaved}}}function Ce(r){let c=r.map((l)=>l.maxRssBytes).filter((l)=>l!==void 0);if(c.length===0)return;return{origin:"resourceUsage",perTrial:r.map((l)=>({rssBytes:l.maxRssBytes})),maxRssBytes:Math.max(...c)}}function a(r){return{id:e("run",r.workload.id,r.phase,r.configFingerprint,Bun.version,m),workloadId:r.workload.id,phase:r.phase,instrumented:!0,configFingerprint:r.configFingerprint,trials:[{i:0,wallNs:r.diagnosticWallNs,exitCode:r.exitCode}],diagnosticWallNs:r.diagnosticWallNs,cpu:r.cpu,heap:r.heap,memory:r.memory,jit:r.jit,warnings:r.warnings,artifacts:r.artifacts}}async function E(r,c,l){let R=await Bun.file(l).arrayBuffer(),M=new Bun.CryptoHasher("sha256");return M.update(R),{id:e("art",r,c,l),kind:c,path:l,sha256:M.digest("hex"),bytes:R.byteLength}}function o(r){return e("cfg",r)}function S(r){return`${JSON.stringify(ge(r),null,2)}
-`}async function s(r,c){await Bun.write(c,S(r))}function We(r){if(r.schemaVersion===2)return r;let{runs:c,comparisons:l,...b}=r;return{...b,schemaVersion:2,measurements:c.map(({baselineRunId:R,...M})=>({...M,...R!==void 0&&{baselineMeasurementId:R}})),...l!==void 0&&{comparisons:l.map(({baselineRunId:R,candidateRunId:M,...N})=>({...N,baselineMeasurementId:R,candidateMeasurementId:M}))}}}async function t(r){let c=await Bun.file(r).text(),l=JSON.parse(c);return We(l)}import{profile as Le}from"bun:jsc";var Ge=new Map([["LLInt","llint"],["Baseline","baseline"],["DFG","dfg"],["FTL","ftl"]]),Ie=4294967295;function Ne(r,c){let l=c??r.interval*1e6,b=new Map,R=[];function M(w,v,J,ne){let re=b.get(w);if(re===void 0)re=new Map,b.set(w,re);let Y=v??"",se=re.get(Y);if(se===void 0)se=R.length,re.set(Y,se),R.push({key:e("fr",w,Y),name:w,url:v,line:J,col:ne});return se}function N(w){let v=w.line===Ie,J=v?void 0:w.line-1,ne=v||w.column===Ie?void 0:w.column-1;return M(w.name,w.sourceURL,J,ne)}let C=M("(root)",void 0,void 0,void 0),G=1,V={id:0,frameIx:C,children:new Map,selfUs:0,samples:0,totalUs:0},ee=new Map([[0,V]]),te={llint:0,baseline:0,dfg:0,ftl:0},X=new Map,me=[],ae=[];for(let w of r.traces){let v=w.frames,J=V;for(let Y=v.length-1;Y>=0;Y--){let se=N(v[Y]),pe=J.children.get(se);if(!pe)pe={id:G++,frameIx:se,children:new Map,selfUs:0,samples:0,totalUs:0},J.children.set(se,pe),ee.set(pe.id,pe);J=pe}J.selfUs+=l,J.samples+=1,me.push(J.id),ae.push(l);let ne=v[0],re=ne&&Ge.get(ne.category);if(re){te[re]++;let Y=X.get(re)??new Map;Y.set(J.frameIx,(Y.get(J.frameIx)??0)+1),X.set(re,Y)}}function oe(w){let v=w.selfUs;for(let J of w.children.values())v+=oe(J);return w.totalUs=v,v}oe(V);let ue=new Map;function ie(w){let v=ue.get(w.frameIx);if(v)v.selfUs+=w.selfUs,v.totalUs+=w.totalUs,v.samples+=w.samples;else ue.set(w.frameIx,{frameIx:w.frameIx,selfUs:w.selfUs,totalUs:w.totalUs,samples:w.samples});for(let J of w.children.values())ie(J)}ie(V);let ce=[...ee.values()].map((w)=>({id:w.id,frameIx:w.frameIx,children:[...w.children.values()].map((v)=>v.id)})),le={origin:"jsc-profile",samplingIntervalUs:l,frames:R,nodes:ce,totals:[...ue.values()].sort((w,v)=>v.selfUs-w.selfUs),samples:{nodeIds:me,timeDeltasUs:ae}},z=[...X.entries()].flatMap(([w,v])=>[...v.entries()].sort((J,ne)=>ne[1]-J[1]).slice(0,3).map(([J,ne])=>({tier:w,frameKey:R[J].key,samples:ne})));return{cpu:le,jit:{origin:"jsc-profile",tiers:te,topFramesByTier:z}}}var He=1000;async function d(r,c={}){let l=c.intervalUs??He,b,R=Bun.nanoseconds(),M=await Le(async()=>(b=await r(),b),l),N=Bun.nanoseconds()-R,{cpu:C,jit:G}=Ne(M.stackTraces,l);return{result:b,cpu:C,jit:G,diagnosticWallNs:N}}import Te from"os";function u(r){if(r.length===0)throw Error("computeTimingStats: samples must be non-empty");let c=r.length,l=Ee(r),b=0;for(let w=0;w<c;w++)b+=r[w];let R=b/c,M=de(l,0.5),N=0;for(let w=0;w<c;w++){let v=r[w]-R;N+=v*v}let C=Math.sqrt(N/c),G=l[0],V=l[c-1],ee=de(l,0.25),te=de(l,0.75),X=te-ee,me=ee-1.5*X,ae=te+1.5*X,oe=ee-3*X,ue=te+3*X,ie=0,ce=0;for(let w=0;w<c;w++){let v=r[w];if(v<oe||v>ue)ce++;else if(v<me||v>ae)ie++}let le=de(l,0.99),z=new Float64Array(c);for(let w=0;w<c;w++)z[w]=Math.abs(r[w]-M);z.sort();let Q=de(z,0.5);return{unit:"ns",samples:r,mean:R,median:M,stddev:C,min:G,max:V,outliers:{mild:ie,severe:ce},p75:te,p99:le,mad:Q}}function Ee(r){let c=new Float64Array(r.length);return c.set(r),c.sort(),c}function de(r,c){let l=r.length;if(l===1)return r[0];let b=c*(l-1),R=Math.floor(b),M=Math.ceil(b);if(R===M)return r[R];let N=b-R;return r[R]*(1-N)+r[M]*N}var Je=5000000,je=200;function P(r,c,l="subprocess"){let b=[],R=r.samples[0];if(R!==void 0){let N=Ee(r.samples),C=de(N,0.25),V=de(N,0.75)-C;if(R>r.median+3*V&&V>0)b.push({code:"slow-first-run",message:`First run took ${(R/1e6).toFixed(2)}ms, much slower than the median ${(r.median/1e6).toFixed(2)}ms. Consider more warmup.`,data:{firstNs:R,medianNs:r.median}})}if(r.outliers.mild+r.outliers.severe>0)b.push({code:"outliers-detected",message:`${r.outliers.mild+r.outliers.severe} outlier(s) detected (${r.outliers.severe} severe, ${r.outliers.mild} mild).`,data:r.outliers});if(l==="subprocess"&&r.median<Je)b.push({code:"fast-command",message:`Median run time (${(r.median/1e6).toFixed(3)}ms) is very fast; results may be dominated by spawn overhead.`,data:{medianNs:r.median}});if(l==="inprocess"&&r.median<je)b.push({code:"below-timer-resolution",message:`Median run time (${r.median.toFixed(0)}ns) is close to timer resolution; consider a larger batch size or a coarser operation.`,data:{medianNs:r.median}});let M=c.filter((N)=>N!==void 0&&N!==0);if(M.length>0)b.push({code:"nonzero-exit",message:`${M.length} of ${c.length} trial(s) exited non-zero.`,data:{exitCodes:M}});return b}var Ve=200,Fe=64,qe=(()=>{let r=new Uint8Array(4096);for(let c=0;c<r.length;c++)r[c]=c*2654435761&255;return r})();function ze(r,c){let l=c;for(let b=0;b<r.length;b++)l^=r[b],l=Math.imul(l,16777619);return l>>>0}function Ke(r){let c=u(r),l=c.mad??0;return{floorPct:c.median===0?0:l/c.median*100,referenceMedianNs:c.median,samples:r.length}}function Be(r=Ve){let c=r*1e6,l=[],b=0,R=Bun.nanoseconds(),M=0;while(M<c){let N=Bun.nanoseconds();for(let G=0;G<Fe;G++)b^=ze(qe,G);let C=Bun.nanoseconds();l.push((C-N)/Fe),M=Bun.nanoseconds()-R}return Ke(l)}var Xe=0.75;function f(){let[r=0,c=0]=Te.loadavg();return{cpuModel:Te.cpus()[0]?.model??"unknown",cores:Te.availableParallelism(),loadAvg1:r,loadAvg5:c,noise:Be()}}function g(r){if(r.loadAvg1<=r.cores*Xe)return;return{code:"noisy-machine",message:`Load average ${r.loadAvg1.toFixed(2)} exceeds 75% of ${r.cores} available core(s); timing noise may be elevated.`,data:{loadAvg1:r.loadAvg1,cores:r.cores}}}var Ze=500,Qe=20,Oe=3,Ye=10,en=2,nn=0.1,rn=1000,tn=1e4;function Ue(r){let c=Math.log10(Math.max(1,r)/1e6),l=Math.round(Oe+en*c);return Math.min(Ye,Math.max(Oe,l))}function on(r,c){let l=Math.floor(c/r);return Math.min(Qe,Math.max(l,Ue(r)))}var Pe=0;function T(r){if(typeof r==="number")Pe+=r;else if(r!==void 0&&r!==null)Pe+=1}function we(r){return r!==null&&typeof r==="object"&&typeof r.then==="function"}function Ae(r,c){return Math.max(1,Math.ceil(rn/r),Math.ceil(c/(r*tn)))}async function U(r,c={}){let l=(c.budgetMs??Ze)*1e6,b=l*(c.warmup??nn),R=Bun.nanoseconds(),M=0,N=0;while(N<b){let z=r();T(we(z)?await z:z),M++,N=Bun.nanoseconds()-R}let C;if(M>0)C=Math.max(1,N/M);else{let z=Bun.nanoseconds(),Q=r();T(we(Q)?await Q:Q),C=Math.max(1,Bun.nanoseconds()-z)}let G=Ae(C,l);if(G>1){let z=Bun.nanoseconds();for(let Q=0;Q<G;Q++){let w=r();T(we(w)?await w:w)}C=Math.max(1,(Bun.nanoseconds()-z)/G),G=Ae(C,l)}let V=C*G,ee=c.samples??c.minSamples??on(V,l),te=c.samples!==void 0?0:l,X=[],me=Bun.nanoseconds(),ae=0,oe=0;while(oe<ee||ae<te){let z=Bun.nanoseconds();for(let w=0;w<G;w++){let v=r();T(we(v)?await v:v)}let Q=Bun.nanoseconds();if(X.push({i:oe,wallNs:(Q-z)/G}),oe++,ae=Bun.nanoseconds()-me,c.gc)Bun.gc(!0);if(c.samples!==void 0&&oe>=c.samples)break}let ue=X.map((z)=>z.wallNs),ie=u(ue),ce=P(ie,[],"inprocess"),le=Ue(V);if(X.length<le)ce.push({code:"low-sample-count",message:`Only ${X.length} sample(s) at ~${sn(V)} per trial; ${le} is the floor for this cost class. Raise minSamples or the time budget for a steadier number.`,data:{samples:X.length,target:le,trialCostNs:V}});return{trials:X,timing:ie,warnings:ce}}function sn(r){if(r>=1e9)return`${(r/1e9).toFixed(2)}s`;if(r>=1e6)return`${(r/1e6).toFixed(1)}ms`;if(r>=1000)return`${(r/1000).toFixed(1)}\xB5s`;return`${r.toFixed(0)}ns`}var ye=[],Z,fe;function xe(r,c,l,b){let R=Z;Z={name:r,description:l?.description,isolate:l?.isolate,gc:l?.gc,cpu:l?.cpu,alloc:l?.alloc,before:l?.before,after:l?.after,skip:b.skip,only:b.only};try{c()}finally{Z=R}}var q=Object.assign((r,c,l)=>xe(r,c,l,{}),{skip:(r,c,l)=>xe(r,c,l,{skip:!0}),only:(r,c,l)=>xe(r,c,l,{only:!0})});function he(r,c,l,b){let R=fe!==void 0||l?.params!==void 0?{...fe,...l?.params}:void 0;ye.push({groupName:Z?.name,groupDescription:Z?.description,groupIsolate:Z?.isolate,groupGc:Z?.gc,groupCpu:Z?.cpu,groupAlloc:Z?.alloc,groupBefore:Z?.before,groupAfter:Z?.after,name:r,fn:c,baseline:l?.baseline,params:R,skipped:b.skip||Z?.skip,only:b.only||Z?.only,opts:l})}var K=Object.assign((r,c,l)=>he(r,c,l,{}),{skip:(r,c,l)=>he(r,c,l,{skip:!0}),only:(r,c,l)=>he(r,c,l,{only:!0})});function B(){return ye}function A(){ye.length=0,Z=void 0,fe=void 0}function W(r,c){let l=fe;fe=r;try{return c()}finally{fe=l}}function h(r){return r.groupName?`${r.groupName}/${r.name}`:r.name}function I(r,c){return r.opts?.isolate??r.groupIsolate??c}function j(r,c){return r.opts?.gc??r.groupGc??c}function _(r,c){return r.opts?.cpu??r.groupCpu??c}function L(r,c){return r.opts?.alloc??r.groupAlloc??c}function H(r,c){if(!c)return[...r];let l=new RegExp(c);return r.filter((b)=>l.test(h(b)))}
-export{D,k,y,x,e,m,n,p,F,O,i,a,E,o,S,s,t,u,P,d,f,g,T,U,q,K,B,A,W,h,I,j,_,L,H};