@ac-bench/measure-constant-time 0.1.0

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024-2026 Anthony Champagne and contributors
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,31 @@
+# @ac-bench/measure-constant-time
+
+Detects whether an operation's runtime depends on its input — the timing leak
+that lets an attacker recover a secret without ever guessing it whole.
+
+This is the dudect approach: run two closures under a randomly interleaved
+schedule, crop the distribution tails to discard scheduler noise, and report
+Welch's t-statistic. A large statistic means the two inputs are
+distinguishable by timing alone.
+
+```ts
+import { constantTimeCase, constantTimeCondition } from "@ac-bench/measure-constant-time";
+
+constantTimeCondition("tag comparison", () => {
+  constantTimeCase(
+    "constantTimeBytesIsEqual",
+    () => compare(correctTag, correctTag),
+    () => compare(correctTag, wrongFirstByte),
+  );
+});
+```
+
+The two closures are the classes being told apart. A large statistic means an
+attacker could distinguish them by timing alone.
+
+A passing result is evidence, not proof: it shows no leak was detected at this
+sample size, on this machine, against this compiler's output.
+
+Host-bound for `hrtime.bigint()`'s nanosecond resolution.
+
+Run suites with the `measure` CLI from `@ac-bench/cli`.

package/dist/_collect.d.ts

@@ -0,0 +1,50 @@
+import { MaybeAsyncCallableNoArgs, RandomFn } from "@ac-kit/core";
+/** Two classes of raw, per-execution timing samples, in nanoseconds. */
+export interface InterleavedTimings {
+    classA: number[];
+    classB: number[];
+}
+/** Options for {@link collectInterleavedTimings}. */
+export type CollectOptions = {
+    /** Executions of each closure to measure. Default `5000`. */
+    samples?: number;
+    /** Unmeasured executions of each closure before timing starts. Default `200`. */
+    warmup?: number;
+    /**
+     * High-resolution clock, in nanoseconds. A real run passes `hrtime.bigint`; a
+     * test injects a scripted clock instead of timing the host it runs on.
+     */
+    now: () => bigint;
+    /**
+     * Source of randomness for the shuffle that decides execution order. Fixed by
+     * the caller's choice of seed, so a run that finds no leak is reproducible
+     * rather than "passed this time".
+     */
+    random: RandomFn;
+    signal?: AbortSignal | null;
+    beforeMeasure?: MaybeAsyncCallableNoArgs;
+    afterMeasure?: MaybeAsyncCallableNoArgs;
+};
+/**
+ * Times `classA` and `classB` in a randomly interleaved order and returns the
+ * raw per-execution durations for each, in nanoseconds.
+ *
+ * Randomising the order — rather than running all of `classA` and then all of
+ * `classB` — is the difference between this and an ordinary benchmark run: a
+ * systematic drift over the run (CPU frequency scaling, thermal throttling,
+ * background load) would otherwise land almost entirely on whichever class ran
+ * second, and get mistaken for the class itself being slower.
+ *
+ * Both closures must be synchronous. An `await` inside the timed region would
+ * add microtask-queue scheduling jitter on the order of microseconds, which
+ * swamps the nanosecond-to-low-microsecond differences this is built to
+ * detect.
+ *
+ * @param classA First closure to time.
+ * @param classB Second closure to time.
+ * @param options Sampling policy, clock and randomness.
+ * @returns The two classes' raw timings, in the order they were collected
+ *   within each class (not the randomised execution order).
+ */
+export declare function collectInterleavedTimings(classA: () => void, classB: () => void, options: CollectOptions): Promise<InterleavedTimings>;
+//# sourceMappingURL=_collect.d.ts.map

package/dist/_collect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_collect.d.ts","sourceRoot":"","sources":["../src/_collect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAElE,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IAClC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,qDAAqD;AACrD,MAAM,MAAM,cAAc,GAAG;IAC5B,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,GAAG,EAAE,MAAM,MAAM,CAAC;IAElB;;;;OAIG;IACH,MAAM,EAAE,QAAQ,CAAC;IAEjB,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAE5B,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,YAAY,CAAC,EAAE,wBAAwB,CAAC;CACxC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,yBAAyB,CAC9C,MAAM,EAAE,MAAM,IAAI,EAClB,MAAM,EAAE,MAAM,IAAI,EAClB,OAAO,EAAE,cAAc,GACrB,OAAO,CAAC,kBAAkB,CAAC,CA8C7B"}

package/dist/_collect.js

