ppef 1.0.0 → 1.1.0

package/dist/__tests__/test-helpers.js

@@ -0,0 +1,271 @@
+/**
+ * Test Helpers for Framework Tests
+ *
+ * Factory functions for creating mock evaluation results, aggregates,
+ * and claims for testing the evaluation framework.
+ */
+/**
+ * Create a mock EvaluationResult with sensible defaults.
+ *
+ * @param overrides - Partial fields to override defaults
+ * @returns A complete EvaluationResult
+ */
+export const createMockResult = (overrides) => {
+    const defaultRun = {
+        runId: "mock-run-001",
+        sut: "test-sut-v1.0.0",
+        sutRole: "primary",
+        caseId: "test-case-001",
+        caseClass: "test-class",
+    };
+    const defaultCorrectness = {
+        expectedExists: true,
+        producedOutput: true,
+        valid: true,
+        matchesExpected: true,
+    };
+    const defaultOutputs = {
+        summary: {},
+    };
+    const defaultMetrics = {
+        numeric: {
+            "execution-time": 100,
+            "nodes-expanded": 50,
+            "path-diversity": 0.75,
+        },
+    };
+    const defaultProvenance = {
+        runtime: {
+            platform: "darwin",
+            arch: "arm64",
+            nodeVersion: "20.0.0",
+        },
+        timestamp: new Date().toISOString(),
+    };
+    return {
+        run: { ...defaultRun, ...overrides?.run },
+        correctness: { ...defaultCorrectness, ...overrides?.correctness },
+        outputs: { ...defaultOutputs, ...overrides?.outputs },
+        metrics: { ...defaultMetrics, ...overrides?.metrics },
+        provenance: { ...defaultProvenance, ...overrides?.provenance },
+    };
+};
+/**
+ * Create multiple mock results for a specific SUT.
+ *
+ * @param count - Number of results to create
+ * @param sut - SUT identifier
+ * @param role - SUT role (default: "primary")
+ * @param caseClass - Optional case class
+ * @returns Array of EvaluationResults
+ */
+export const createMockResults = (count, sut, role = "primary", caseClass) => Array.from({ length: count }, (_, index) => createMockResult({
+    run: {
+        runId: `${sut}-run-${index.toString().padStart(3, "0")}`,
+        sut,
+        sutRole: role,
+        caseId: `case-${index.toString().padStart(3, "0")}`,
+        caseClass,
+    },
+    metrics: {
+        numeric: {
+            "execution-time": 100 + Math.random() * 50,
+            "nodes-expanded": 50 + Math.floor(Math.random() * 20),
+            "path-diversity": 0.5 + Math.random() * 0.4,
+        },
+    },
+}));
+/**
+ * Create mock SummaryStats.
+ *
+ * @param values - Array of values to compute stats from
+ * @returns SummaryStats
+ */
+export const createMockSummaryStats = (values) => {
+    if (values.length === 0) {
+        return {
+            n: 0,
+            mean: Number.NaN,
+            median: Number.NaN,
+            min: Number.NaN,
+            max: Number.NaN,
+        };
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const n = values.length;
+    const sum = values.reduce((accumulator, v) => accumulator + v, 0);
+    const mean = sum / n;
+    const midIndex = Math.floor(n / 2);
+    const median = n % 2 === 0 ? (sorted[midIndex - 1] + sorted[midIndex]) / 2 : sorted[midIndex];
+    let std;
+    if (n > 1) {
+        const variance = values.map((v) => (v - mean) ** 2).reduce((accumulator, v) => accumulator + v, 0) / (n - 1);
+        std = Math.sqrt(variance);
+    }
+    return {
+        n,
+        mean,
+        median,
+        min: sorted[0],
+        max: sorted[n - 1],
+        std,
+        sum,
+    };
+};
+/**
+ * Create mock AggregatedResult.
+ *
+ * @param sut - SUT identifier
+ * @param role - SUT role
+ * @param caseClass - Optional case class
+ * @param metrics - Optional metrics map
+ * @returns AggregatedResult
+ */
+export const createMockAggregate = (sut, role = "primary", caseClass, metrics) => {
+    const defaultMetrics = {
+        "execution-time": createMockSummaryStats([100, 110, 105, 115, 120]),
+        "nodes-expanded": createMockSummaryStats([50, 55, 52, 58, 60]),
+        "path-diversity": createMockSummaryStats([0.7, 0.75, 0.72, 0.78, 0.8]),
+    };
+    return {
+        sut,
+        sutRole: role,
+        caseClass,
+        group: {
+            runCount: 5,
+            caseCount: 5,
+        },
+        correctness: {
+            validRate: 1,
+            producedOutputRate: 1,
+            matchesExpectedRate: 1,
+        },
+        metrics: metrics ?? defaultMetrics,
+    };
+};
+/**
+ * Create mock aggregates for testing comparisons.
+ *
+ * @returns Array with primary and baseline aggregates
+ */
+export const createMockAggregates = () => [
+    createMockAggregate("degree-prioritised-v1.0.0", "primary", "scale-free", {
+        "execution-time": createMockSummaryStats([80, 85, 82, 88, 90]),
+        "nodes-expanded": createMockSummaryStats([40, 45, 42, 48, 50]),
+    }),
+    createMockAggregate("standard-bfs-v1.0.0", "baseline", "scale-free", {
+        "execution-time": createMockSummaryStats([120, 125, 122, 128, 130]),
+        "nodes-expanded": createMockSummaryStats([70, 75, 72, 78, 80]),
+    }),
+    createMockAggregate("frontier-balanced-v1.0.0", "baseline", "scale-free", {
+        "execution-time": createMockSummaryStats([100, 105, 102, 108, 110]),
+        "nodes-expanded": createMockSummaryStats([60, 65, 62, 68, 70]),
+    }),
+];
+/**
+ * Create a mock EvaluationClaim.
+ *
+ * @param overrides - Partial fields to override defaults
+ * @returns EvaluationClaim
+ */
+export const createMockClaim = (overrides) => ({
+    claimId: "C001",
+    description: "Primary SUT is faster than baseline",
+    sut: "degree-prioritised-v1.0.0",
+    baseline: "standard-bfs-v1.0.0",
+    metric: "execution-time",
+    direction: "less",
+    scope: "global",
+    ...overrides,
+});
+/**
+ * Create mock ClaimEvidence.
+ *
+ * @param overrides - Partial fields to override defaults
+ * @returns ClaimEvidence
+ */
+export const createMockEvidence = (overrides) => ({
+    primaryValue: 85,
+    baselineValue: 125,
+    delta: -40,
+    ratio: 0.68,
+    pValue: 0.01,
+    effectSize: 1.5,
+    n: 10,
+    ...overrides,
+});
+/**
+ * Create mock ClaimEvaluation.
+ *
+ * @param status - Claim status
+ * @param claim - Optional claim
+ * @param evidence - Optional evidence
+ * @returns ClaimEvaluation
+ */
+export const createMockClaimEvaluation = (status = "satisfied", claim, evidence) => ({
+    claim: createMockClaim(claim),
+    status,
+    evidence: createMockEvidence(evidence),
+});
+/**
+ * Create an array of mock results with varying metrics.
+ * Useful for testing aggregation and statistics.
+ *
+ * @param executionTimes - Array of execution times
+ * @param sut - SUT identifier
+ * @param role - SUT role
+ * @returns Array of EvaluationResults
+ */
+export const createMockResultsWithMetrics = (executionTimes, sut, role = "primary") => executionTimes.map((time, index) => createMockResult({
+    run: {
+        runId: `${sut}-run-${index.toString().padStart(3, "0")}`,
+        sut,
+        sutRole: role,
+        caseId: `case-${index.toString().padStart(3, "0")}`,
+    },
+    metrics: {
+        numeric: {
+            "execution-time": time,
+        },
+    },
+}));
+/**
+ * Create a minimal valid result for validation tests.
+ * Returns the bare minimum fields required by the schema.
+ */
+export const createMinimalValidResult = () => ({
+    run: {
+        runId: "minimal-001",
+        sut: "test-sut",
+        sutRole: "primary",
+        caseId: "test-case",
+    },
+    correctness: {
+        expectedExists: false,
+        producedOutput: true,
+        valid: true,
+        matchesExpected: null,
+    },
+    outputs: {},
+    metrics: {
+        numeric: {},
+    },
+    provenance: {
+        runtime: {
+            platform: "test",
+            arch: "test",
+            nodeVersion: "20.0.0",
+        },
+    },
+});
+/**
+ * Create an invalid result missing required fields.
+ * Useful for testing validation logic.
+ */
+export const createInvalidResult = () => ({
+    run: {
+    // Missing runId, sut, sutRole, caseId
+    },
+    // Missing correctness, metrics, provenance
+});
+//# sourceMappingURL=test-helpers.js.map

package/dist/__tests__/test-helpers.js.map

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

package/dist/aggregation/__tests__/aggregators.unit.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unit tests for Aggregation Functions
+ *
+ * Tests the pure functions for computing aggregated statistics.
+ */
+export {};
+//# sourceMappingURL=aggregators.unit.test.d.ts.map

package/dist/aggregation/__tests__/aggregators.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregators.unit.test.d.ts","sourceRoot":"","sources":["../../../src/aggregation/__tests__/aggregators.unit.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/aggregation/__tests__/aggregators.unit.test.js

@@ -0,0 +1,350 @@
+/**
+ * Unit tests for Aggregation Functions
+ *
+ * Tests the pure functions for computing aggregated statistics.
+ */
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { computeSummaryStats, computeSpeedup, computeMaxSpeedup, computeComparison, computeRankings, getTValue, } from "../aggregators.js";
+import { createMockResult } from "../../__tests__/test-helpers.js";
+describe("computeSummaryStats", () => {
+    it("should return NaN values for empty array", () => {
+        const result = computeSummaryStats([]);
+        assert.strictEqual(result.n, 0);
+        assert.ok(Number.isNaN(result.mean));
+        assert.ok(Number.isNaN(result.median));
+        assert.ok(Number.isNaN(result.min));
+        assert.ok(Number.isNaN(result.max));
+    });
+    it("should compute basic statistics for single value", () => {
+        const result = computeSummaryStats([42]);
+        assert.strictEqual(result.n, 1);
+        assert.strictEqual(result.mean, 42);
+        assert.strictEqual(result.median, 42);
+        assert.strictEqual(result.min, 42);
+        assert.strictEqual(result.max, 42);
+        assert.strictEqual(result.std, undefined);
+        assert.strictEqual(result.confidence95, undefined);
+    });
+    it("should compute statistics for multiple values", () => {
+        const result = computeSummaryStats([1, 2, 3, 4, 5]);
+        assert.strictEqual(result.n, 5);
+        assert.strictEqual(result.mean, 3);
+        assert.strictEqual(result.median, 3);
+        assert.strictEqual(result.min, 1);
+        assert.strictEqual(result.max, 5);
+        assert.ok(result.std !== undefined);
+        assert.ok(result.std > 0);
+    });
+    it("should compute median for even-length arrays", () => {
+        const result = computeSummaryStats([1, 2, 3, 4]);
+        assert.strictEqual(result.median, 2.5); // (2 + 3) / 2
+    });
+    it("should compute 95% confidence interval", () => {
+        const result = computeSummaryStats([10, 12, 14, 16, 18]);
+        assert.ok(result.confidence95 !== undefined);
+        assert.ok(result.confidence95[0] < result.mean);
+        assert.ok(result.confidence95[1] > result.mean);
+    });
+    it("should compute percentiles", () => {
+        const result = computeSummaryStats([1, 2, 3, 4, 5, 6, 7, 8]);
+        assert.strictEqual(result.p25, 3); // Floor of 8 * 0.25 = 2, sorted[2] = 3
+        assert.strictEqual(result.p75, 7); // Floor of 8 * 0.75 = 6, sorted[6] = 7
+    });
+});
+describe("computeSpeedup", () => {
+    it("should compute speedup ratio", () => {
+        const result = computeSpeedup(100, 50);
+        assert.strictEqual(result, 2); // 100 / 50 = 2x speedup
+    });
+    it("should return Infinity for zero treatment time", () => {
+        const result = computeSpeedup(100, 0);
+        assert.strictEqual(result, Infinity);
+    });
+    it("should handle slower treatment", () => {
+        const result = computeSpeedup(50, 100);
+        assert.strictEqual(result, 0.5); // 50 / 100 = 0.5x (slower)
+    });
+});
+describe("computeMaxSpeedup", () => {
+    it("should return 0 for empty pairs", () => {
+        const result = computeMaxSpeedup([]);
+        assert.strictEqual(result, 0);
+    });
+    it("should compute maximum speedup from pairs", () => {
+        const pairs = [
+            [100, 50], // 2x
+            [100, 25], // 4x
+            [100, 100], // 1x
+        ];
+        const result = computeMaxSpeedup(pairs);
+        assert.strictEqual(result, 4); // Maximum is 4x
+    });
+    it("should handle pairs with zero treatment time", () => {
+        const pairs = [
+            [100, 50],
+            [100, 0], // Infinity
+            [100, 25],
+        ];
+        const result = computeMaxSpeedup(pairs);
+        assert.strictEqual(result, Infinity);
+    });
+    it("should handle single pair", () => {
+        const pairs = [[100, 25]];
+        const result = computeMaxSpeedup(pairs);
+        assert.strictEqual(result, 4);
+    });
+});
+describe("computeComparison", () => {
+    it("should return default values when no common case IDs", () => {
+        const primaryResults = [
+            createMockResult({
+                run: { runId: "p1", sut: "primary", sutRole: "primary", caseId: "primary-case-1" },
+            }),
+            createMockResult({
+                run: { runId: "p2", sut: "primary", sutRole: "primary", caseId: "primary-case-2" },
+            }),
+        ];
+        const baselineResults = [
+            createMockResult({
+                run: { runId: "b1", sut: "baseline", sutRole: "baseline", caseId: "baseline-case-1" },
+            }),
+            createMockResult({
+                run: { runId: "b2", sut: "baseline", sutRole: "baseline", caseId: "baseline-case-2" },
+            }),
+        ];
+        const result = computeComparison(primaryResults, baselineResults, "execution-time");
+        assert.deepStrictEqual(result.deltas, { default: 0 });
+        assert.deepStrictEqual(result.ratios, { default: 1 });
+    });
+    it("should compute delta and ratio for matching cases", () => {
+        const primaryResults = [
+            createMockResult({
+                run: { runId: "p1", sut: "primary", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 80 } },
+            }),
+            createMockResult({
+                run: { runId: "p2", sut: "primary", sutRole: "primary", caseId: "case-2" },
+                metrics: { numeric: { "execution-time": 120 } },
+            }),
+        ];
+        const baselineResults = [
+            createMockResult({
+                run: { runId: "b1", sut: "baseline", sutRole: "baseline", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 100 } },
+            }),
+            createMockResult({
+                run: { runId: "b2", sut: "baseline", sutRole: "baseline", caseId: "case-2" },
+                metrics: { numeric: { "execution-time": 100 } },
+            }),
+        ];
+        const result = computeComparison(primaryResults, baselineResults, "execution-time");
+        // Primary mean = 100, baseline mean = 100
+        assert.strictEqual(result.deltas.default, 0);
+        assert.strictEqual(result.ratios.default, 1);
+    });
+    it("should compute better rate (wins)", () => {
+        const primaryResults = [
+            createMockResult({
+                run: { runId: "p1", sut: "primary", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { accuracy: 0.9 } },
+            }),
+            createMockResult({
+                run: { runId: "p2", sut: "primary", sutRole: "primary", caseId: "case-2" },
+                metrics: { numeric: { accuracy: 0.7 } },
+            }),
+            createMockResult({
+                run: { runId: "p3", sut: "primary", sutRole: "primary", caseId: "case-3" },
+                metrics: { numeric: { accuracy: 0.85 } },
+            }),
+        ];
+        const baselineResults = [
+            createMockResult({
+                run: { runId: "b1", sut: "baseline", sutRole: "baseline", caseId: "case-1" },
+                metrics: { numeric: { accuracy: 0.8 } },
+            }),
+            createMockResult({
+                run: { runId: "b2", sut: "baseline", sutRole: "baseline", caseId: "case-2" },
+                metrics: { numeric: { accuracy: 0.8 } },
+            }),
+            createMockResult({
+                run: { runId: "b3", sut: "baseline", sutRole: "baseline", caseId: "case-3" },
+                metrics: { numeric: { accuracy: 0.8 } },
+            }),
+        ];
+        const result = computeComparison(primaryResults, baselineResults, "accuracy");
+        // Primary wins: case-1 (0.9 > 0.8), loses case-2 (0.7 < 0.8), wins case-3 (0.85 > 0.8)
+        // Win rate = 2/3 ≈ 0.667
+        assert.ok(result.betterRate > 0.6);
+        assert.ok(result.betterRate < 0.7);
+    });
+    it("should return infinite ratio when baseline mean is zero", () => {
+        const primaryResults = [
+            createMockResult({
+                run: { runId: "p1", sut: "primary", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { errors: 0 } },
+            }),
+        ];
+        const baselineResults = [
+            createMockResult({
+                run: { runId: "b1", sut: "baseline", sutRole: "baseline", caseId: "case-1" },
+                metrics: { numeric: { errors: 0 } },
+            }),
+        ];
+        const result = computeComparison(primaryResults, baselineResults, "errors");
+        // When both means are 0, ratio should be 0/0 which is handled specially
+        // Actually looking at the code, if baselineStats.mean === 0, ratio = Infinity
+        assert.strictEqual(result.ratios.default, Infinity);
+    });
+    it("should compute pValue using Mann-Whitney U test", () => {
+        const primaryResults = [
+            createMockResult({
+                run: { runId: "p1", sut: "primary", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 100 } },
+            }),
+        ];
+        const baselineResults = [
+            createMockResult({
+                run: { runId: "b1", sut: "baseline", sutRole: "baseline", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 100 } },
+            }),
+        ];
+        const result = computeComparison(primaryResults, baselineResults, "execution-time");
+        assert.ok(typeof result.pValue === "number");
+        assert.ok(typeof result.uStatistic === "number");
+    });
+    it("should compute effect size when both samples have variance", () => {
+        const primaryResults = [
+            createMockResult({
+                run: { runId: "p1", sut: "primary", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 80 } },
+            }),
+            createMockResult({
+                run: { runId: "p2", sut: "primary", sutRole: "primary", caseId: "case-2" },
+                metrics: { numeric: { "execution-time": 120 } },
+            }),
+        ];
+        const baselineResults = [
+            createMockResult({
+                run: { runId: "b1", sut: "baseline", sutRole: "baseline", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 95 } },
+            }),
+            createMockResult({
+                run: { runId: "b2", sut: "baseline", sutRole: "baseline", caseId: "case-2" },
+                metrics: { numeric: { "execution-time": 105 } },
+            }),
+        ];
+        const result = computeComparison(primaryResults, baselineResults, "execution-time");
+        assert.ok(result.effectSize !== undefined);
+        assert.ok(result.effectSize >= 0);
+    });
+});
+describe("computeRankings", () => {
+    it("should rank results by metric in descending order (default)", () => {
+        const results = [
+            createMockResult({
+                run: { runId: "r1", sut: "sut-1", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { score: 0.8 } },
+            }),
+            createMockResult({
+                run: { runId: "r2", sut: "sut-2", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { score: 0.95 } },
+            }),
+            createMockResult({
+                run: { runId: "r3", sut: "sut-3", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { score: 0.7 } },
+            }),
+        ];
+        const rankings = computeRankings(results, "score");
+        assert.strictEqual(rankings.length, 3);
+        assert.strictEqual(rankings[0].rank, 1);
+        assert.strictEqual(rankings[0].result.run.runId, "r2"); // Highest score gets rank 1
+        assert.strictEqual(rankings[2].rank, 3);
+        assert.strictEqual(rankings[2].result.run.runId, "r3"); // Lowest score gets rank 3
+    });
+    it("should rank results in ascending order when specified", () => {
+        const results = [
+            createMockResult({
+                run: { runId: "r1", sut: "sut-1", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 100 } },
+            }),
+            createMockResult({
+                run: { runId: "r2", sut: "sut-2", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 50 } },
+            }),
+            createMockResult({
+                run: { runId: "r3", sut: "sut-3", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { "execution-time": 75 } },
+            }),
+        ];
+        const rankings = computeRankings(results, "execution-time", true);
+        assert.strictEqual(rankings[0].rank, 1);
+        assert.strictEqual(rankings[0].result.run.runId, "r2"); // Fastest (lowest time) gets rank 1
+        assert.strictEqual(rankings[2].rank, 3);
+        assert.strictEqual(rankings[2].result.run.runId, "r1"); // Slowest (highest time) gets rank 3
+    });
+    it("should filter out results with missing or NaN metric values", () => {
+        const results = [
+            createMockResult({
+                run: { runId: "r1", sut: "sut-1", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { score: 0.8 } },
+            }),
+            createMockResult({
+                run: { runId: "r2", sut: "sut-2", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: {} }, // Missing metric
+            }),
+        ];
+        const rankings = computeRankings(results, "score");
+        assert.strictEqual(rankings.length, 1); // Only r1 has the metric
+        assert.strictEqual(rankings[0].result.run.runId, "r1");
+    });
+    it("should return empty array when no results have the metric", () => {
+        const results = [
+            createMockResult({
+                run: { runId: "r1", sut: "sut-1", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: {} },
+            }),
+        ];
+        const rankings = computeRankings(results, "nonexistent");
+        assert.deepStrictEqual(rankings, []);
+    });
+    it("should handle ties in metric values", () => {
+        const results = [
+            createMockResult({
+                run: { runId: "r1", sut: "sut-1", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { score: 0.9 } },
+            }),
+            createMockResult({
+                run: { runId: "r2", sut: "sut-2", sutRole: "primary", caseId: "case-1" },
+                metrics: { numeric: { score: 0.9 } },
+            }),
+        ];
+        const rankings = computeRankings(results, "score");
+        assert.strictEqual(rankings.length, 2);
+        // Both have rank 1 and 2 due to sort stability
+        assert.ok(rankings.every((r) => r.value === 0.9));
+    });
+});
+describe("getTValue", () => {
+    it("should return t-value from lookup table for 95% CI", () => {
+        const t10 = getTValue(10, 0.975);
+        assert.strictEqual(t10, 2.228);
+        const t30 = getTValue(30, 0.975);
+        assert.strictEqual(t30, 2.042);
+        const t100 = getTValue(100, 0.975);
+        assert.strictEqual(t100, 1.984);
+    });
+    it("should return z-value fallback for non-standard probability", () => {
+        const result = getTValue(50, 0.99);
+        assert.strictEqual(result, 1.96); // z-value for large samples
+    });
+    it("should return z-value fallback for 90% CI", () => {
+        const result = getTValue(50, 0.95); // 90% two-tailed = 0.95
+        assert.strictEqual(result, 1.96);
+    });
+    it("should return z-value fallback for 99% CI", () => {
+        const result = getTValue(50, 0.995); // 99% two-tailed = 0.995
+        assert.strictEqual(result, 1.96);
+    });
+});
+//# sourceMappingURL=aggregators.unit.test.js.map