@interfere/react 12.0.5 → 12.1.0

package/dist/tracking/registration.fixture.d.mts

@@ -1,12 +1,13 @@
-import { t as SessionTracker } from "../api-DEVCOKkJ.mjs";
-//#region ../../../../node_modules/.bun/vitest@5.0.1+3a20bcfa24daf8e9/node_modules/vitest/optional-runtime-types.d.ts
-/* eslint-disable ts/ban-ts-comment */
+import { t as SessionTracker } from "../api-CMPV9rgU.mjs";
+import { InterfereClient } from "@interfere/javascript";
+//#region ../../../../node_modules/.bun/vitest@5.0.5+68042dbef16394d8/node_modules/vitest/optional-runtime-types.d.ts
+/* oxlint-disable typescript/ban-ts-comment */
 interface Disposable {
   // @ts-ignore -- Symbol.dispose might not be in user types
   [Symbol.dispose]: () => void;
 }
 //#endregion
-//#region ../../../../node_modules/.bun/tinybench@6.1.4/node_modules/tinybench/dist/index.d.ts
+//#region ../../../../node_modules/.bun/tinybench@6.2.2/node_modules/tinybench/dist/index.d.ts
 //#region src/task.d.ts
 /**
  * A class that represents each benchmark task in Tinybench. It keeps track of the
@@ -17,15 +18,13 @@ declare class Task$1 extends EventTarget {
   addEventListener: (<K extends TaskEvents>(type: K, listener: EventListener<K, 'task'> | EventListenerObject<K, 'task'> | null, options?: AddEventListenerOptionsArgument) => void) & EventTarget['addEventListener'];
   removeEventListener: (<K extends TaskEvents>(type: K, listener: EventListener<K, 'task'> | EventListenerObject<K, 'task'> | null, options?: RemoveEventListenerOptionsArgument) => void) & EventTarget['removeEventListener'];
   /**
-   * The estimated effective timer resolution observed during the last run,
-   * computed as the smallest strictly positive latency sample that repeats
-   * among the timer-measured samples, or the smallest strictly positive
-   * sample when none repeats (samples supplied via `overriddenDuration` are
-   * excluded). When `subtractTimerOverhead` is enabled the value is derived
-   * from the overhead-corrected samples rather than the raw timer grain.
-   * @returns The resolution in milliseconds, or `undefined` when no
-   *   timer-measured strictly positive sample was observed (e.g. every
-   *   sample was supplied via `overriddenDuration`)
+   * Sample-based timer-resolution heuristic for the last run. Returns the
+   * smallest positive latency repeated at least twice, otherwise the minimum
+   * positive latency. Uses timer-measured samples after overhead correction;
+   * samples supplied via `overriddenDuration` are excluded. This does not
+   * guarantee a bound on the timer's resolution.
+   * @returns The estimate in milliseconds, or `undefined` when no eligible
+   *   sample remains positive after correction.
    */
   get detectedResolution(): number | undefined;
   /**
@@ -39,13 +38,17 @@ declare class Task$1 extends EventTarget {
    */
   get result(): TaskResult$1 & TaskResultRuntimeInfo & TaskResultTimestampProviderInfo;
   /**
-   * The number of times the task function has been executed.
-   * @returns The total number of executions performed
+   * The recorded sample count from run statistics or task-concurrent execution.
+   * Task-concurrent warmup also updates this counter; other warmup and
+   * async-detection calls do not.
+   * @returns The recorded sample count.
    */
   get runs(): number;
   constructor(bench: BenchLike, name: string, fn: Fn, fnOpts?: FnOptions);
   /**
-   * Resets the task to make the `Task.runs` a zero-value and remove the `Task.result` object property.
+   * Clears the run count, statistics and diagnostics. The result becomes
+   * `not-started`, or stays `aborted` if a signal has aborted. Does not rearm
+   * an aborted signal.
    * @param emit - whether to emit the `reset` event or not
    */
   reset(emit?: boolean): void;
@@ -70,11 +73,12 @@ declare class Task$1 extends EventTarget {
 }
 //#endregion
 //#region src/event.d.ts
+declare const EventBase: new (type: string) => Omit<Event, 'type'>;
 /**
  * The BenchEvent class represents events that occur during the benchmarking
  * process.
  */