@@ -0,0 +1,62 @@
+import { shuffle } from "@ac-kit/algo";
+/**
+ * Times `classA` and `classB` in a randomly interleaved order and returns the
+ * raw per-execution durations for each, in nanoseconds.
+ *
+ * Randomising the order — rather than running all of `classA` and then all of
+ * `classB` — is the difference between this and an ordinary benchmark run: a
+ * systematic drift over the run (CPU frequency scaling, thermal throttling,
+ * background load) would otherwise land almost entirely on whichever class ran
+ * second, and get mistaken for the class itself being slower.
+ *
+ * Both closures must be synchronous. An `await` inside the timed region would
+ * add microtask-queue scheduling jitter on the order of microseconds, which
+ * swamps the nanosecond-to-low-microsecond differences this is built to
+ * detect.
+ *
+ * @param classA First closure to time.
+ * @param classB Second closure to time.
+ * @param options Sampling policy, clock and randomness.
+ * @returns The two classes' raw timings, in the order they were collected
+ *   within each class (not the randomised execution order).
+ */
+export async function collectInterleavedTimings(classA, classB, options) {
+    options.signal?.throwIfAborted();
+    const samples = options.samples ?? 5000;
+    const warmup = options.warmup ?? 200;
+    for (let index = 0; index < warmup; index++) {
+        options.signal?.throwIfAborted();
+        await options.beforeMeasure?.();
+        classA();
+        classB();
+        await options.afterMeasure?.();
+    }
+    // A flat, shuffled sequence of labels decides execution order up front,
+    // rather than shuffling per pair — a per-pair coin flip still lets both
+    // classes fall into short local runs that a slow drift can bias.
+    const order = Array.from({ length: 2 * samples });
+    for (let index = 0; index < samples; index++) {
+        order[2 * index] = 0;
+        order[2 * index + 1] = 1;
+    }
+    const shuffledOrder = shuffle(order, { rand: options.random });
+    const classATimings = [];
+    const classBTimings = [];
+    for (const label of shuffledOrder) {
+        options.signal?.throwIfAborted();
+        await options.beforeMeasure?.();
+        if (label === 0) {
+            const started = options.now();
+            classA();
+            classATimings.push(Number(options.now() - started));
+        }
+        else {
+            const started = options.now();
+            classB();
+            classBTimings.push(Number(options.now() - started));
+        }
+        await options.afterMeasure?.();
+    }
+    return { classA: classATimings, classB: classBTimings };
+}
+//# sourceMappingURL=_collect.js.map

package/dist/_collect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_collect.js","sourceRoot":"","sources":["../src/_collect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAoCvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC9C,MAAkB,EAClB,MAAkB,EAClB,OAAuB;IAEvB,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;IAEjC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC;IACxC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,GAAG,CAAC;IAErC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC7C,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;QAEjC,MAAM,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;QAChC,MAAM,EAAE,CAAC;QACT,MAAM,EAAE,CAAC;QACT,MAAM,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC;IAChC,CAAC;IAED,wEAAwE;IACxE,wEAAwE;IACxE,iEAAiE;IACjE,MAAM,KAAK,GAAc,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,CAAC;IAC7D,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC;QAC9C,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;QACrB,KAAK,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE/D,MAAM,aAAa,GAAa,EAAE,CAAC;IACnC,MAAM,aAAa,GAAa,EAAE,CAAC;IAEnC,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE,CAAC;QACnC,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;QAEjC,MAAM,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;QAChC,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YACjB,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;YAC9B,MAAM,EAAE,CAAC;YACT,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;QACrD,CAAC;aAAM,CAAC;YACP,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;YAC9B,MAAM,EAAE,CAAC;YACT,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;QACrD,CAAC;QACD,MAAM,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC;IAChC,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;AACzD,CAAC"}

package/dist/_dudect.d.ts

@@ -0,0 +1,55 @@
+import { CollectOptions } from "./_collect.js";
+/** `|t|` above which dudect-style tools conventionally report a leak. */
+export declare const DEFAULT_LEAK_THRESHOLD = 4.5;
+/** Default seed for {@link CollectOptions.random}, reproducible across runs. */
+export declare const DEFAULT_SEED = 1592590337;
+/** Options for {@link runDudectCheck}, extending the collection policy. */
+export type DudectOptions = CollectOptions & {
+    /**
+     * Upper-tail quantile beyond which a sample is dropped before the statistic
+     * is computed. Default `0.995`.
+     *
+     * Real hardware occasionally delays an execution far past its typical cost —
+     * an interrupt, a GC pause, a context switch — and those delays land on both
+     * classes equally often, so they dilute a real signal rather than create a
+     * false one. Cropping only the slow tail, symmetrically for both classes,
+     * removes that noise without touching the difference this is looking for.
+     */
+    cropQuantile?: number;
+    /** `|t|` above which {@link DudectResult.leakDetected} is `true`. */
+    leakThreshold?: number;
+};
+export type DudectResult = {
+    /** Welch's t-statistic on the (cropped) timing samples. */
+    t: number;
+    /** Welch–Satterthwaite degrees of freedom for `t`. */
+    degreesOfFreedom: number;
+    /** Samples collected per class, before cropping. */
+    samplesPerClass: number;
+    /** `true` when `|t|` exceeds the threshold. */
+    leakDetected: boolean;
+};
+/**
+ * A dudect-style constant-time check: times `classA` and `classB` under a
+ * randomly interleaved schedule (see {@link collectInterleavedTimings}) and
+ * reports whether their timing distributions are distinguishable.
+ *
+ * This only ever answers "is a timing difference detectable in this many
+ * samples", never "why" — a positive result still needs a human to find the
+ * secret-dependent branch or memory access it came from, and a negative result
+ * only means none was found at this sample count, not that none exists.
+ * Increase {@link CollectOptions.samples} to raise the harness's power to
+ * detect a smaller leak.
+ *
+ * The classic dudect design compares one **fixed** secret input, called
+ * repeatedly, against a **new random** secret input generated for every call of
+ * the other class — pass closures built that way, not two closures over the
+ * same fixed input or the test has no power to detect anything.
+ *
+ * @param classA First closure to time.
+ * @param classB Second closure to time.
+ * @param options Sampling, cropping and threshold policy.
+ * @returns The statistic and its leak verdict.
+ */
+export declare function runDudectCheck(classA: () => void, classB: () => void, options: DudectOptions): Promise<DudectResult>;
+//# sourceMappingURL=_dudect.d.ts.map

