knodin 0.7.4 → 0.7.6

package/dist/src/competitive-measurement.js

@@ -1,183 +0,0 @@
-import childProcess from "node:child_process";
-import fs from "node:fs";
-/**
- * Twenty warm observations are the minimum that gives nearest-rank p95 a
- * distinct tail observation instead of aliasing a three-sample median.
- */
-export const MIN_WARM_SAMPLES = 20;
-export const DEFAULT_WARMUP_COUNT = 3;
-export const DEFAULT_COLD_SAMPLES = 5;
-export const DEFAULT_CALL_TIMEOUT_MS = 30_000;
-function percentile(sorted, fraction) {
-    const index = Math.max(0, Math.ceil(fraction * sorted.length) - 1);
-    return sorted[index];
-}
-export function summarizeLatencySamples(mode, samplesMs, warmupCount) {
-    if (!Number.isInteger(warmupCount) || warmupCount < 0)
-        throw new Error("Warm-up count must be a non-negative integer");
-    if (samplesMs.length === 0)
-        throw new Error("At least one latency sample is required");
-    if (mode === "warm" && samplesMs.length < MIN_WARM_SAMPLES) {
-        throw new Error(`Warm measurements require at least ${MIN_WARM_SAMPLES} samples for a meaningful p95`);
-    }
-    if (samplesMs.some((sample) => !Number.isFinite(sample) || sample < 0))
-        throw new Error("Latency samples must be finite non-negative numbers");
-    const raw = [...samplesMs];
-    const sorted = [...raw].sort((left, right) => left - right);
-    const p50Ms = percentile(sorted, 0.5);
-    return {
-        mode,
-        warmupCount,
-        sampleCount: raw.length,
-        samplesMs: raw,
-        p50Ms,
-        p95Ms: percentile(sorted, 0.95),
-        minMs: sorted[0],
-        maxMs: sorted.at(-1),
-        medianMs: p50Ms,
-    };
-}
-export async function sampleOperation(operation, options) {
-    const mode = options.mode ?? "warm";
-    const warmupCount = mode === "warm" ? (options.warmupCount ?? DEFAULT_WARMUP_COUNT) : 0;
-    const sampleCount = options.sampleCount ?? (mode === "warm" ? MIN_WARM_SAMPLES : DEFAULT_COLD_SAMPLES);
-    let value;
-    const call = async (kind, index) => {
-        const timeoutMs = options.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
-        let timer;
-        try {
-            return await Promise.race([
-                operation(),
-                new Promise((_, reject) => {
-                    timer = setTimeout(async () => {
-                        try {
-                            if (options.onTimeout)
-                                await options.onTimeout(kind, index);
-                            else
-                                reapDescendants(process.pid);
-                        }
-                        catch {
-                            // Cleanup failure must not replace or strand the timeout result.
-                        }
-                        finally {
-                            reject(new Error(`Competitive ${kind} call ${index + 1} timed out after ${timeoutMs}ms`));
-                        }
-                    }, timeoutMs);
-                    timer.unref?.();
-                }),
-            ]);
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    };
-    for (let index = 0; index < warmupCount; index++) {
-        await options.beforeSample?.("warmup", index);
-        value = await call("warmup", index);
-    }
-    const samplesMs = [];
-    for (let index = 0; index < sampleCount; index++) {
-        await options.beforeSample?.("sample", index);
-        const startedAt = performance.now();
-        value = await call("sample", index);
-        samplesMs.push(Number((performance.now() - startedAt).toFixed(3)));
-    }
-    return {
-        value: value,
-        measurement: summarizeLatencySamples(mode, samplesMs, warmupCount),
-    };
-}
-export function reapDescendants(rootPid) {
-    const output = childProcess.spawnSync("ps", ["-axo", "pid=,ppid="]).stdout.toString();
-    const processes = output
-        .split("\n")
-        .map((line) => line.trim().split(/\s+/).map(Number))
-        .filter(([pid, parentPid]) => Number.isInteger(pid) && Number.isInteger(parentPid));
-    const descendants = new Set([rootPid]);
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const [pid, parentPid] of processes) {
-            if (!descendants.has(pid) && descendants.has(parentPid)) {
-                descendants.add(pid);
-                changed = true;
-            }
-        }
-    }
-    descendants.delete(rootPid);
-    for (const signal of ["-TERM", "-KILL"]) {
-        for (const pid of [...descendants].reverse()) {
-            childProcess.spawnSync("/bin/kill", [signal, String(pid)]);
-        }
-    }
-}
-export function createCheckpointingResults(outputPath) {
-    const results = [];
-    results.push = (...items) => {
-        const length = Array.prototype.push.apply(results, items);
-        const temporary = `${outputPath}.partial-${process.pid}`;
-        fs.writeFileSync(temporary, `${JSON.stringify({
-            schemaVersion: 2,
-            status: "partial",
-            terminal: false,
-            partial: true,
-            generatedAt: new Date().toISOString(),
-            results,
-        }, null, 2)}\n`);
-        fs.renameSync(temporary, outputPath);
-        return length;
-    };
-    return results;
-}
-function emptyOwner() {
-    return { rssBytes: 0, pids: [] };
-}
-export function attributeProcessTree(processes, rootPid, patterns, phase, rootOwner = "harness") {
-    const descendants = new Set([rootPid]);
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const process of processes) {
-            if (!descendants.has(process.pid) && descendants.has(process.parentPid)) {
-                descendants.add(process.pid);
-                changed = true;
-            }
-        }
-    }
-    const result = {
-        phase,
-        harness: emptyOwner(),
-        knodin: emptyOwner(),
-        competitor: emptyOwner(),
-        unknown: emptyOwner(),
-    };
-    for (const process of processes) {
-        if (!descendants.has(process.pid))
-            continue;
-        const owner = process.pid === rootPid
-            ? rootOwner
-            : patterns.knodin.some((pattern) => pattern.test(process.command))
-                ? "knodin"
-                : patterns.competitor.some((pattern) => pattern.test(process.command))
-                    ? "competitor"
-                    : "unknown";
-        result[owner].rssBytes += process.rssBytes;
-        result[owner].pids.push(process.pid);
-    }
-    return result;
-}
-export function mergeResourcePeaks(left, right) {
-    const merged = {
-        phase: right.phase,
-        harness: emptyOwner(),
-        knodin: emptyOwner(),
-        competitor: emptyOwner(),
-        unknown: emptyOwner(),
-    };
-    for (const owner of ["harness", "knodin", "competitor", "unknown"]) {
-        merged[owner] =
-            right[owner].rssBytes >= left[owner].rssBytes
-                ? { ...right[owner], pids: [...right[owner].pids] }
-                : { ...left[owner], pids: [...left[owner].pids] };
-    }
-    return merged;
-}