-declare class BenchEvent<K extends BenchEvents = BenchEvents, M extends 'bench' | 'task' = 'bench'> extends globalThis.Event {
+declare class BenchEvent<K extends BenchEvents = BenchEvents, M extends 'bench' | 'task' = 'bench'> extends EventBase {
   #private;
   type: K;
   /**
@@ -91,9 +95,11 @@ declare class BenchEvent<K extends BenchEvents = BenchEvents, M extends 'bench'
   get reason(): K extends 'warning' ? TimerSaturationReason | undefined : undefined;
   /**
    * The task associated with the event.
-   * @returns The task if the event type is one that includes a task; otherwise, undefined
+   * @returns The task for task-scoped events and bench events that require one;
+   *   for bench `abort`, the relayed task or `undefined` for a global abort.
+   *   Other bench events return `undefined`.
    */
-  get task(): M extends 'task' ? Task$1 : K extends BenchEventsWithTask ? Task$1 : undefined;
+  get task(): M extends 'task' ? Task$1 : K extends BenchEventsWithTask ? Task$1 : K extends 'abort' ? Task$1 | undefined : undefined;
   constructor(type: 'warning', task: Task$1, reason?: TimerSaturationReason);
   constructor(type: BenchEventsWithError, task: Task$1, error: Error);
   constructor(type: BenchEventsWithTask, task: Task$1);
@@ -138,7 +144,7 @@ interface BenchLike extends EventTarget {
    */
   concurrency: Concurrency;
   /**
-   * The amount of executions per task.
+   * The iteration limit per task; see {@link BenchOptions.iterations}.
    */
   iterations: number;
   /**
@@ -162,7 +168,7 @@ interface BenchLike extends EventTarget {
    */
   runtimeVersion: string;
   /**
-   * A setup function that runs before each task execution.
+   * A setup function called once per task and phase.
    */
   setup: (task: Task$1, mode: HookMode) => Promise<void> | void;
   /**
@@ -170,11 +176,11 @@ interface BenchLike extends EventTarget {
    */
   signal?: AbortSignal;
   /**
-   * A teardown function that runs after each task execution.
+   * A teardown function called once per task and phase.
    */
   teardown: (task: Task$1, mode: HookMode) => Promise<void> | void;
   /**
-   * The maximum number of concurrent tasks to run
+   * The maximum concurrent iterations within a task; only for `concurrency: 'task'`.
    */
   threshold: number;
   /**
@@ -182,7 +188,7 @@ interface BenchLike extends EventTarget {
    */
   throws: boolean;
   /**
-   * The amount of time to run each task.
+   * The time budget per task in milliseconds; see {@link BenchOptions.time}.
    */
   time: number;
   /**
@@ -201,11 +207,11 @@ interface BenchLike extends EventTarget {
    */
   warmup: boolean;
   /**
-   * The amount of warmup iterations per task.
+   * The warmup iteration limit per task; see {@link BenchOptions.warmupIterations}.
    */
   warmupIterations: number;
   /**
-   * The amount of time to warmup each task.
+   * The warmup time budget in milliseconds; see {@link BenchOptions.warmupTime}.
    */
   warmupTime: number;
 }
@@ -222,7 +228,11 @@ interface BenchOptions$1 {
    */
   concurrency?: Concurrency;
   /**
-   * The number of times that a task should run if even the time option is finished.
+   * Minimum iterations per task in sequential modes (`null` and `'bench'`).
+   * With `concurrency: 'task'`, a positive value instead caps scheduled
+   * iterations; scheduling stops when either positive iteration or time limit
+   * is reached. Zero disables this limit in that mode and requires a finite
+   * `threshold` (for example, `threshold: 10`), not the default `Infinity`.
    * @default 64
    */
   iterations?: number;
@@ -258,25 +268,16 @@ interface BenchOptions$1 {
    * {@link calibrateTimerOverhead}, and `max(0, raw_sample - Ĉ)` is used
    * in place of each non-overridden sample before statistics are computed.
    *
-   * **Statistics after correction.** All fields of {@link Statistics} are
-   * derived from the clamped corrected samples, not from the raw
-   * distribution. With `M` denoting the raw-sample mean:
-   *
-   * - **Clean-shift regime (`X >> Ĉ`).** The clamp `max(0, …)` rarely
-   *   triggers, so the correction acts as a translation by `Ĉ`. Location
-   *   statistics (`mean`, `min`, `max`, all percentiles) decrease by `Ĉ`;
-   *   absolute-unit dispersion (`vr`, `sd`, `sem`, `moe`, `mad`, `aad`)
-   *   is essentially unchanged. Because `rme = moe / mean`, it inflates
-   *   by the deterministic factor `M / (M − Ĉ)` whenever `Ĉ > 0`.
-   * - **Sub-overhead regime (`X ≈ Ĉ`).** A non-trivial fraction of
-   *   samples clamp to `0`, biasing the corrected mean upward,
-   *   contracting `vr`/`sd`/`sem`/`moe`/`aad`, and compounding the
-   *   `M / (M − Ĉ)` factor in `rme`. Once the cumulative mass of raw
-   *   samples at or below `Ĉ` reaches a given quantile, that percentile
-   *   collapses to `0`; in particular `p50` collapses once at least half
-   *   of the raw samples satisfy `raw_sample ≤ Ĉ`, which then forces
-   *   `mad` and `aad` toward `0`. Prefer `overriddenDuration` for
-   *   sub-overhead measurements.
+   * **Statistics after correction.** Statistics use the final samples, after
+   * correction and any duration overrides. When all latency samples are
+   * timer-measured and exceed `Ĉ`, subtracting the constant shifts location
+   * statistics by `Ĉ` while leaving variance and absolute dispersion unchanged
+   * apart from rounding. Relative error can increase as the mean decreases.
+   *
+   * When samples clamp to zero, these translation rules no longer hold.
+   * Quantiles are interpolated: exactly half zero samples need not give a
+   * zero median, and a zero median does not imply zero mean absolute deviation.
+   * Prefer `overriddenDuration` for sub-overhead measurements.
    *
    * **Three observable consequences of the clamp.**
    *
@@ -300,8 +301,8 @@ interface BenchOptions$1 {
    * are never modified by the correction. They are also excluded from
    * {@link Task.detectedResolution} and from timer-saturation detection.
    *
-   * On runtimes with a coarse timer (resolution >= 1 ms), the
-   * calibration returns `0` and this option becomes a no-op.
+   * If fewer than half of the calibration pairs have positive deltas, the
+   * estimate is `0` and the correction is a no-op.
    * @default false
    */
   subtractTimerOverhead?: boolean;
@@ -310,7 +311,10 @@ interface BenchOptions$1 {
    */
   teardown?: Hook;
   /**
-   * The maximum number of concurrent tasks to run
+   * Maximum concurrent iterations within a task. Only applies with
+   * `concurrency: 'task'`; does not limit concurrent benchmark tasks.
+   * A finite value is required for a task-concurrent cycle with a zero
+   * iteration limit (`iterations` for run or `warmupIterations` for warmup).
    * @default Number.POSITIVE_INFINITY
    */
   threshold?: number;
@@ -320,7 +324,10 @@ interface BenchOptions$1 {
    */
   throws?: boolean;
   /**
-   * Time needed for running a benchmark task in milliseconds.
+   * Time budget per task in milliseconds. Sequential modes keep running
+   * until both this budget and the minimum iteration count are met. With
+   * `concurrency: 'task'`, a positive finite value instead limits scheduling
+   * by elapsed time; reaching either positive limit stops new iterations.
    * @default 1000
    */
   time?: number;
@@ -335,12 +342,16 @@ interface BenchOptions$1 {
    */
   warmup?: boolean;
   /**
-   * Warmup iterations.
+   * Warmup iteration limit. {@link Task.warmup} uses the mode-dependent
+   * semantics of {@link iterations}; {@link Task.warmupSync} always treats
+   * this as a minimum.
    * @default 16
    */
   warmupIterations?: number;
   /**
-   * Warmup time in milliseconds.
+   * Warmup time budget in milliseconds. {@link Task.warmup} uses the
+   * mode-dependent semantics of {@link time}; {@link Task.warmupSync}
+   * always uses the sequential budget.
    * @default 250
    */
   warmupTime?: number;
@@ -372,12 +383,19 @@ interface EventListenerObject<E extends BenchEvents, M extends 'bench' | 'task'
  * If you need to provide a custom duration for the task (e.g.: because
  * you want to measure a specific part of its execution), you can return an
  * object with a `overriddenDuration` field. You should still use
- * `bench.opts.now()` to measure that duration.
+ * `bench.now()` to measure that duration. When the task function batches
+ * several inner calls, also return `overriddenIterationCost` so the `time`
+ * budget reflects the whole iteration while samples record batch means.
+ *
+ * Task results are unrestricted. See {@link FnReturnedObject} for explicit
+ * compile-time checks of measurement fields.
  */
-type Fn = () => FnReturnedObject | Promise<FnReturnedObject | unknown> | unknown;
+type Fn = () => unknown;
 /**
  * The task hook function signature.
- * If warmup is enabled, the hook will be called twice, once for the warmup and once for the run.
+ * Hooks apply to both run and warmup phases when warmup is enabled.
+ * `beforeAll`/`afterAll` run once per task and phase; `beforeEach`/`afterEach`
+ * run once per iteration.
  * @param mode the mode where the hook is being called
  */
 type FnHook = (this: Task$1, mode?: HookMode) => Promise<void> | void;
@@ -386,11 +404,11 @@ type FnHook = (this: Task$1, mode?: HookMode) => Promise<void> | void;
  */
 interface FnOptions {
   /**
-   * An optional function that is run after all iterations of this task end
+   * Runs once after all iterations of a task phase (warmup or run).
    */
   afterAll?: FnHook;
   /**
-   * An optional function that is run after each iteration of this task
+   * Runs after each iteration in both warmup and run phases.
    */
   afterEach?: FnHook;
   /**
@@ -403,11 +421,11 @@ interface FnOptions {
    */
   async?: boolean;
   /**
-   * An optional function that is run before iterations of this task begin
+   * Runs once before the iterations of a task phase (warmup or run).
    */
   beforeAll?: FnHook;
   /**
-   * An optional function that is run before each iteration of this task
+   * Runs before each iteration in both warmup and run phases.
    */
   beforeEach?: FnHook;
   /**
@@ -421,23 +439,9 @@ interface FnOptions {
    */
   signal?: AbortSignal;
 }
-/**
- * A possible object returned by task functions to override default behaviors,
- * like the duration of the function itself.
- */
-interface FnReturnedObject {
-  /**
-   * An overridden duration for the task function, to be used instead of the
-   * duration measured by tinybench when running the benchmark.
-   *
-   * This can be useful to measure parts of the execution of a function that are
-   * hard to execute independently.
-   */
-  overriddenDuration?: number;
-}
 /**
  * The hook function signature.
- * If warmup is enabled, the hook will be called twice, once for the warmup and once for the run.
+ * Called once per task and phase: warmup (if enabled), then run.
  * @param task the task instance
  * @param mode the mode where the hook is being called
  */
@@ -470,7 +474,9 @@ type SortedSamples = Samples & {
   readonly __sorted__: unique symbol;
 };
 /**
- * The statistics object
+ * Location and dispersion statistics use the samples' units (ms for latency,
+ * ops/s for throughput), except variance (squared units). Relative margin of
+ * error is a percentage; counts and critical values are dimensionless.
  */
 interface Statistics {
   /**
@@ -478,7 +484,8 @@ interface Statistics {
    */
   aad: number;
   /**
-   * critical value
+   * two-sided 95% critical value of Student's t for {@link Statistics.df},
+   * approached from above as {@link Statistics.df} grows
    */
   critical: number;
   /**
@@ -526,7 +533,8 @@ interface Statistics {
    */
   p999: number;
   /**
-   * relative margin of error
+   * Relative margin of error in percent: `100 * moe / abs(mean)`.
+   * Infinity when the mean is zero.
    */
   rme: number;
   /**
@@ -546,7 +554,7 @@ interface Statistics {
    */
   sem: number;
   /**
-   * variance
+   * Sample variance, in squared sample units.
    */
   variance: number;
 }
@@ -643,24 +651,27 @@ interface TaskResultTimestampProviderInfo {
  */
 interface TaskResultWithStatistics {
   /**
-   * the task latency statistics
+   * Statistics of final latency samples in milliseconds.
    */
   latency: Statistics;
   /**
-   * how long each operation takes (ms)
+   * Mean final latency in milliseconds: `totalTime / runs`.
    */
   period: number;
   /**
-   * the task throughput statistics
+   * Throughput statistics in operations per second.
    */
   throughput: Statistics;
   /**
-   * the time to run the task benchmark cycle (ms)
+   * Sum of final latency samples in milliseconds, after overrides and overhead
+   * correction; not elapsed wall time or the consumed iteration-cost budget.
    */
   totalTime: number;
 }
 /**
  * Reason a sample set is classified as timer-saturated.
+ * Classification requires at least 10 samples. For task diagnostics these are
+ * timer-measured samples after correction; overridden samples are excluded.
  *
  * - `'zero-dominated'` — more than half of the samples are exactly zero.
  * - `'low-distinct'` — distinct sample count is below
@@ -715,7 +726,7 @@ type TimestampProviderName = (string & {}) | TimestampFns;
  */
 type TimestampValue = bigint | number;
 //#endregion
-//#region ../../../../node_modules/.bun/vitest@5.0.1+3a20bcfa24daf8e9/node_modules/vitest/dist/chunks/config.d.CU_b-wJj.d.ts
+//#region ../../../../node_modules/.bun/vitest@5.0.5+68042dbef16394d8/node_modules/vitest/dist/chunks/config.d.QBNYCgFU.d.ts
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -1029,6 +1040,7 @@ declare class SnapshotState {
   private _inlineSnapshotStacks;
   private _testIdToKeys;
   private _rawSnapshots;
+  private _rawSnapshotFiles;
   private _uncheckedKeys;
   private _snapshotFormat;
   private _environment;
@@ -1064,6 +1076,10 @@ declare class SnapshotState {
   probeExpectedSnapshot(options: Pick<SnapshotMatchOptions, "testName" | "testId" | "isInline" | "inlineSnapshot">): ExpectedSnapshot;
   match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }: SnapshotMatchOptions): SnapshotReturnOptions;
   processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }: ProcessDomainSnapshotOptions): SnapshotReturnOptions;
+  /**
+   * The snapshot file, if the test file stores snapshots in it, and every asserted file snapshot.
+   */
+  getSnapshotFiles(): string[];
   pack(): Promise<SnapshotResult>;
 }
 type SnapshotUpdateState = "all" | "new" | "none";
@@ -1169,7 +1185,7 @@ interface UserConsoleLog {
 interface MockResultReturn<T> {
   type: "return";
   /**
-   * The value that was returned from the function. If function returned a Promise, then this will be a resolved value.
+   * The value that was returned from the function. If the function returned a Promise, then this will be the Promise, not its resolved value.
    */
   value: T;
 }
@@ -1219,12 +1235,12 @@ interface MockContext<T extends Procedure | Constructable = Procedure> {
    */
   calls: MockParameters<T>[];
   /**
-   * This is an array containing all instances that were instantiated when mock was called with a `new` keyword. Note that this is an actual context (`this`) of the function, not a return value.
+   * An array with one value for each call: the object returned by `new`, or the context (`this`) of the call if the mock was called without `new`.
    * @see https://vitest.dev/api/mock#mock-instances
    */
   instances: MockProcedureContext<T>[];
   /**
-   * An array of `this` values that were used during each call to the mock function.
+   * An array of `this` values that were used during each call to the mock function. If the mock was called with `new`, the value is the same as in `instances`.
    * @see https://vitest.dev/api/mock#mock-contexts
    */
   contexts: MockProcedureContext<T>[];
@@ -1277,7 +1293,7 @@ interface MockContext<T extends Procedure | Constructable = Procedure> {
   /**
    * An array containing all values that were `resolved` or `rejected` from the function.
    *
-   * This array will be empty if the function was never resolved or rejected.
+   * Until the value is resolved or rejected, the type will be `incomplete`.
    *
    * @see https://vitest.dev/api/mock#mock-settledresults
    * @example
@@ -1315,11 +1331,11 @@ interface MockContext<T extends Procedure | Constructable = Procedure> {
   lastCall: MockParameters<T> | undefined;
 }
 type Procedure = (...args: any[]) => any;
-type NormalizedProcedure<T extends Procedure | Constructable> = T extends Constructable ? ({
+type NormalizedProcedure<T extends Procedure | Constructable> = T extends Constructable ? {
   new (...args: ConstructorParameters<T>): InstanceType<T>;
-}) | ({
+} | {
   (this: InstanceType<T>, ...args: ConstructorParameters<T>): void;
-}) : T extends Procedure ? (...args: Parameters<T>) => ReturnType<T> : never;
+} : T extends Procedure ? (...args: Parameters<T>) => ReturnType<T> : never;
 interface MockInstance<T extends Procedure | Constructable = Procedure> extends Disposable {
   /**
    * Use it to return the name assigned to the mock with the `.mockName(name)` method. By default, it will return `vi.fn()`.
@@ -1358,7 +1374,7 @@ interface MockInstance<T extends Procedure | Constructable = Procedure> extends
    */
   mockRestore(): void;
   /**
-   * Returns current permanent mock implementation if there is one.
+   * Returns current mock implementation if there is one. If an implementation was queued with `mockImplementationOnce`, it returns the first queued implementation instead.
    *
    * If mock was created with `vi.fn`, it will consider passed down method as a mock implementation.
    *
@@ -1417,7 +1433,7 @@ interface MockInstance<T extends Procedure | Constructable = Procedure> extends
    */
   mockReturnValue(value: MockReturnType<T>): this;
   /**
-   * Accepts a value that will be returned whenever the mock function is called. TypeScript will only accept values that match the return type of the original function.
+   * Accepts a value that will be returned during the next function call. TypeScript will only accept values that match the return type of the original function. If chained, each consecutive call will return the specified value.
    *
    * When the mocked function runs out of implementations, it will invoke the default implementation set with `vi.fn(() => defaultValue)` or `.mockImplementation(() => defaultValue)` if they were called.
    * @example
@@ -1493,15 +1509,6 @@ interface MockInstance<T extends Procedure | Constructable = Procedure> extends
    */
   mockRejectedValueOnce(error: unknown): this;
 }
-type Mock<T extends Procedure | Constructable = Procedure> = MockInstance<T> & (T extends Constructable ? (T extends Procedure ? {
-  new (...args: ConstructorParameters<T>): InstanceType<T>;
-  (...args: Parameters<T>): ReturnType<T>;
-} : {
-  new (...args: ConstructorParameters<T>): InstanceType<T>;
-}) : {
-  new (...args: MockParameters<T>): MockReturnType<T>;
-  (...args: MockParameters<T>): MockReturnType<T>;
-}) & { [P in keyof T]: T[P]; };
 interface Constructable {
   new (...args: any[]): any;
 }
@@ -2551,13 +2558,11 @@ interface TaskResult {
    */
   hooks?: Partial<Record<keyof SuiteHooks, TaskState>>;
   /**
-   * The amount of times the task was retried. The task is retried only if it
-   * failed and `retry` option is set.
+   * The number of times the task has been retried across all repeats.
    */
   retryCount?: number;
   /**
-   * The amount of times the task was repeated. The task is repeated only if
-   * `repeats` option is set. This number also contains `retryCount`.
+   * The zero-based index of the current repeat.
    */
   repeatCount?: number;
 }
@@ -2984,7 +2989,7 @@ interface TestArtifactRegistry {}
  */
 type TestArtifact = BrowserTraceArtifact | FailureScreenshotArtifact | TestAnnotationArtifact | VisualRegressionArtifact | TestArtifactRegistry[keyof TestArtifactRegistry];
 //#endregion
-//#region ../../../../node_modules/.bun/vitest@5.0.1+3a20bcfa24daf8e9/node_modules/vitest/dist/chunks/task-utils.d.BZm4GSQD.d.ts
+//#region ../../../../node_modules/.bun/vitest@5.0.5+68042dbef16394d8/node_modules/vitest/dist/chunks/task-utils.d.PFh2BV6Q.d.ts
 interface SnapshotMatcher<R extends void | Promise<void>, T = unknown> {
   <U extends { [P in keyof T]: any; }>(snapshot: Partial<U>, hint?: string): R;
   (hint?: string): R;
@@ -3105,8 +3110,13 @@ declare module "vitest" {
 }
 //#endregion
 //#region src/tracking/registration.fixture.d.ts
-export declare function registration(): {
-  fetcher: Mock<typeof fetch>;
+export declare const sessionEndpoint = "https://registration.invalid/v3/session";
+interface RegistrationFixture {
+  arrived: (count: number) => Promise<void>;
+  registrations: MockInstance<InterfereClient["sessions"]["createSession"]>;
+  requests: Request[];
+  settle: () => Promise<void>;
   tracker: SessionTracker;
-};
+}
+export declare function registration(): Promise<RegistrationFixture>;
 //#endregion