package/dist/_dudect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dudect.d.ts","sourceRoot":"","sources":["../src/_dudect.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAA6B,MAAM,eAAe,CAAC;AAE1E,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,gFAAgF;AAChF,eAAO,MAAM,YAAY,aAAc,CAAC;AAExC,2EAA2E;AAC3E,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG;IAC5C;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,qEAAqE;IACrE,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IAC1B,2DAA2D;IAC3D,CAAC,EAAE,MAAM,CAAC;IAEV,sDAAsD;IACtD,gBAAgB,EAAE,MAAM,CAAC;IAEzB,oDAAoD;IACpD,eAAe,EAAE,MAAM,CAAC;IAExB,+CAA+C;IAC/C,YAAY,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,cAAc,CACnC,MAAM,EAAE,MAAM,IAAI,EAClB,MAAM,EAAE,MAAM,IAAI,EAClB,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAqBvB"}

package/dist/_dudect.js

@@ -0,0 +1,48 @@
+import { quantile, welchTStatistic } from "@ac-kit/math-stats";
+import { collectInterleavedTimings } from "./_collect.js";
+/** `|t|` above which dudect-style tools conventionally report a leak. */
+export const DEFAULT_LEAK_THRESHOLD = 4.5;
+/** Default seed for {@link CollectOptions.random}, reproducible across runs. */
+export const DEFAULT_SEED = 1592590337;
+/**
+ * A dudect-style constant-time check: times `classA` and `classB` under a
+ * randomly interleaved schedule (see {@link collectInterleavedTimings}) and
+ * reports whether their timing distributions are distinguishable.
+ *
+ * This only ever answers "is a timing difference detectable in this many
+ * samples", never "why" — a positive result still needs a human to find the
+ * secret-dependent branch or memory access it came from, and a negative result
+ * only means none was found at this sample count, not that none exists.
+ * Increase {@link CollectOptions.samples} to raise the harness's power to
+ * detect a smaller leak.
+ *
+ * The classic dudect design compares one **fixed** secret input, called
+ * repeatedly, against a **new random** secret input generated for every call of
+ * the other class — pass closures built that way, not two closures over the
+ * same fixed input or the test has no power to detect anything.
+ *
+ * @param classA First closure to time.
+ * @param classB Second closure to time.
+ * @param options Sampling, cropping and threshold policy.
+ * @returns The statistic and its leak verdict.
+ */
+export async function runDudectCheck(classA, classB, options) {
+    const cropQuantile = options?.cropQuantile ?? 0.995;
+    const leakThreshold = options?.leakThreshold ?? DEFAULT_LEAK_THRESHOLD;
+    const { classA: rawA, classB: rawB } = await collectInterleavedTimings(classA, classB, options);
+    const croppedA = cropUpperTail_(rawA, cropQuantile);
+    const croppedB = cropUpperTail_(rawB, cropQuantile);
+    const { t, degreesOfFreedom } = welchTStatistic(croppedA, croppedB);
+    return {
+        t,
+        degreesOfFreedom,
+        samplesPerClass: rawA.length,
+        leakDetected: Math.abs(t) > leakThreshold,
+    };
+}
+function cropUpperTail_(samples, q) {
+    const sorted = [...samples].sort((a, b) => a - b);
+    const limit = quantile(sorted, q);
+    return sorted.filter((value) => value <= limit);
+}
+//# sourceMappingURL=_dudect.js.map

package/dist/_dudect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dudect.js","sourceRoot":"","sources":["../src/_dudect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EAAkB,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE1E,yEAAyE;AACzE,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAE1C,gFAAgF;AAChF,MAAM,CAAC,MAAM,YAAY,GAAG,UAAW,CAAC;AAkCxC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CACnC,MAAkB,EAClB,MAAkB,EAClB,OAAsB;IAEtB,MAAM,YAAY,GAAG,OAAO,EAAE,YAAY,IAAI,KAAK,CAAC;IACpD,MAAM,aAAa,GAAG,OAAO,EAAE,aAAa,IAAI,sBAAsB,CAAC;IAEvE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,yBAAyB,CACrE,MAAM,EACN,MAAM,EACN,OAAO,CACP,CAAC;IAEF,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IACpD,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAEpD,MAAM,EAAE,CAAC,EAAE,gBAAgB,EAAE,GAAG,eAAe,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAEpE,OAAO;QACN,CAAC;QACD,gBAAgB;QAChB,eAAe,EAAE,IAAI,CAAC,MAAM;QAC5B,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,aAAa;KACzC,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,OAA0B,EAAE,CAAS;IAC5D,MAAM,MAAM,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAClD,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAElC,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC;AACjD,CAAC"}

package/dist/_run-case.d.ts