package/dist/src/competitive-runner.js

@@ -1,487 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { COMPETITIVE_MANIFEST, } from "./competitive-manifest.js";
-const RESERVED_CASE_KEYS = new Set([
-    "id",
-    "axis",
-    "parameters",
-    "note",
-    "blocked",
-    "mutation",
-    "knodin",
-    "oracle",
-    "caseContract",
-    "partial",
-]);
-function responseOf(side) {
-    if (!side || side.ok !== true)
-        return null;
-    const response = side.response;
-    return typeof response === "string" && response.length > 0 ? response : null;
-}
-function normalizedWords(value) {
-    return new Set(value
-        .toLowerCase()
-        .split(/[^a-z0-9_.-]+/)
-        .filter((word) => word.length >= 4));
-}
-function runCheckedInOracle(oracleId, test, competitor) {
-    const contenderResponse = responseOf(findCompetitorSide(test, competitor));
-    const knodinResponse = responseOf(test.knodin);
-    if (!contenderResponse || !knodinResponse) {
-        return {
-            id: oracleId,
-            status: "unavailable",
-            reason: "Both successful response payloads are required for the checked-in oracle.",
-        };
-    }
-    const bothContain = (pattern) => pattern.test(contenderResponse) && pattern.test(knodinResponse);
-    let passed = false;
-    switch (oracleId) {
-        case "contains-create-engine":
-            passed = bothContain(/create[\s_-]*engine/i);
-            break;
-        case "create-engine-definition":
-            passed = bothContain(/create[\s_-]*engine/i) && bothContain(/src\/engine\/index\.ts/i);
-            break;
-        case "create-engine-callers":
-            passed = bothContain(/create[\s_-]*engine/i) && bothContain(/\bmain\b/i);
-            break;
-        case "create-engine-callees":
-            passed = bothContain(/create[\s_-]*engine/i) && bothContain(/withStaleness/i);
-            break;
-        case "create-engine-both":
-            passed =
-                bothContain(/create[\s_-]*engine/i) &&
-                    bothContain(/\bmain\b/i) &&
-                    bothContain(/withStaleness/i);
-            break;
-        case "freshness-search":
-            passed = bothContain(/index/i) && bothContain(/fresh(?:ness)?/i);
-            break;
-        case "engine-package":
-            passed = bothContain(/engine/i) && bothContain(/(?:package|module|community)/i);
-            break;
-        case "indexed-status": {
-            const indexed = (response) => /(?:total_files|indexedFiles)"?\s*:\s*[1-9]\d*/i.test(response);
-            passed = indexed(contenderResponse) && indexed(knodinResponse);
-            break;
-        }
-        case "contains-index":
-            passed = bothContain(/index|fresh|status/i);
-            break;
-        case "pack-two-files":
-            passed =
-                bothContain(/src\/context\.ts/i) &&
-                    bothContain(/src\/cli-args\.ts/i) &&
-                    !/(?:^|\/)[^/\n]*\.spec\.ts/i.test(contenderResponse) &&
-                    !/(?:^|\/)[^/\n]*\.spec\.ts/i.test(knodinResponse);
-            break;
-        case "packed-read": {
-            const contenderWords = normalizedWords(contenderResponse);
-            const knodinWords = normalizedWords(knodinResponse);
-            const shared = [...contenderWords].filter((word) => knodinWords.has(word));
-            passed = shared.length >= 2;
-            break;
-        }
-        case "grep-create-engine":
-            passed = bothContain(/createEngine/i);
-            break;
-        case "architecture-facet": {
-            const facet = String(test.id ?? "")
-                .replace(/^architecture-/, "")
-                .replace("_", " ");
-            passed = facet.length > 0 && bothContain(new RegExp(facet.replace(" ", "[ _-]?"), "i"));
-            break;
-        }
-    }
-    return {
-        id: oracleId,
-        status: passed ? "passed" : "failed",
-        ...(passed ? {} : { reason: `Checked-in ${oracleId} oracle did not match both responses.` }),
-    };
-}
-export function applyCompetitiveCaseContracts(competitor, raw, fixtureRevision) {
-    const source = raw && typeof raw === "object"
-        ? raw
-        : {};
-    const results = Array.isArray(source.results) ? source.results : [];
-    const mappings = COMPETITIVE_MANIFEST.find((entry) => entry.id === competitor)?.caseMappings ?? [];
-    return {
-        ...source,
-        results: results.map((test) => {
-            const caseId = String(test.id ?? "");
-            const mapping = mappings.find((candidate) => new RegExp(candidate.idPattern).test(caseId));
-            if (!mapping) {
-                return {
-                    ...test,
-                    caseContract: {
-                        useCase: String(test.axis ?? test.id ?? "unlabeled competitive case"),
-                        fixtureRevision,
-                        mode: "warm",
-                        scope: {
-                            competitorOperation: "unmatched",
-                            knodinOperation: "unmatched",
-                            dimensions: [],
-                        },
-                        budgets: { bytes: null, tokens: null, items: null },
-                        disposition: {
-                            status: "incomparable",
-                            reason: "No checked-in equivalent-operation mapping exists for this case ID; latency is excluded.",
-                        },
-                        oracle: {
-                            status: "unavailable",
-                            reason: "Correctness is not evaluated for an incomparable case.",
-                        },
-                    },
-                };
-            }
-            const dimensions = [...mapping.scope.dimensions];
-            const direction = caseId.match(/^trace-(inbound|outbound|both)-/)?.[1];
-            if (direction)
-                dimensions.push(`direction=${direction}`);
-            const facet = caseId.match(/^architecture-([a-z_]+)/)?.[1];
-            if (facet)
-                dimensions.push(`facet=${facet}`);
-            return {
-                ...test,
-                caseContract: {
-                    useCase: mapping.useCase,
-                    fixtureRevision,
-                    mode: caseId.endsWith("-cold") ? "cold" : mapping.mode,
-                    scope: { ...mapping.scope, dimensions },
-                    budgets: mapping.budgets,
-                    disposition: { status: "comparable", reason: mapping.reason },
-                    oracle: runCheckedInOracle(mapping.oracleId, test, competitor),
-                },
-            };
-        }),
-    };
-}
-export function selectCompetitors(manifest, explicitIds, roadmapIds) {
-    const known = new Set(manifest.map((entry) => entry.id));
-    for (const id of explicitIds) {
-        if (!known.has(id))
-            throw new Error(`Unknown competitor: ${id}`);
-    }
-    const requestedRoadmap = new Set(roadmapIds.map((id) => id.toUpperCase()));
-    const knownRoadmap = new Set(manifest.flatMap((entry) => [...entry.roadmap]).map((id) => id.toUpperCase()));
-    for (const id of requestedRoadmap) {
-        if (!knownRoadmap.has(id))
-            throw new Error(`Unknown roadmap item: ${id}`);
-    }
-    const selected = new Set(explicitIds);
-    for (const entry of manifest) {
-        if (entry.roadmap.some((id) => requestedRoadmap.has(id.toUpperCase())))
-            selected.add(entry.id);
-    }
-    if (selected.size === 0 && explicitIds.length === 0 && roadmapIds.length === 0) {
-        for (const entry of manifest)
-            selected.add(entry.id);
-    }
-    return manifest.filter((entry) => selected.has(entry.id)).map((entry) => entry.id);
-}
-export function createRunDirectory(root, timestamp, commit) {
-    const stamp = timestamp.replace(/[-:.]/g, "");
-    const directory = path.join(root, `${stamp}-${commit.slice(0, 12)}`);
-    try {
-        fs.mkdirSync(directory, { recursive: false });
-    }
-    catch (error) {
-        if (error.code === "EEXIST") {
-            throw new Error(`Competitive run directory already exists: ${directory}`);
-        }
-        throw error;
-    }
-    return directory;
-}
-function findCompetitorSide(test, competitor) {
-    const candidates = [
-        competitor,
-        competitor.replaceAll("-", ""),
-        competitor.replaceAll("-", "_"),
-        "competitor",
-        "gitnexus",
-        "graphify",
-        "serena",
-        "grepai",
-        "repomix",
-        "aider",
-        "code2prompt",
-        "claudeContext",
-        "codegraph",
-    ];
-    for (const key of candidates) {
-        const value = test[key];
-        if (value && typeof value === "object" && ("ok" in value || "medianMs" in value)) {
-            return value;
-        }
-    }
-    for (const [key, value] of Object.entries(test)) {
-        if (RESERVED_CASE_KEYS.has(key) || !value || typeof value !== "object")
-            continue;
-        if ("ok" in value || "medianMs" in value)
-            return value;
-    }
-    return undefined;
-}
-export function normalizeRawResult(competitor, raw) {
-    const rawRecord = raw && typeof raw === "object"
-        ? raw
-        : {};
-    const results = Array.isArray(rawRecord.results)
-        ? (rawRecord.results ?? [])
-        : [];
-    const partialRun = rawRecord.partial === true || rawRecord.status === "partial";
-    let paired = 0;
-    let knodinFaster = 0;
-    let competitorFaster = 0;
-    let competitorErrors = 0;
-    let knodinErrors = 0;
-    let blocked = 0;
-    const ratios = [];
-    const precisions = [];
-    const recalls = [];
-    let oracleCases = 0;
-    let oraclePassed = 0;
-    let oracleFailed = 0;
-    let oracleUnavailable = 0;
-    let incomparable = 0;
-    let exactMatches = 0;
-    let exactMismatches = 0;
-    let falsePositives = 0;
-    let hasExactMatch = false;
-    let hasFalsePositives = false;
-    let knodinResponseBytes = 0;
-    let competitorResponseBytes = 0;
-    let hasKnodinResponseBytes = false;
-    let hasCompetitorResponseBytes = false;
-    const estimatedTokens = [];
-    const peakRssMb = [];
-    const knodinPeakRssMb = [];
-    const competitorPeakRssMb = [];
-    const diskBytes = [];
-    const modeRatios = {
-        cold: { p50: [], p95: [] },
-        warm: { p50: [], p95: [] },
-    };
-    const attributedResources = Array.isArray(rawRecord.resources)
-        ? rawRecord.resources
-        : [];
-    for (const resource of attributedResources) {
-        for (const [owner, target] of [
-            ["knodin", knodinPeakRssMb],
-            ["competitor", competitorPeakRssMb],
-        ]) {
-            const measurement = resource[owner];
-            if (measurement &&
-                typeof measurement === "object" &&
-                "rssBytes" in measurement &&
-                typeof measurement.rssBytes === "number" &&
-                measurement.rssBytes > 0) {
-                const megabytes = measurement.rssBytes / 1024 / 1024;
-                target.push(megabytes);
-                peakRssMb.push(megabytes);
-            }
-        }
-    }
-    for (const test of results) {
-        if (test.blocked)
-            blocked++;
-        const contender = findCompetitorSide(test, competitor);
-        const knodin = test.knodin;
-        if (contender && contender.ok === false)
-            competitorErrors++;
-        if (knodin && knodin.ok === false)
-            knodinErrors++;
-        const oracle = test.oracle;
-        const contract = test.caseContract;
-        if (contract?.disposition.status === "incomparable")
-            incomparable++;
-        if (!test.blocked) {
-            if (contract?.disposition.status === "comparable") {
-                oracleCases++;
-                if (contract.oracle.status === "passed")
-                    oraclePassed++;
-                else if (contract.oracle.status === "failed")
-                    oracleFailed++;
-                else
-                    oracleUnavailable++;
-            }
-            else if (!contract) {
-                oracleUnavailable++;
-            }
-        }
-        if (oracle && typeof oracle === "object") {
-            if (contract?.disposition.status !== "comparable")
-                oracleCases++;
-            if (typeof oracle.exactMatch === "boolean") {
-                hasExactMatch = true;
-                if (oracle.exactMatch)
-                    exactMatches++;
-                else
-                    exactMismatches++;
-            }
-            if (typeof oracle.precision === "number")
-                precisions.push(oracle.precision);
-            if (typeof oracle.recall === "number")
-                recalls.push(oracle.recall);
-            if (typeof oracle.falsePositives === "number") {
-                hasFalsePositives = true;
-                falsePositives += oracle.falsePositives;
-            }
-        }
-        if (typeof knodin?.responseBytes === "number") {
-            hasKnodinResponseBytes = true;
-            knodinResponseBytes += knodin.responseBytes;
-        }
-        if (typeof contender?.responseBytes === "number") {
-            hasCompetitorResponseBytes = true;
-            competitorResponseBytes += contender.responseBytes;
-        }
-        for (const value of [knodin?.estimatedTokens, contender?.estimatedTokens])
-            if (typeof value === "number")
-                estimatedTokens.push(value);
-        if (typeof knodin?.peakRssMb === "number") {
-            peakRssMb.push(knodin.peakRssMb);
-            knodinPeakRssMb.push(knodin.peakRssMb);
-        }
-        if (typeof contender?.peakRssMb === "number") {
-            peakRssMb.push(contender.peakRssMb);
-            competitorPeakRssMb.push(contender.peakRssMb);
-        }
-        for (const value of [knodin?.diskBytes, contender?.diskBytes])
-            if (typeof value === "number")
-                diskBytes.push(value);
-        if (!partialRun &&
-            test.partial !== true &&
-            contract?.disposition.status === "comparable" &&
-            contract.oracle.status === "passed" &&
-            contender?.ok === true &&
-            knodin?.ok === true &&
-            typeof contender.medianMs === "number" &&
-            typeof knodin.medianMs === "number" &&
-            knodin.medianMs > 0) {
-            const mode = contract.mode;
-            const contenderP50 = contender.p50Ms ?? contender.medianMs;
-            const knodinP50 = knodin.p50Ms ?? knodin.medianMs;
-            paired++;
-            if (contender.medianMs < knodin.medianMs)
-                competitorFaster++;
-            else if (knodin.medianMs < contender.medianMs)
-                knodinFaster++;
-            ratios.push(contender.medianMs / knodin.medianMs);
-            if (knodinP50 > 0)
-                modeRatios[mode].p50.push(contenderP50 / knodinP50);
-            if (typeof contender.p95Ms === "number" &&
-                typeof knodin.p95Ms === "number" &&
-                knodin.p95Ms > 0) {
-                modeRatios[mode].p95.push(contender.p95Ms / knodin.p95Ms);
-            }
-        }
-    }
-    ratios.sort((a, b) => a - b);
-    const median = (values) => {
-        const sorted = [...values].sort((left, right) => left - right);
-        return sorted.length ? sorted[Math.floor(sorted.length / 2)] : null;
-    };
-    return {
-        competitor,
-        cases: results.length,
-        paired,
-        knodinFaster,
-        competitorFaster,
-        competitorErrors,
-        knodinErrors,
-        blocked,
-        medianRatio: ratios.length ? ratios[Math.floor(ratios.length / 2)] : null,
-        correctness: {
-            oracleCases,
-            oraclePassed,
-            oracleFailed,
-            oracleUnavailable,
-            incomparable,
-            exactMatches: hasExactMatch ? exactMatches : null,
-            exactMismatches: hasExactMatch ? exactMismatches : null,
-            precision: precisions.length
-                ? precisions.reduce((sum, value) => sum + value, 0) / precisions.length
-                : null,
-            recall: recalls.length
-                ? recalls.reduce((sum, value) => sum + value, 0) / recalls.length
-                : null,
-            falsePositives: hasFalsePositives ? falsePositives : null,
-        },
-        performance: {
-            latencySamples: ratios.length,
-            modes: Object.fromEntries(["cold", "warm"]
-                .filter((mode) => modeRatios[mode].p50.length > 0)
-                .map((mode) => [
-                mode,
-                {
-                    paired: modeRatios[mode].p50.length,
-                    p50Ratio: median(modeRatios[mode].p50),
-                    p95Ratio: median(modeRatios[mode].p95),
-                },
-            ])),
-            knodinResponseBytes: hasKnodinResponseBytes ? knodinResponseBytes : null,
-            competitorResponseBytes: hasCompetitorResponseBytes ? competitorResponseBytes : null,
-            estimatedTokens: estimatedTokens.length
-                ? estimatedTokens.reduce((sum, value) => sum + value, 0)
-                : null,
-            knodinPeakRssMb: knodinPeakRssMb.length ? Math.max(...knodinPeakRssMb) : null,
-            competitorPeakRssMb: competitorPeakRssMb.length ? Math.max(...competitorPeakRssMb) : null,
-            peakRssMb: peakRssMb.length ? Math.max(...peakRssMb) : null,
-            diskBytes: diskBytes.length ? Math.max(...diskBytes) : null,
-        },
-    };
-}
-export function compareSummaries(baseline, current, latencyTolerance = 0.1) {
-    if (!Number.isFinite(latencyTolerance) || latencyTolerance < 0) {
-        throw new Error("Latency tolerance must be a non-negative number");
-    }
-    const reasons = [];
-    if (current.paired < baseline.paired)
-        reasons.push(`Paired cases fell by ${baseline.paired - current.paired}`);
-    if (current.knodinFaster < baseline.knodinFaster) {
-        reasons.push(`knodin wins fell by ${baseline.knodinFaster - current.knodinFaster}`);
-    }
-    if (current.knodinErrors > baseline.knodinErrors) {
-        reasons.push(`knodin errors increased by ${current.knodinErrors - baseline.knodinErrors}`);
-    }
-    if (baseline.performance && current.performance) {
-        for (const mode of ["cold", "warm"]) {
-            const before = baseline.performance.modes?.[mode];
-            const after = current.performance.modes?.[mode];
-            if (!before || !after)
-                continue;
-            for (const percentile of ["p50Ratio", "p95Ratio"]) {
-                const beforeValue = before[percentile];
-                const afterValue = after[percentile];
-                if (beforeValue !== null &&
-                    afterValue !== null &&
-                    afterValue < beforeValue * (1 - latencyTolerance)) {
-                    reasons.push(`${mode} ${percentile.replace("Ratio", "")} competitor/knodin ratio fell from ${beforeValue.toFixed(3)} to ${afterValue.toFixed(3)}`);
-                }
-            }
-        }
-    }
-    else if (baseline.medianRatio !== null &&
-        current.medianRatio !== null &&
-        current.medianRatio < baseline.medianRatio * (1 - latencyTolerance)) {
-        reasons.push(`Competitor/knodin median ratio fell from ${baseline.medianRatio.toFixed(3)} to ${current.medianRatio.toFixed(3)}`);
-    }
-    return {
-        regressed: reasons.length > 0,
-        reasons,
-        deltas: {
-            paired: current.paired - baseline.paired,
-            knodinFaster: current.knodinFaster - baseline.knodinFaster,
-            competitorFaster: current.competitorFaster - baseline.competitorFaster,
-            competitorErrors: current.competitorErrors - baseline.competitorErrors,
-            knodinErrors: current.knodinErrors - baseline.knodinErrors,
-            medianRatio: baseline.medianRatio === null || current.medianRatio === null
-                ? null
-                : current.medianRatio - baseline.medianRatio,
-        },
-    };
-}