autor3search-typescript 0.1.0

package/dist/pm/detect.js

@@ -0,0 +1,131 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { LOCKFILES } from '../config/schema.js';
+/**
+ * The manager and install command for each recognised lockfile.
+ *
+ * The filenames themselves come from `LOCKFILES` in `src/config/schema.ts`
+ * (also the base of `IMMUTABLE_FILES`) rather than being re-declared here, so
+ * the two lists cannot drift apart. The `switch` is exhaustive over
+ * `LockfileName`: if schema.ts ever adds a lockfile without a case being
+ * added here, this fails to typecheck rather than silently detecting nothing.
+ */
+function managerFor(lockfile) {
+    switch (lockfile) {
+        case 'package-lock.json':
+            return { pm: 'npm', installCommand: 'npm ci' };
+        case 'pnpm-lock.yaml':
+            return { pm: 'pnpm', installCommand: 'pnpm install --frozen-lockfile' };
+        case 'yarn.lock':
+            return { pm: 'yarn', installCommand: 'yarn install --immutable' };
+        case 'bun.lockb':
+        case 'bun.lock':
+            return { pm: 'bun', installCommand: 'bun install --frozen-lockfile' };
+        default: {
+            const exhaustive = lockfile;
+            throw new Error(`unhandled lockfile: ${String(exhaustive)}`);
+        }
+    }
+}
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True if a parsed `workspaces` field expresses a real workspace.
+ *
+ * `"workspaces": []` and `"workspaces": {}` declare no members, but declaring
+ * the key at all signals workspace intent (npm and yarn both treat its mere
+ * presence as opting a repository into workspace mode). Since a subtly wrong
+ * guess here would weaken a guarantee the user believes they have, an empty
+ * declaration is refused in the same way a populated one is.
+ *
+ * `"workspaces": null` is different: neither npm's nor yarn's schema accepts
+ * `null` for this field, and `null` is the idiomatic JSON spelling of "not
+ * set" — so, unlike `[]`/`{}`, it does not signal intent and is treated as
+ * absent.
+ */
+function isWorkspaceDeclaration(workspaces) {
+    return workspaces !== undefined && workspaces !== null;
+}
+/**
+ * Refuses a workspace root.
+ *
+ * v0.1 supports single-package repositories only. Saying so plainly is much
+ * better than half-working: in a workspace the scope gate, the freeze set and
+ * the install layout all mean something different, and getting any of them
+ * subtly wrong weakens a guarantee the user believes they have.
+ */
+export async function assertSinglePackage(pkgJsonText, root) {
+    let pkg;
+    try {
+        pkg = JSON.parse(pkgJsonText);
+    }
+    catch (e) {
+        throw new Error(`package.json is not valid JSON: ${e.message}. ` +
+            'Fix the JSON syntax and try again.');
+    }
+    const workspaces = pkg.workspaces;
+    if (isWorkspaceDeclaration(workspaces)) {
+        throw new Error('this repository declares npm/yarn workspaces (a "workspaces" key in package.json). ' +
+            'autor3search-typescript v0.1 supports single-package repositories only: in a ' +
+            'workspace the scope gate, the freeze set and the install layout all mean something ' +
+            'different, and getting any of them wrong would weaken the guarantee this tool gives. ' +
+            'Run autor3search-typescript from inside one of the workspace packages instead.');
+    }
+    if (await exists(path.join(root, 'pnpm-workspace.yaml'))) {
+        throw new Error('this repository is a pnpm workspace (a pnpm-workspace.yaml is present). ' +
+            'autor3search-typescript v0.1 supports single-package repositories only: in a ' +
+            'workspace the scope gate, the freeze set and the install layout all mean something ' +
+            'different, and getting any of them wrong would weaken the guarantee this tool gives. ' +
+            'Run autor3search-typescript from inside one of the workspace packages instead.');
+    }
+}
+export async function detect(root) {
+    const pkgPath = path.join(root, 'package.json');
+    let pkgText;
+    try {
+        pkgText = await readFile(pkgPath, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            throw new Error(`no package.json in ${root}: this does not look like a Node package. ` +
+                'Run autor3search-typescript from the package root (the directory that contains ' +
+                'package.json).');
+        }
+        // package.json exists but could not be read (permissions, it's a directory,
+        // etc.) — that is a different problem than a missing package.json, and
+        // telling the user to create a file that already exists would be
+        // actively misleading.
+        throw new Error(`could not read package.json in ${root}: ${e.message}. ` +
+            'Check that it is a regular, readable file and try again.');
+    }
+    await assertSinglePackage(pkgText, root);
+    const present = [];
+    for (const lockfile of LOCKFILES) {
+        if (await exists(path.join(root, lockfile))) {
+            present.push({ lockfile, ...managerFor(lockfile) });
+        }
+    }
+    if (present.length === 0) {
+        throw new Error(`no lockfile found (looked for ${LOCKFILES.join(', ')}). ` +
+            'A baseline pinned without a lockfile could not be reproduced, so this is refused. ' +
+            'Commit a lockfile and try again.');
+    }
+    // Two bun lockfile names (bun.lockb, bun.lock) map to the same manager; that
+    // is not ambiguity, so we compare distinct managers, not lockfile count.
+    const managers = new Set(present.map((p) => p.pm));
+    if (managers.size > 1) {
+        throw new Error(`more than one lockfile is present (${present.map((p) => p.lockfile).join(', ')}), ` +
+            'implying more than one package manager. Which one owns this repository would then ' +
+            'be a guess, and guessing wrong installs the baseline differently from the ' +
+            'candidate. Remove the stale lockfile and try again.');
+    }
+    return present[0];
+}
+//# sourceMappingURL=detect.js.map