@@ -0,0 +1,17 @@
+import { BenchCaseRunContext } from "@ac-bench/core/runner";
+import { CallableNoArgs } from "@ac-kit/core";
+import { ConstantTimeCaseOptions, ConstantTimeConditionOptions } from "./options.js";
+export type ConstantTimeRunCaseOptions = ConstantTimeCaseOptions & {
+    conditionOptions?: ConstantTimeConditionOptions;
+};
+/**
+ * Run one constant-time check.
+ *
+ * @param title Case name, carried into the reported result.
+ * @param classA First closure to time.
+ * @param classB Second closure to time.
+ * @param context Run context, used to report the result and check for abort.
+ * @param options Sampling, cropping and threshold policy.
+ */
+export declare function runConstantTimeCase(title: string, classA: CallableNoArgs, classB: CallableNoArgs, context: BenchCaseRunContext, options?: ConstantTimeRunCaseOptions): Promise<void>;
+//# sourceMappingURL=_run-case.d.ts.map

package/dist/_run-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_run-case.d.ts","sourceRoot":"","sources":["../src/_run-case.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAe,MAAM,cAAc,CAAC;AAU3D,OAAO,EACN,uBAAuB,EACvB,4BAA4B,EAC5B,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,GAAG;IAClE,gBAAgB,CAAC,EAAE,4BAA4B,CAAC;CAChD,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACxC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,0BAA0B,GAClC,OAAO,CAAC,IAAI,CAAC,CA4Df"}

package/dist/_run-case.js

@@ -0,0 +1,62 @@
+import { hrtime } from "node:process";
+import { formatError } from "@ac-kit/core";
+import { mulberry32 } from "@ac-kit/math-random";
+import { DEFAULT_LEAK_THRESHOLD, DEFAULT_SEED, runDudectCheck, } from "./_dudect.js";
+import { detectConstantTimeWarnings_ } from "./_warnings.js";
+/**
+ * Run one constant-time check.
+ *
+ * @param title Case name, carried into the reported result.
+ * @param classA First closure to time.
+ * @param classB Second closure to time.
+ * @param context Run context, used to report the result and check for abort.
+ * @param options Sampling, cropping and threshold policy.
+ */
+export async function runConstantTimeCase(title, classA, classB, context, options) {
+    context.signal.throwIfAborted();
+    const tags = options?.tags ?? {};
+    const leakThreshold = options?.conditionOptions?.dudect?.leakThreshold ?? DEFAULT_LEAK_THRESHOLD;
+    const beforeMeasure = options?.beforeEach
+        ? () => options.beforeEach?.(context.signal)
+        : undefined;
+    const afterMeasure = options?.afterEach
+        ? () => options.afterEach?.(context.signal)
+        : undefined;
+    try {
+        await options?.setup?.(context.signal);
+        const dudectResult = await runDudectCheck(classA, classB, {
+            ...options?.conditionOptions?.dudect,
+            random: options?.conditionOptions?.dudect?.random ?? mulberry32(DEFAULT_SEED),
+            now: hrtime.bigint,
+            signal: context.signal,
+            beforeMeasure,
+            afterMeasure,
+        });
+        await options?.teardown?.(context.signal);
+        context.setCaseResult({
+            title,
+            tags,
+            dudectResult,
+            warnings: detectConstantTimeWarnings_(dudectResult, leakThreshold),
+            failureMessage: null,
+        });
+    }
+    catch (error) {
+        let failureMessage;
+        try {
+            await options?.teardown?.(context.signal);
+            failureMessage = formatError(error);
+        }
+        catch (tearDownError) {
+            failureMessage = formatError(new SuppressedError(tearDownError, error, "teardown failed after case failure"));
+        }
+        context.setCaseResult({
+            title,
+            tags,
+            dudectResult: null,
+            warnings: [],
+            failureMessage,
+        });
+    }
+}
+//# sourceMappingURL=_run-case.js.map

package/dist/_run-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_run-case.js","sourceRoot":"","sources":["../src/_run-case.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAkB,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EACN,sBAAsB,EACtB,YAAY,EACZ,cAAc,GACd,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAU7D;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACxC,KAAa,EACb,MAAsB,EACtB,MAAsB,EACtB,OAA4B,EAC5B,OAAoC;IAEpC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;IAEhC,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC;IACjC,MAAM,aAAa,GAClB,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,IAAI,sBAAsB,CAAC;IAE5E,MAAM,aAAa,GAAG,OAAO,EAAE,UAAU;QACxC,CAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;QAC5C,CAAC,CAAC,SAAS,CAAC;IACb,MAAM,YAAY,GAAG,OAAO,EAAE,SAAS;QACtC,CAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;QAC3C,CAAC,CAAC,SAAS,CAAC;IAEb,IAAI,CAAC;QACJ,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAEvC,MAAM,YAAY,GAAG,MAAM,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE;YACzD,GAAG,OAAO,EAAE,gBAAgB,EAAE,MAAM;YACpC,MAAM,EACL,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,IAAI,UAAU,CAAC,YAAY,CAAC;YACtE,GAAG,EAAE,MAAM,CAAC,MAAM;YAClB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,aAAa;YACb,YAAY;SACZ,CAAC,CAAC;QAEH,MAAM,OAAO,EAAE,QAAQ,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAE1C,OAAO,CAAC,aAAa,CAAC;YACrB,KAAK;YACL,IAAI;YACJ,YAAY;YACZ,QAAQ,EAAE,2BAA2B,CAAC,YAAY,EAAE,aAAa,CAAC;YAClE,cAAc,EAAE,IAAI;SACa,CAAC,CAAC;IACrC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,IAAI,cAAsB,CAAC;QAC3B,IAAI,CAAC;YACJ,MAAM,OAAO,EAAE,QAAQ,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAE1C,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,aAAa,EAAE,CAAC;YACxB,cAAc,GAAG,WAAW,CAC3B,IAAI,eAAe,CAClB,aAAa,EACb,KAAK,EACL,oCAAoC,CACpC,CACD,CAAC;QACH,CAAC;QAED,OAAO,CAAC,aAAa,CAAC;YACrB,KAAK;YACL,IAAI;YACJ,YAAY,EAAE,IAAI;YAClB,QAAQ,EAAE,EAAE;YACZ,cAAc;SACmB,CAAC,CAAC;IACrC,CAAC;AACF,CAAC"}

package/dist/_statistics.d.ts

@@ -0,0 +1,8 @@
+import { DudectResult } from "./_dudect.js";
+/**
+ * Constant-time check statistics — an alias for {@link DudectResult}, named to
+ * match its sibling measures' `_statistics.ts` modules (duration, jitter),
+ * which the plugin contract (§4.6) expects one of per measure.
+ */
+export type ConstantTimeStatistics = DudectResult;
+//# sourceMappingURL=_statistics.d.ts.map

package/dist/_statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_statistics.d.ts","sourceRoot":"","sources":["../src/_statistics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAC"}

package/dist/_statistics.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=_statistics.js.map

package/dist/_statistics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_statistics.js","sourceRoot":"","sources":["../src/_statistics.ts"],"names":[],"mappings":""}

package/dist/_types.d.ts

@@ -0,0 +1,43 @@
+import * as z from "zod/mini";
+export declare const constantTimeCaseResultSchema: z.ZodMiniObject<{
+    title: z.ZodMiniString<string>;
+    dudectResult: z.ZodMiniNullable<z.ZodMiniObject<{
+        t: z.ZodMiniNumber<number>;
+        degreesOfFreedom: z.ZodMiniNumber<number>;
+        samplesPerClass: z.ZodMiniNumber<number>;
+        leakDetected: z.ZodMiniBoolean<boolean>;
+    }, z.core.$strip>>;
+    tags: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+    warnings: z.ZodMiniArray<z.ZodMiniObject<{
+        kind: z.ZodMiniEnum<{
+            "leak-detected": "leak-detected";
+            "too-few-samples": "too-few-samples";
+        }>;
+        message: z.ZodMiniString<string>;
+    }, z.core.$strip>>;
+    failureMessage: z.ZodMiniNullable<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type ConstantTimeCaseResult = z.infer<typeof constantTimeCaseResultSchema>;
+export declare const constantTimeConditionResultSchema: z.ZodMiniObject<{
+    title: z.ZodMiniString<string>;
+    results: z.ZodMiniArray<z.ZodMiniObject<{
+        title: z.ZodMiniString<string>;
+        dudectResult: z.ZodMiniNullable<z.ZodMiniObject<{
+            t: z.ZodMiniNumber<number>;
+            degreesOfFreedom: z.ZodMiniNumber<number>;
+            samplesPerClass: z.ZodMiniNumber<number>;
+            leakDetected: z.ZodMiniBoolean<boolean>;
+        }, z.core.$strip>>;
+        tags: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+        warnings: z.ZodMiniArray<z.ZodMiniObject<{
+            kind: z.ZodMiniEnum<{
+                "leak-detected": "leak-detected";
+                "too-few-samples": "too-few-samples";
+            }>;
+            message: z.ZodMiniString<string>;
+        }, z.core.$strip>>;
+        failureMessage: z.ZodMiniNullable<z.ZodMiniString<string>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ConstantTimeConditionResult = z.infer<typeof constantTimeConditionResultSchema>;
+//# sourceMappingURL=_types.d.ts.map

package/dist/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../src/_types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAW9B,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,4BAA4B,CACnC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;iBAG5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,iCAAiC,CACxC,CAAC"}

package/dist/_types.js

@@ -0,0 +1,20 @@
+import * as z from "zod/mini";
+import { constantTimeWarningSchema } from "./_warnings.js";
+const dudectResultSchema = z.object({
+    t: z.number(),
+    degreesOfFreedom: z.number(),
+    samplesPerClass: z.number(),
+    leakDetected: z.boolean(),
+});
+export const constantTimeCaseResultSchema = z.object({
+    title: z.string(),
+    dudectResult: z.nullable(dudectResultSchema),
+    tags: z.record(z.string(), z.string()),
+    warnings: z.array(constantTimeWarningSchema),
+    failureMessage: z.nullable(z.string()),
+});
+export const constantTimeConditionResultSchema = z.object({
+    title: z.string(),
+    results: z.array(constantTimeCaseResultSchema),
+});
+//# sourceMappingURL=_types.js.map

package/dist/_types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.js","sourceRoot":"","sources":["../src/_types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE;IACb,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;IAC5B,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE;IAC3B,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE;CACzB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACpD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,YAAY,EAAE,CAAC,CAAC,QAAQ,CAAC,kBAAkB,CAAC;IAC5C,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IACtC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,yBAAyB,CAAC;IAC5C,cAAc,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CACtC,CAAC,CAAC;AAKH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,CAAC,MAAM,CAAC;IACzD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC;CAC9C,CAAC,CAAC"}

package/dist/_warnings.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod/mini";
+import { ConstantTimeStatistics } from "./_statistics.js";
+/** Categories of quality problem detected in a constant-time result. */
+export declare const constantTimeWarningKindSchema: z.ZodMiniEnum<{
+    "leak-detected": "leak-detected";
+    "too-few-samples": "too-few-samples";
+}>;
+export type ConstantTimeWarningKind = z.infer<typeof constantTimeWarningKindSchema>;
+/** A quality problem that should be shown alongside the numbers. */
+export declare const constantTimeWarningSchema: z.ZodMiniObject<{
+    kind: z.ZodMiniEnum<{
+        "leak-detected": "leak-detected";
+        "too-few-samples": "too-few-samples";
+    }>;
+    message: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type ConstantTimeWarning = z.infer<typeof constantTimeWarningSchema>;
+/**
+ * Surfaces conditions that make a constant-time verdict untrustworthy, or
+ * restates a positive verdict as a warning worth calling out alongside the
+ * numbers.
+ */
+export declare function detectConstantTimeWarnings_(statistics: ConstantTimeStatistics, leakThreshold: number): ConstantTimeWarning[];
+//# sourceMappingURL=_warnings.d.ts.map

package/dist/_warnings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_warnings.d.ts","sourceRoot":"","sources":["../src/_warnings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAK1D,wEAAwE;AACxE,eAAO,MAAM,6BAA6B;;;EAGxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,6BAA6B,CACpC,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,yBAAyB;;;;;;iBAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,2BAA2B,CAC1C,UAAU,EAAE,sBAAsB,EAClC,aAAa,EAAE,MAAM,GACnB,mBAAmB,EAAE,CAkBvB"}

package/dist/_warnings.js

@@ -0,0 +1,35 @@
+import * as z from "zod/mini";
+/** Below this, cropping has too few samples per class to be meaningful. */
+const MIN_SAMPLES_PER_CLASS = 1000;
+/** Categories of quality problem detected in a constant-time result. */
+export const constantTimeWarningKindSchema = z.enum([
+    "leak-detected",
+    "too-few-samples",
+]);
+/** A quality problem that should be shown alongside the numbers. */
+export const constantTimeWarningSchema = z.object({
+    kind: constantTimeWarningKindSchema,
+    message: z.string(),
+});
+/**
+ * Surfaces conditions that make a constant-time verdict untrustworthy, or
+ * restates a positive verdict as a warning worth calling out alongside the
+ * numbers.
+ */
+export function detectConstantTimeWarnings_(statistics, leakThreshold) {
+    const warnings = [];
+    if (statistics.samplesPerClass < MIN_SAMPLES_PER_CLASS) {
+        warnings.push({
+            kind: "too-few-samples",
+            message: `only ${statistics.samplesPerClass} samples per class collected; increase samples to raise the harness's power to detect a smaller leak`,
+        });
+    }
+    if (statistics.leakDetected) {
+        warnings.push({
+            kind: "leak-detected",
+            message: `timing difference detected (|t|=${Math.abs(statistics.t).toFixed(2)} > ${leakThreshold}); the two classes are statistically distinguishable`,
+        });
+    }
+    return warnings;
+}
+//# sourceMappingURL=_warnings.js.map

package/dist/_warnings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_warnings.js","sourceRoot":"","sources":["../src/_warnings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAI9B,2EAA2E;AAC3E,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAEnC,wEAAwE;AACxE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,IAAI,CAAC;IACnD,eAAe;IACf,iBAAiB;CACjB,CAAC,CAAC;AAKH,oEAAoE;AACpE,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,IAAI,EAAE,6BAA6B;IACnC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;CACnB,CAAC,CAAC;AAGH;;;;GAIG;AACH,MAAM,UAAU,2BAA2B,CAC1C,UAAkC,EAClC,aAAqB;IAErB,MAAM,QAAQ,GAA0B,EAAE,CAAC;IAE3C,IAAI,UAAU,CAAC,eAAe,GAAG,qBAAqB,EAAE,CAAC;QACxD,QAAQ,CAAC,IAAI,CAAC;YACb,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,QAAQ,UAAU,CAAC,eAAe,sGAAsG;SACjJ,CAAC,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;QAC7B,QAAQ,CAAC,IAAI,CAAC;YACb,IAAI,EAAE,eAAe;YACrB,OAAO,EAAE,mCAAmC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,aAAa,sDAAsD;SACtJ,CAAC,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC;AACjB,CAAC"}

package/dist/decl.d.ts

@@ -0,0 +1,7 @@
+import { CallableNoArgs, MaybeAsyncCallableNoArgs } from "@ac-kit/core";
+import { ConstantTimeCaseOptions, ConstantTimeConditionOptions } from "./options.js";
+export declare function constantTimeCondition(title: string, fn: MaybeAsyncCallableNoArgs): void;
+export declare function constantTimeCondition(title: string, options: ConstantTimeConditionOptions, fn: MaybeAsyncCallableNoArgs): void;
+export declare function constantTimeCase(name: string, classA: CallableNoArgs, classB: CallableNoArgs): void;
+export declare function constantTimeCase(name: string, options: ConstantTimeCaseOptions, classA: CallableNoArgs, classB: CallableNoArgs): void;
+//# sourceMappingURL=decl.d.ts.map

package/dist/decl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decl.d.ts","sourceRoot":"","sources":["../src/decl.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAGxE,OAAO,EACN,uBAAuB,EACvB,4BAA4B,EAC5B,MAAM,cAAc,CAAC;AAItB,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,wBAAwB,GAC1B,IAAI,CAAC;AACR,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,4BAA4B,EACrC,EAAE,EAAE,wBAAwB,GAC1B,IAAI,CAAC;AAgBR,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACpB,IAAI,CAAC;AACR,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,uBAAuB,EAChC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACpB,IAAI,CAAC"}

package/dist/decl.js

@@ -0,0 +1,22 @@
+import { registerCondition, registerCase } from "@ac-bench/core/runner";
+import { runConstantTimeCase } from "./_run-case.js";
+const MEASURE_TYPE_ = "constant-time";
+export function constantTimeCondition(title, optionsOrFn, fn) {
+    const [options, callback] = typeof optionsOrFn === "function"
+        ? [undefined, optionsOrFn]
+        : [optionsOrFn, fn];
+    registerCondition(MEASURE_TYPE_, title, callback, {
+        additionalRunArgs: [options],
+    });
+}
+export function constantTimeCase(name, optionsOrClassA, classAOrClassB, maybeClassB) {
+    const isOptionsForm = typeof optionsOrClassA !== "function";
+    const options = isOptionsForm ? optionsOrClassA : undefined;
+    const classA = isOptionsForm ? classAOrClassB : optionsOrClassA;
+    const classB = isOptionsForm ? maybeClassB : classAOrClassB;
+    registerCase(MEASURE_TYPE_, name, (context, conditionOptions) => runConstantTimeCase(name, classA, classB, context, {
+        ...options,
+        conditionOptions,
+    }));
+}
+//# sourceMappingURL=decl.js.map

package/dist/decl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decl.js","sourceRoot":"","sources":["../src/decl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAMrD,MAAM,aAAa,GAAG,eAAe,CAAC;AAWtC,MAAM,UAAU,qBAAqB,CACpC,KAAa,EACb,WAAoE,EACpE,EAA6B;IAE7B,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,GACxB,OAAO,WAAW,KAAK,UAAU;QAChC,CAAC,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC;QAC1B,CAAC,CAAC,CAAC,WAAW,EAAE,EAAG,CAAC,CAAC;IAEvB,iBAAiB,CAAC,aAAa,EAAE,KAAK,EAAE,QAAQ,EAAE;QACjD,iBAAiB,EAAE,CAAC,OAAO,CAAC;KAC5B,CAAC,CAAC;AACJ,CAAC;AAaD,MAAM,UAAU,gBAAgB,CAC/B,IAAY,EACZ,eAAyD,EACzD,cAA0C,EAC1C,WAA4B;IAE5B,MAAM,aAAa,GAAG,OAAO,eAAe,KAAK,UAAU,CAAC;IAC5D,MAAM,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5D,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,cAAe,CAAC,CAAC,CAAC,eAAe,CAAC;IACjE,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,WAAY,CAAC,CAAC,CAAC,cAAe,CAAC;IAE9D,YAAY,CACX,aAAa,EACb,IAAI,EACJ,CAAC,OAAO,EAAE,gBAAgB,EAAE,EAAE,CAC7B,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;QAClD,GAAG,OAAO;QACV,gBAAgB;KAChB,CAAC,CACH,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { afterAll, afterEach, beforeAll, beforeEach, } from "@ac-bench/core/runner";
+export * from "./decl.js";
+export * from "./options.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,GACV,MAAM,uBAAuB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { afterAll, afterEach, beforeAll, beforeEach, } from "@ac-bench/core/runner";
+export * from "./decl.js";
+export * from "./options.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,GACV,MAAM,uBAAuB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dist/options.d.ts

@@ -0,0 +1,14 @@
+import { CaseCommonOptions } from "@ac-bench/core/runner";
+import { RandomFn } from "@ac-kit/core";
+import { DudectOptions } from "./_dudect.js";
+export type ConstantTimeConditionOptions = {
+    dudect?: Omit<DudectOptions, "beforeMeasure" | "afterMeasure" | "signal" | "now" | "random"> & {
+        /**
+         * Source of randomness for the execution-order shuffle. Defaults to a fixed
+         * seed.
+         */
+        random?: RandomFn;
+    };
+};
+export type ConstantTimeCaseOptions = CaseCommonOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,MAAM,4BAA4B,GAAG;IAC1C,MAAM,CAAC,EAAE,IAAI,CACZ,aAAa,EACb,eAAe,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAC9D,GAAG;QACH;;;WAGG;QACH,MAAM,CAAC,EAAE,QAAQ,CAAC;KAClB,CAAC;CACF,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CAAC"}

package/dist/options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":""}

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@ac-bench/core/plugin").MeasurePlugin;
+export default _default;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":""}

package/dist/plugin.js

@@ -0,0 +1,105 @@
+import { defineMeasurePlugin, MeasureResultValidationError, } from "@ac-bench/core/plugin";
+import { DIMENSIONLESS } from "@ac-kit/model-dataset";
+import * as z from "zod/mini";
+import { constantTimeCaseResultSchema, constantTimeConditionResultSchema, } from "./_types.js";
+const MEASURE_ID = "constant-time";
+function parseCaseResult_(value) {
+    const result = constantTimeCaseResultSchema.safeParse(value);
+    if (!result.success) {
+        throw new MeasureResultValidationError(MEASURE_ID, z.prettifyError(result.error));
+    }
+    return result.data;
+}
+function parseConditionResult_(value) {
+    const result = constantTimeConditionResultSchema.safeParse(value);
+    if (!result.success) {
+        throw new MeasureResultValidationError(MEASURE_ID, z.prettifyError(result.error));
+    }
+    return result.data;
+}
+const FIELDS = [
+    { name: "case", kind: "nominal", title: "case" },
+    {
+        name: "t",
+        kind: "quantitative",
+        title: "t",
+        // Thresholded, not minimised: no direction is the honest answer here.
+        unit: DIMENSIONLESS,
+        format: { minimumFractionDigits: 3, maximumFractionDigits: 3 },
+    },
+    {
+        name: "degreesOfFreedom",
+        kind: "quantitative",
+        title: "df",
+        format: { minimumFractionDigits: 1, maximumFractionDigits: 1 },
+    },
+    {
+        name: "samplesPerClass",
+        kind: "quantitative",
+        title: "n/class",
+        format: { maximumFractionDigits: 0 },
+    },
+    { name: "verdict", kind: "nominal", title: "verdict" },
+];
+function caseRow_(result) {
+    const stats = result.dudectResult;
+    if (!stats) {
+        return [
+            result.title,
+            null,
+            null,
+            null,
+            `SKIPPED: ${result.failureMessage ?? "unknown"}`,
+        ];
+    }
+    return [
+        result.title,
+        stats.t,
+        stats.degreesOfFreedom,
+        stats.samplesPerClass,
+        stats.leakDetected ? "⚠ leak detected" : "ok",
+    ];
+}
+export default defineMeasurePlugin({
+    id: "constant-time",
+    label: "Constant-time",
+    parseCaseResult: parseCaseResult_,
+    parseConditionResult: parseConditionResult_,
+    fields: FIELDS,
+    caseRow: caseRow_,
+    // No `comparison`: a t-statistic is thresholded against a critical value,
+    // not ordered against the other cases, so there is nothing to escalate on.
+    warnings: (result) => {
+        const diagnostics = [];
+        if (result.failureMessage) {
+            diagnostics.push({
+                severity: "error",
+                code: "case-failed",
+                message: result.failureMessage,
+            });
+        }
+        for (const warning of result.warnings) {
+            diagnostics.push({
+                severity: "warning",
+                code: warning.kind,
+                message: warning.message,
+            });
+        }
+        return diagnostics;
+    },
+    // dudect interleaves its own two classes inside one case; a second
+    // interleaving layer above it (round-robin across cases) adds drift it
+    // cannot cancel.
+    scheduling: { rounds: "one", grouping: "condition" },
+    // A leak verdict is not an average: one process finding a leak is a leak,
+    // whatever the others saw. The most significant result stands for the case.
+    pool: (executions) => executions.reduce((worst, execution) => Math.abs(execution.result.dudectResult?.t ?? 0) >
+        Math.abs(worst.result.dudectResult?.t ?? 0)
+        ? execution
+        : worst).result,
+    toJsonCase: (result) => result,
+    toJsonCondition: (result) => ({
+        constantTimeConditions: [result],
+    }),
+});
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

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

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@ac-bench/measure-constant-time",
+  "version": "0.1.0",
+  "description": "dudect-style constant-time measure for @ac-bench: times two closures under a randomly interleaved schedule and reports Welch's t-statistic.",
+  "keywords": [
+    "benchmark",
+    "constant-time",
+    "dudect",
+    "side-channel",
+    "timing"
+  ],
+  "homepage": "https://github.com/anthochamp/node-essentials/tree/main/bench/measure-constant-time#readme",
+  "bugs": {
+    "url": "https://github.com/anthochamp/node-essentials/issues"
+  },
+  "license": "BSD-3-Clause",
+  "author": "Anthony Champagne <dev@anthonychampagne.fr>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anthochamp/node-essentials.git",
+    "directory": "bench/measure-constant-time"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./plugin": "./dist/plugin.js"
+  },
+  "publishConfig": {
+    "main": "./dist/index.js",
+    "exports": {
+      ".": "./dist/index.js",
+      "./plugin": "./dist/plugin.js"
+    },
+    "access": "public"
+  },
+  "scripts": {
+    "compile": "tsc -p ./tsconfig.build.json --outDir dist",
+    "compile:check": "tsc -noEmit -p ./tsconfig.json",
+    "clean": "rimraf dist",
+    "build": "yarn clean && yarn compile",
+    "test": "yarn run -T vitest run",
+    "prepack": "yarn build"
+  },
+  "dependencies": {
+    "@ac-bench/core": "^0.1.0",
+    "@ac-kit/algo": "^0.1.0",
+    "@ac-kit/app-report": "^0.1.0",
+    "@ac-kit/core": "^0.1.0",
+    "@ac-kit/math-random": "^0.1.0",
+    "@ac-kit/math-stats": "^0.1.0",
+    "@ac-kit/model-dataset": "^0.1.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@ac-kit/tsconfig": "0.1.0",
+    "@ac-kit/typedoc-config": "0.1.0",
+    "@ac-kit/vitest-config": "0.1.0",
+    "@types/node": "26.5.1",
+    "@typescript/native": "typescript@7.0.2",
+    "rimraf": "6.1.3",
+    "typedoc": "0.28.20",
+    "typescript": "@typescript/typescript6@6.0.2",
+    "vite": "8.3.0",
+    "vitest": "5.0.0"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}