package/dist/pm/detect.js.map

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

package/dist/profile/profile.d.ts

@@ -0,0 +1,53 @@
+export interface HotFrame {
+    functionName: string;
+    url: string;
+    lineNumber: number;
+    /** Sum of the microsecond timeDeltas attributed to this function+url, across every sample. */
+    selfTimeUs: number;
+}
+/**
+ * Aggregates a raw `.cpuprofile` JSON document into self time per
+ * `functionName` + `url`, dropping Node-internal and anonymous-root frames,
+ * sorted with the hottest function first.
+ *
+ * Self time per node id is the sum of `timeDeltas[i]` for every index `i`
+ * where `samples[i]` is that node -- `samples` and `timeDeltas` are parallel
+ * arrays, not independent ones. A profile that samples nothing but Node
+ * internals (a benchmark too fast to catch any user code in a sample) is a
+ * real input, not a bug: this returns an empty array rather than throwing,
+ * so a caller can tell "genuinely nothing to report" from a parse failure.
+ */
+export declare function parseCpuProfile(text: string): HotFrame[];
+export interface ProfileOneOptions {
+    /** The worktree/repo to measure in -- sets module resolution and tsconfig context. */
+    cwd: string;
+    benchFileAbs: string;
+    fn: string;
+    id: string;
+    benchtimeMs: number;
+    warmupMs: number;
+    timeoutMs: number;
+    nodeArgs: string[];
+    /** Directory the `.cpuprofile` file is written into; created if missing. */
+    profileDir: string;
+    log?: ((s: string) => void) | undefined;
+}
+export interface ProfileResult {
+    id: string;
+    /** Absolute path to the written `.cpuprofile` file. */
+    profilePath: string;
+    /** Aggregated, sorted (hottest first) user-code hot frames. */
+    hotFrames: HotFrame[];
+    /** Sum of every kept hot frame's self time -- the denominator for percentages. */
+    totalSelfUs: number;
+}
+/**
+ * Profiles one benchmark once, by spawning the same measurement child
+ * `runChild` uses elsewhere, with `--cpu-prof` added to its node args.
+ *
+ * Never requires a baseline: this only ever spawns a fresh child in `cwd`
+ * and reads back what Node's own profiler wrote, so it works before a run
+ * has ever started -- it is reconnaissance for deciding whether the
+ * benchmarks even point at the right code.
+ */
+export declare function profileBenchmark(o: ProfileOneOptions): Promise<ProfileResult>;

package/dist/profile/profile.js

@@ -0,0 +1,105 @@
+/**
+ * Runs one benchmark under Node's built-in `--cpu-prof` sampling profiler
+ * and turns the resulting `.cpuprofile` document into an aggregated,
+ * sorted list of hot functions.
+ *
+ * This exists so the optimizing agent works from real profiler data instead
+ * of guessing at hot spots from reading source -- a profiler that only ever
+ * reports Node internals gives it nothing to act on.
+ */
+import { mkdir, readFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { runChild } from '../benchrun/invoke.js';
+/** True for a frame this report should never surface: it is not the user's own code. */
+function isNodeInternal(url) {
+    return url === '' || url.startsWith('node:');
+}
+/**
+ * Aggregates a raw `.cpuprofile` JSON document into self time per
+ * `functionName` + `url`, dropping Node-internal and anonymous-root frames,
+ * sorted with the hottest function first.
+ *
+ * Self time per node id is the sum of `timeDeltas[i]` for every index `i`
+ * where `samples[i]` is that node -- `samples` and `timeDeltas` are parallel
+ * arrays, not independent ones. A profile that samples nothing but Node
+ * internals (a benchmark too fast to catch any user code in a sample) is a
+ * real input, not a bug: this returns an empty array rather than throwing,
+ * so a caller can tell "genuinely nothing to report" from a parse failure.
+ */
+export function parseCpuProfile(text) {
+    const doc = JSON.parse(text);
+    const nodeById = new Map(doc.nodes.map((n) => [n.id, n]));
+    const selfUsByNodeId = new Map();
+    for (let i = 0; i < doc.samples.length; i++) {
+        const nodeId = doc.samples[i];
+        const delta = doc.timeDeltas[i];
+        if (nodeId === undefined || delta === undefined)
+            continue;
+        selfUsByNodeId.set(nodeId, (selfUsByNodeId.get(nodeId) ?? 0) + delta);
+    }
+    const byKey = new Map();
+    for (const [nodeId, selfTimeUs] of selfUsByNodeId) {
+        const node = nodeById.get(nodeId);
+        if (!node)
+            continue;
+        const { functionName, url, lineNumber } = node.callFrame;
+        if (isNodeInternal(url))
+            continue;
+        // A "|" separator is enough here: functionName and url both come from
+        // source code the profiler itself observed, and even a collision would
+        // only ever merge two frames' self times together (never crash or
+        // misattribute to a third, unrelated frame) -- an acceptable, extremely
+        // unlikely edge case for a reporting tool, not a security boundary.
+        const key = functionName + '|' + url;
+        const existing = byKey.get(key);
+        if (existing) {
+            existing.selfTimeUs += selfTimeUs;
+        }
+        else {
+            byKey.set(key, { functionName, url, lineNumber, selfTimeUs });
+        }
+    }
+    return [...byKey.values()].sort((a, b) => b.selfTimeUs - a.selfTimeUs);
+}
+/** Turns a benchmark id into a filesystem-safe `.cpuprofile` basename. */
+function profileFileName(id) {
+    return id.replace(/[^A-Za-z0-9._-]/g, '_') + '.cpuprofile';
+}
+/**
+ * Profiles one benchmark once, by spawning the same measurement child
+ * `runChild` uses elsewhere, with `--cpu-prof` added to its node args.
+ *
+ * Never requires a baseline: this only ever spawns a fresh child in `cwd`
+ * and reads back what Node's own profiler wrote, so it works before a run
+ * has ever started -- it is reconnaissance for deciding whether the
+ * benchmarks even point at the right code.
+ */
+export async function profileBenchmark(o) {
+    await mkdir(o.profileDir, { recursive: true });
+    const name = profileFileName(o.id);
+    const profilePath = path.join(o.profileDir, name);
+    // Remove any stale file at this exact path first, so a previous run's
+    // leftover (e.g. this benchmark crashing before writing one) is never
+    // mistaken for the profile this call is about to produce.
+    await rm(profilePath, { force: true });
+    const nodeArgs = [...o.nodeArgs, '--cpu-prof', '--cpu-prof-dir', o.profileDir, '--cpu-prof-name', name];
+    const result = await runChild({
+        cwd: o.cwd,
+        benchFileAbs: o.benchFileAbs,
+        fn: o.fn,
+        id: o.id,
+        benchtimeMs: o.benchtimeMs,
+        warmupMs: o.warmupMs,
+        timeoutMs: o.timeoutMs,
+        nodeArgs,
+        ...(o.log ? { log: o.log } : {}),
+    });
+    if (!result.ok) {
+        throw new Error(`profiling ${o.id} failed: ${result.error}`);
+    }
+    const text = await readFile(profilePath, 'utf8');
+    const hotFrames = parseCpuProfile(text);
+    const totalSelfUs = hotFrames.reduce((sum, f) => sum + f.selfTimeUs, 0);
+    return { id: o.id, profilePath, hotFrames, totalSelfUs };
+}
+//# sourceMappingURL=profile.js.map

package/dist/profile/profile.js.map

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

package/dist/results/results.d.ts

@@ -0,0 +1,65 @@
+import type { DiscardReason, Status } from '../verdict/verdict.js';
+/** Repo-root-relative default location of the log. */
+export declare const RESULTS_PATH = "results.tsv";
+export declare const HEADER = "commit\tscore\tbest_bench_delta\tp_min\tstatus\treason\tdescription";
+export interface Row {
+    commit: string;
+    score: number;
+    bestBenchDelta: number;
+    pMin: number;
+    /**
+     * Typed against verdict's own `Status` rather than a plain string: every
+     * producer of a row already holds one of these four values, so a stray
+     * status string would be a bug at the call site, not something this log
+     * should quietly tolerate.
+     */
+    status: Status;
+    /**
+     * A `DiscardReason` on a discard row; the empty string on every other
+     * row (keep, fail, crash). Never `undefined` -- a field that sometimes
+     * exists and sometimes doesn't cannot round-trip through a fixed
+     * 7-column TSV, whose row shape does not vary with status.
+     */
+    reason: DiscardReason | '';
+    description: string;
+}
+export interface Summary {
+    counts: Record<string, number>;
+    /** Product of every kept row's score; 1 (no-op) when there are none. */
+    cumulativeSpeedup: number;
+    topWins: Row[];
+}
+/**
+ * Appends one row, writing the header first if the file is new or empty.
+ * Not safe for concurrent writers -- callers are expected to hold the eval
+ * lock across the whole experiment, so only one process ever appends at a
+ * time.
+ */
+export declare function appendRow(path: string, r: Row): Promise<void>;
+/**
+ * Loads every row. A missing file is an empty log, not an error -- this is
+ * the state of a repository that has never run an experiment.
+ *
+ * Anything else is strict: a line that does not split into exactly 7
+ * tab-separated fields, or whose numeric or enum fields don't parse,
+ * fails the WHOLE load, naming the file and the 1-based line number.
+ * Sanitizing on write (see `sanitize`) already makes a malformed row
+ * nearly impossible to produce honestly, so encountering one is a real
+ * signal -- a torn write, a hand edit -- not noise. Silently dropping the
+ * bad row instead would let a corrupted log masquerade as a short one,
+ * which is the worse failure for a file that is the sole record of an
+ * unattended overnight run. The same reasoning extends past field count
+ * to field *content*: a torn write is at least as likely to garble a
+ * value as to drop a whole field, and a garbled numeric field that
+ * parses "successfully" to 0 or NaN is a worse failure than a visible
+ * parse error, since it distorts every summary silently.
+ */
+export declare function loadRows(path: string): Promise<Row[]>;
+/**
+ * Counts per status, the cumulative speedup, and the biggest individual
+ * wins. Never throws and never produces NaN, even for an empty log: an
+ * empty log is a real, valid state (no experiments have run yet), not an
+ * error, and a report reading it should say "1x, nothing tried yet"
+ * rather than crash.
+ */
+export declare function summarize(rows: Row[]): Summary;

package/dist/results/results.js

@@ -0,0 +1,214 @@
+import { appendFile, readFile, stat } from 'node:fs/promises';
+/** Repo-root-relative default location of the log. */
+export const RESULTS_PATH = 'results.tsv';
+export const HEADER = 'commit\tscore\tbest_bench_delta\tp_min\tstatus\treason\tdescription';
+const FIELD_COUNT = 7;
+/** Character (not byte) cap on `description`, ellipsis included. */
+const DESCRIPTION_LIMIT = 256;
+const VALID_STATUSES = ['keep', 'discard', 'fail', 'crash'];
+const VALID_REASONS = [
+    'no_significant_improvement',
+    'improvement_below_min_effect',
+    'significant_regression',
+];
+/**
+ * Tabs, CRs and LFs are the TSV's own field and row delimiters. Left
+ * untouched, a single embedded newline in e.g. `description` would split
+ * one experiment into two lines on disk -- and the second half, missing
+ * its leading columns, would fail `loadRows`'s field-count check on every
+ * future read. Flattening them to spaces before a value ever reaches disk
+ * makes that failure mode structurally impossible rather than merely
+ * unlikely, whatever the field.
+ */
+function sanitize(s) {
+    return s.replace(/[\t\r\n]/g, ' ');
+}
+/**
+ * Truncates by Unicode code point, never by byte or by UTF-16 code unit.
+ * `Array.from` iterates a string by code point, so a surrogate pair (an
+ * astral character, e.g. an emoji) is kept or dropped whole. A byte-count
+ * cut (e.g. slicing a UTF-8 `Buffer`) could stop mid-sequence and decode
+ * back as a replacement character; a naive `.slice` on UTF-16 units could
+ * split a surrogate pair into two lone, invalid halves. Either would let an
+ * agent's pasted stack trace or diff -- pasted verbatim into `-desc` --
+ * produce a row that doesn't even round-trip as valid text.
+ */
+function truncateDescription(s) {
+    const chars = Array.from(s);
+    if (chars.length <= DESCRIPTION_LIMIT)
+        return s;
+    return `${chars.slice(0, DESCRIPTION_LIMIT - 3).join('')}...`;
+}
+function formatRow(r) {
+    const fields = [
+        sanitize(r.commit),
+        // 4 decimals: score is a ratio hovering around 1.0, where a 0.01%
+        // difference is noise; 4 places is enough to distinguish real
+        // improvements without implying false precision.
+        r.score.toFixed(4),
+        // best_bench_delta is a percentage; 2 decimal places (0.01 pp) is
+        // already finer than the run-to-run noise it's measuring.
+        r.bestBenchDelta.toFixed(2),
+        // p_min is a probability, not a percentage, and can be extremely
+        // small (e.g. 1.08e-5). Formatting it to a fixed 2 decimals would
+        // print "0.00" for every significant result, making them
+        // indistinguishable from each other and from a genuine p=0. JS's
+        // own number-to-string conversion is lossless (it prints the
+        // shortest decimal that reads back to the exact same double), and
+        // switches to exponential notation on its own for very small
+        // magnitudes, so it is used as-is instead of a fixed decimal count.
+        String(r.pMin),
+        sanitize(r.status),
+        sanitize(r.reason),
+        truncateDescription(sanitize(r.description)),
+    ];
+    return fields.join('\t');
+}
+/**
+ * Appends one row, writing the header first if the file is new or empty.
+ * Not safe for concurrent writers -- callers are expected to hold the eval
+ * lock across the whole experiment, so only one process ever appends at a
+ * time.
+ */
+export async function appendRow(path, r) {
+    let needsHeader = true;
+    try {
+        const info = await stat(path);
+        needsHeader = info.size === 0;
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+        needsHeader = true;
+    }
+    const prefix = needsHeader ? `${HEADER}\n` : '';
+    await appendFile(path, `${prefix}${formatRow(r)}\n`, 'utf8');
+}
+/**
+ * Parses one numeric column strictly. `Number('')` is `0` in JavaScript --
+ * left unchecked, a torn write that leaves an empty field (still 7 fields
+ * total, so the field-count check alone would never catch it) would
+ * silently produce a legitimate-looking score of 0 rather than an obvious
+ * parse failure. A blank `score` on a `keep` row is the worst case: it
+ * collapses `summarize`'s cumulative-speedup PRODUCT for the ENTIRE log to
+ * 0, with no visible anomaly. So blank is checked and rejected explicitly,
+ * before ever calling `Number` on it; `Number.isFinite` then also catches
+ * genuinely non-numeric text (which parses to `NaN`) and `Infinity`.
+ */
+function parseNumberField(path, lineNo, field, raw) {
+    if (raw.trim() === '') {
+        throw new Error(`${path}:${lineNo}: ${field}: empty field, want a number`);
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new Error(`${path}:${lineNo}: ${field}: invalid number "${raw}"`);
+    }
+    return n;
+}
+/**
+ * `status` must be one of the four values `Status` allows. An unrecognized
+ * status has a milder blast radius than a bad number -- it simply never
+ * matches the `'keep'` filter in `summarize`, so it can't poison the
+ * cumulative-speedup product -- but it would still let `counts` silently
+ * accumulate an unexpected key, which is the same "corrupted log
+ * masquerading as valid" failure the field-count check exists to prevent.
+ */
+function parseStatus(path, lineNo, raw) {
+    if (!VALID_STATUSES.includes(raw)) {
+        throw new Error(`${path}:${lineNo}: status: unknown status "${raw}"`);
+    }
+    return raw;
+}
+/** `reason` must be empty, or one of the three `DiscardReason` values. */
+function parseReason(path, lineNo, raw) {
+    if (raw === '' || VALID_REASONS.includes(raw)) {
+        return raw;
+    }
+    throw new Error(`${path}:${lineNo}: reason: unknown reason "${raw}"`);
+}
+/**
+ * Loads every row. A missing file is an empty log, not an error -- this is
+ * the state of a repository that has never run an experiment.
+ *
+ * Anything else is strict: a line that does not split into exactly 7
+ * tab-separated fields, or whose numeric or enum fields don't parse,
+ * fails the WHOLE load, naming the file and the 1-based line number.
+ * Sanitizing on write (see `sanitize`) already makes a malformed row
+ * nearly impossible to produce honestly, so encountering one is a real
+ * signal -- a torn write, a hand edit -- not noise. Silently dropping the
+ * bad row instead would let a corrupted log masquerade as a short one,
+ * which is the worse failure for a file that is the sole record of an
+ * unattended overnight run. The same reasoning extends past field count
+ * to field *content*: a torn write is at least as likely to garble a
+ * value as to drop a whole field, and a garbled numeric field that
+ * parses "successfully" to 0 or NaN is a worse failure than a visible
+ * parse error, since it distorts every summary silently.
+ */
+export async function loadRows(path) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const lines = text.split('\n');
+    // A well-formed file ends with a trailing newline, which turns into one
+    // trailing empty element after split; drop it rather than counting it as
+    // a (blank, malformed) final line.
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    const rows = [];
+    for (let i = 0; i < lines.length; i++) {
+        const lineNo = i + 1;
+        const rawLine = lines[i] ?? '';
+        if (lineNo === 1 && rawLine === HEADER)
+            continue;
+        const fields = rawLine.split('\t');
+        if (fields.length !== FIELD_COUNT) {
+            throw new Error(`${path}:${lineNo}: got ${fields.length} fields, want ${FIELD_COUNT}`);
+        }
+        const [commit, scoreStr, deltaStr, pMinStr, status, reason, description] = fields;
+        rows.push({
+            commit,
+            score: parseNumberField(path, lineNo, 'score', scoreStr),
+            bestBenchDelta: parseNumberField(path, lineNo, 'best_bench_delta', deltaStr),
+            pMin: parseNumberField(path, lineNo, 'p_min', pMinStr),
+            status: parseStatus(path, lineNo, status),
+            reason: parseReason(path, lineNo, reason),
+            description,
+        });
+    }
+    return rows;
+}
+/** Number of "top wins" to report -- the most impactful kept experiments. */
+const TOP_WINS = 3;
+/**
+ * Counts per status, the cumulative speedup, and the biggest individual
+ * wins. Never throws and never produces NaN, even for an empty log: an
+ * empty log is a real, valid state (no experiments have run yet), not an
+ * error, and a report reading it should say "1x, nothing tried yet"
+ * rather than crash.
+ */
+export function summarize(rows) {
+    const counts = {};
+    for (const r of rows) {
+        counts[r.status] = (counts[r.status] ?? 0) + 1;
+    }
+    const kept = rows.filter((r) => r.status === 'keep');
+    // The PRODUCT of every kept score, not the latest and not a mean. Each
+    // KEEP advances the measurement baseline to the just-kept commit (see
+    // baseline.measureCommit), so every subsequent score is only that
+    // experiment's own incremental contribution on top of the last win, not
+    // a re-measurement against the original baseline. Successive real
+    // improvements compound the way successive percentage changes do, so
+    // only their product reflects the true end-to-end speedup. `reduce`'s
+    // seed of 1 is what makes an empty (or keep-less) log report "no
+    // speedup yet" instead of dividing by, or starting from, zero.
+    const cumulativeSpeedup = kept.reduce((acc, r) => acc * r.score, 1);
+    const topWins = [...kept].sort((a, b) => a.score - b.score).slice(0, TOP_WINS);
+    return { counts, cumulativeSpeedup, topWins };
+}
+//# sourceMappingURL=results.js.map

package/dist/results/results.js.map

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