@amazon/vinyl-util 1.0.0

package/dist/types/ts4.1/network/RequestInterceptor.d.ts

@@ -0,0 +1,14 @@
+export interface MutableRequestParams {
+    input: string;
+    init: Omit<RequestInit, 'signal'>;
+}
+/**
+ * Mutates a request before it's made.
+ * A request interceptor can be set in Vinyl dependencies. It will be called immediately before a request is made.
+ * The interceptor may modify the request, for example to add headers, change caching, or client-side redirection.
+ * Example to disable caching:
+ *
+ * `(params) => { params.init.cache = 'no-cache' }`
+ */
+export type RequestInterceptor = (params: MutableRequestParams) => void;
+//# sourceMappingURL=RequestInterceptor.d.ts.map

package/dist/types/ts4.1/network/Requester.d.ts

@@ -0,0 +1,84 @@
+import type { ReadonlyAbort } from '../util/async/Abort';
+import type { Maybe } from '../util/type';
+/**
+ * Init options for the request.
+ *
+ * This mirrors the fetch init parameter omitting `signal`. For request cancellation, use
+ * `abort` on RequestOptions.
+ */
+export type RequestInitOptions = Readonly<Omit<RequestInit, 'signal'>>;
+/**
+ * Encapsulates the parameters needed to make a request.
+ */
+export interface RequestParams {
+    readonly input: RequestInfo | Readonly<URL>;
+    readonly init?: Maybe<Readonly<RequestInitOptions>>;
+    readonly requestOptions?: Maybe<RequestOptions>;
+}
+/**
+ * An abstraction to fetching resources.
+ * Implementations may have retry or throttling behaviors.
+ */
+export interface Requester {
+    /**
+     * Requests a resource.
+     *
+     * Note: Unlike `window.fetch`, the returned promise is expected to reject if the
+     * response is !ok.
+     */
+    request(input: RequestInfo | Readonly<URL>, init?: Maybe<RequestInitOptions>, requestOptions?: Maybe<RequestOptions>): Promise<Response>;
+}
+/**
+ * Configuration for a fetch request.
+ */
+export interface RequestOptions {
+    /**
+     * If supplied, will cancel the request on abort.
+     */
+    readonly abort?: Maybe<ReadonlyAbort>;
+    /**
+     * Determines how error responses are read and reported.
+     */
+    readonly readErrorBody?: ErrorBodyType;
+    /**
+     * The service id is used to obtain a service controller for that service.
+     * If nullish, then empty service metrics will be used.
+     */
+    readonly serviceId?: Maybe<string>;
+}
+export declare enum ErrorBodyType {
+    DISABLED = 0,
+    TEXT = 1,
+    JSON = 2
+}
+/**
+ * The signature of `window.fetch`. Provided as a dependency for testing.
+ */
+export type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Capped exponential backoff timing with jitter.
+ *
+ * The timing follows the equation:
+ * `distribution() * min(interval * pow(exponentBase, failureCount), max)`
+ */
+export interface BackoffOptions {
+    /**
+     * The maximum time to wait between tries, in seconds, regardless of how many consecutive
+     * failures.
+     */
+    readonly maxTime: number;
+    /**
+     * The interval in seconds, multiplied by `pow(exponentBase, failureCount)`.
+     */
+    readonly interval: number;
+    /**
+     * pow(exponentBase, failureCount)
+     */
+    readonly exponentBase: number;
+    /**
+     * The distribution function to randomize request retry timing.
+     * This is to prevent all users from making retries at the same time.
+     */
+    readonly distribution: () => number;
+}
+//# sourceMappingURL=Requester.d.ts.map

package/dist/types/ts4.1/network/RequesterImpl.d.ts

@@ -0,0 +1,116 @@
+import { EventHostImpl } from '../event/EventHost';
+import type { NetworkMetricsController } from './metrics/NetworkMetricsController';
+import type { BackoffOptions, Fetch, Requester, RequestInitOptions, RequestOptions } from './Requester';
+import type { RequesterImplEventMap } from './RequesterImplEventMap';
+import type { Maybe, PartialDeep } from '../util/type';
+/**
+ * Request impl options configuring retry and timeout behavior.
+ */
+export interface RequesterImplOptions {
+    /**
+     * Retry configuration.
+     */
+    readonly retryOptions: RetryOptions;
+    /**
+     * The timeout (in seconds) before the request is aborted.
+     */
+    readonly timeout: number;
+}
+export interface RetryOptions {
+    /**
+     * The maximum number of retries for a single request.
+     * Default: 1
+     * For requests with side effects, this should be set to 0.
+     *
+     * "Various studies have collected data which shows that one max retry is sufficient to
+     * achieve 99.999% success. The idea is that a truly transient failure should succeed on
+     * the first retry.  And if the retry fails then it is likely more than a transient failure
+     * and additional retries are exhausting resources in the system for no benefit."
+     */
+    readonly retries: number;
+    /**
+     * The number of consecutive failures before retries are no longer attempted, only tries.
+     */
+    readonly retryFailureCutoff: number;
+    /**
+     * Retry backoff timing.
+     */
+    readonly retryBackoff: BackoffOptions;
+    /**
+     * First try backoff timing.
+     */
+    readonly tryBackoff: BackoffOptions;
+    /**
+     * If there is a retry-after header, add the returned amount of time (in seconds) to prevent
+     * clustered retry behavior.
+     */
+    readonly retryAfterJitter: () => number;
+    /**
+     * Given the network status code, returns true if the fetch should retry.
+     */
+    readonly shouldRetry: (status: number) => boolean;
+}
+/**
+ * The minimum amount of time to leave for network calls. If the `max try time -
+ * timeout` is less than this value, an IllegalArgumentError will be thrown.
+ */
+export declare const MIN_SERVICE_TIME = 10;
+/**
+ * Distribute requests across the last 50% of the exponential back-off time
+ */
+export declare function defaultBackoffDistribution(): number;
+/**
+ * Calculates the timer delay according to an exponential back off strategy.
+ *
+ * @param failedCount The number of times the service has consecutively failed.
+ * @param options Retry timing options (default values from:
+ *   `defaultRetryOptions`)
+ *
+ * @returns The delay to retry a network request in seconds. This will be clamped
+ *   between 1 and `options.maxRetryTime`.
+ */
+export declare function getBackoffTime(failedCount: number, options: BackoffOptions): number;
+/**
+ * Dependencies for {@link RequesterImpl}
+ */
+export interface RequesterImplDeps {
+    readonly fetch: Fetch;
+    readonly networkMetricsController: NetworkMetricsController;
+}
+export declare const RetryStrategy: {
+    readonly NO_RETRIES: RetryOptions;
+    readonly ONE_RETRY: RetryOptions;
+};
+/**
+ * A quality of service wrapper to `global.fetch`.
+ * Handles retries, network status, and emits events that may be used in reporting or metrics.
+ */
+export declare class RequesterImpl extends EventHostImpl<RequesterImplEventMap> implements Requester {
+    protected readonly deps: RequesterImplDeps;
+    get [Symbol.toStringTag](): string;
+    /**
+     * Default values for fetch options.
+     */
+    private _options;
+    constructor(deps: RequesterImplDeps);
+    get options(): RequesterImplOptions;
+    /**
+     * Applies the given partial configuration.
+     *
+     * @param newOptions
+     */
+    configure(newOptions: PartialDeep<RequesterImplOptions>): void;
+    request(input: RequestInfo | Readonly<URL>, init?: Maybe<RequestInitOptions>, requestOptions?: Maybe<RequestOptions>): Promise<Response>;
+    /**
+     * Executes a single fetch.
+     * If the request is aborted via `requestInfo.init.signal` the promise will be rejected with
+     * the abort reason.
+     *
+     * @throws RequestError
+     * @private
+     */
+    private doRequest;
+    private reportMetricsEntry;
+}
+export declare const nativeFetchRef: import("../global/globalRegistry").GlobalRef<Fetch>;
+//# sourceMappingURL=RequesterImpl.d.ts.map

package/dist/types/ts4.1/network/RequesterImplEventMap.d.ts

@@ -0,0 +1,230 @@
+import type { Timestamp } from '../util/date/date';
+import type { ErrorBodyType } from '../network/Requester';
+/**
+ * Events {@link RequesterImpl} emits.
+ */
+export interface RequesterImplEventMap {
+    /**
+     * A request has been requested.
+     * This is emitted immediately when {@link Requester.request} is called.
+     */
+    readonly request: RequestEvent;
+    /**
+     * A request attempt has begun. For implementations with retry behavior, this is expected to be
+     * emitted for each try.
+     */
+    readonly requestAttemptStart: RequestAttemptStartEvent;
+    /**
+     * A request attempt has completed.
+     */
+    readonly requestAttemptComplete: RequestCompletedEvent;
+    /**
+     * The request promise is about to settle.
+     */
+    readonly requestComplete: RequestCompletedEvent;
+}
+export interface RequestEvent {
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+}
+export interface RequestAttemptStartEvent {
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+/**
+ * When a request has been made, information about the request is gathered for logging.
+ */
+export interface FetchRequestInfo {
+    /**
+     * The identifier for the request. The request id for the `requesting` event will match its
+     * corresponding `requestComplete` event.
+     */
+    readonly requestId: string;
+    /**
+     * The input parameter passed to `request`.
+     */
+    readonly input: RequestInfo | URL;
+    /**
+     * The init parameter passed to `request`.
+     */
+    readonly init: RequestInit;
+    /**
+     * The maximum number of retries.
+     */
+    readonly maxRetries: number;
+    /**
+     * Options the request is using.
+     */
+    readonly requestOptions: {
+        /**
+         * The resolved service id.
+         */
+        readonly serviceId: string | null;
+        /**
+         * Determines how error responses are read and reported.
+         */
+        readonly readErrorBody: ErrorBodyType;
+    };
+    /**
+     * The timestamp the request was originally requested.
+     */
+    readonly timestamp: Timestamp;
+}
+/**
+ * Information about the current try.
+ */
+export interface RequestAttemptInfo {
+    /**
+     * The current try (1 = first).
+     */
+    readonly currentTry: number;
+    /**
+     * The timestamp the actual request attempt began. This will be after awaiting network
+     * availability.
+     */
+    readonly timestamp: Timestamp;
+}
+/**
+ * Information about a request completion, either from a successful response or a failure.
+ */
+export type RequestCompletedEvent = RequestSuccessEvent | RequestErrorEvent;
+export interface RequestCompletedEventBase {
+    /**
+     * True if the request was successful.
+     */
+    readonly ok: boolean;
+    /**
+     * The local timestamp of the request result or error.
+     */
+    readonly timestamp: Timestamp;
+    /**
+     * Information about the request.
+     */
+    readonly requestInfo: FetchRequestInfo;
+}
+export interface RequestSuccessEvent extends RequestCompletedEventBase {
+    /**
+     * The response was successful.
+     */
+    readonly ok: true;
+    /**
+     * The serializable and loggable response.
+     */
+    readonly responseInfo: ResponseInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+export declare enum RequestFailureType {
+    /**
+     * The request has been aborted.
+     */
+    ABORT = "abort",
+    /**
+     * The request failed due to a caught internal error.
+     */
+    INTERNAL = "internal",
+    /**
+     * The request failed with a caught error.
+     */
+    NETWORK = "network",
+    /**
+     * An `!ok` response was received.
+     */
+    RESPONSE = "response"
+}
+export type RequestErrorEvent = RequestCaughtErrorEvent | RequestNetworkErrorEvent | RequestResponseErrorEvent;
+export interface RequestErrorEventBase extends RequestCompletedEventBase {
+    /**
+     * The request failed.
+     */
+    readonly ok: false;
+    /**
+     * The failure type.
+     */
+    readonly type: RequestFailureType;
+    /**
+     * If false, the request will not be retried, even if there are more tries remaining.
+     *
+     * This will be false if the error is an internal error, retries have been exhausted or the
+     * response did not pass the `shouldRetry` filter.
+     */
+    readonly willRetry: boolean;
+    /**
+     * The timestamp of the next try.
+     * If `willRetry` is true, the request will try again at this timestamp.
+     */
+    readonly retryAfter: Timestamp | null;
+    /**
+     * The caught or rejected reason.
+     */
+    readonly reason: any;
+}
+export interface RequestCaughtErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.INTERNAL | RequestFailureType.ABORT;
+    /**
+     * Caught errors will not be retried.
+     */
+    readonly willRetry: false;
+}
+export interface RequestNetworkErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.NETWORK;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+export interface RequestResponseErrorEvent extends RequestErrorEventBase {
+    readonly type: RequestFailureType.RESPONSE;
+    /**
+     * The serializable and loggable response.
+     */
+    readonly responseInfo: ResponseInfo;
+    /**
+     * Information about the current attempt.
+     */
+    readonly attemptInfo: RequestAttemptInfo;
+}
+/**
+ * Serializable response metadata, excluding the body.
+ */
+export interface ResponseInfo {
+    /**
+     * True if status is in the 200–299 range.
+     */
+    readonly ok: boolean;
+    /**
+     * True if the response resulted from a redirect.
+     */
+    readonly redirected: boolean;
+    /**
+     * HTTP status code (e.g. 200).
+     */
+    readonly status: number;
+    /**
+     * HTTP status text (e.g. "OK").
+     */
+    readonly statusText: string;
+    /**
+     * Type of response (e.g. "basic", "cors").
+     */
+    readonly type: ResponseType;
+    /**
+     * Final resolved URL of the response.
+     */
+    readonly url: string;
+    /**
+     * Size of the response body in bytes, or null if unknown.
+     */
+    readonly contentLength: number | null;
+}
+//# sourceMappingURL=RequesterImplEventMap.d.ts.map

package/dist/types/ts4.1/network/browser/NetworkInformation.d.ts

@@ -0,0 +1,48 @@
+export interface NetworkInformationEventMap {
+    readonly change: Event;
+}
+export type NetworkInformationEffectiveType = 'slow-2g' | '2g' | '3g' | '4g';
+export type NetworkInformationType = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown';
+/**
+ * Provides information about the system’s current network connection,
+ * such as estimated bandwidth, round-trip time, and connection type.
+ * Also exposes events for monitoring changes to the network state.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/NetworkInformation
+ */
+export interface NetworkInformation extends EventTarget {
+    /**
+     * Approximate downlink speed in megabits per second.
+     * Rounded to the nearest 25 kbps, based on recent throughput
+     * over active connections. May be undefined if no estimate is available.
+     */
+    readonly downlink: number | undefined;
+    /**
+     * A string describing the general quality of the connection
+     * (for example, "4g", "3g"). Determined from both downlink
+     * and latency estimates.
+     */
+    readonly effectiveType: NetworkInformationEffectiveType;
+    /**
+     * Estimated round-trip latency of the current connection in milliseconds,
+     * rounded to the nearest multiple of 25 ms.
+     */
+    readonly rtt: number;
+    /**
+     * Indicates whether the user has requested reduced data usage
+     * in the user agent’s settings.
+     */
+    readonly saveData: boolean;
+    /**
+     * Type of underlying network connection in use
+     * (for example, "wifi", "cellular"). May be omitted if unknown.
+     */
+    readonly type?: NetworkInformationType;
+    addEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+/**
+ * Returns the browser's NetworkInformation interface, if it's defined.
+ */
+export declare function getNetworkInformation(): NetworkInformation | undefined;
+//# sourceMappingURL=NetworkInformation.d.ts.map

package/dist/types/ts4.1/network/createRequester.d.ts

@@ -0,0 +1,12 @@
+import type { Requester } from './Requester';
+import type { RequesterImplDeps, RequesterImplOptions } from './RequesterImpl';
+import type { Maybe, PartialDeep } from '../util/type';
+/**
+ * Creates a default Requester implementation with optional configuration or dependency overrides.
+ * The new Requester is watched for global logging and network metrics.
+ *
+ * @param options
+ * @param deps
+ */
+export declare function createRequester(options?: Maybe<PartialDeep<RequesterImplOptions>>, deps?: Partial<RequesterImplDeps>): Requester;
+//# sourceMappingURL=createRequester.d.ts.map

package/dist/types/ts4.1/network/logging/networkLoggingHandler.d.ts

@@ -0,0 +1,14 @@
+import type { Disposable } from '../../core/disposable';
+import type { ReadonlyEventHost } from '../../event/EventHost';
+import type { RequesterImplEventMap } from '../../network/RequesterImplEventMap';
+import type { LogTarget } from '../../logging/LogTarget';
+/**
+ * Logs all network events.
+ *
+ * @param requester The event host with request events to observe.
+ * @return Returns a disposable handle to remove all added handlers.
+ */
+export declare function networkLoggingHandler(requester: ReadonlyEventHost<RequesterImplEventMap>): Disposable & {
+    readonly target: LogTarget;
+};
+//# sourceMappingURL=networkLoggingHandler.d.ts.map

package/dist/types/ts4.1/network/metrics/NetworkMetricsController.d.ts

@@ -0,0 +1,41 @@
+import type { ReadonlyEventHost } from '../../event/EventHost';
+import type { AnyRecord, Maybe } from '../../util/type';
+import type { NetworkMetrics, NetworkMetricsEntry, NetworkTransferEntry, ServiceMetrics } from './networkMetricsModel';
+export interface NetworkMetricsEventMap {
+    /**
+     * The network metrics state has changed.
+     */
+    readonly metricsChange: AnyRecord;
+}
+export interface ReadonlyNetworkMetricsController extends ReadonlyEventHost<NetworkMetricsEventMap> {
+    /**
+     * The current metrics state.
+     * The returned object is static at the time of request.
+     */
+    readonly metrics: NetworkMetrics;
+    /**
+     * Returns metrics for the given service id.
+     * If the service id is nullish, or there is no history for the given service, empty service
+     * metrics will be returned.
+     *
+     * The returned object is static at the time of request.
+     *
+     * @param serviceId
+     */
+    getServiceMetrics(serviceId: Maybe<string>): ServiceMetrics;
+}
+export interface NetworkMetricsController extends ReadonlyNetworkMetricsController {
+    /**
+     * Adds information about a completed settled request.
+     * Note: This does not update estimated bandwidth.
+     * @param entry
+     */
+    addMetricsEntry(entry: NetworkMetricsEntry): void;
+    /**
+     * Adds information about a completed downlink content transfer.
+     *
+     * @param entry
+     */
+    addDownlinkTransferEntry(entry: NetworkTransferEntry): void;
+}
+//# sourceMappingURL=NetworkMetricsController.d.ts.map

package/dist/types/ts4.1/network/metrics/NetworkMetricsControllerImpl.d.ts

@@ -0,0 +1,119 @@
+import { EventHostImpl } from '../../event/EventHost';
+import type { NetworkInformation } from '../../network/browser/NetworkInformation';
+import type { NetworkMetricsController, NetworkMetricsEventMap } from './NetworkMetricsController';
+import type { NetworkMetrics, NetworkMetricsEntry, NetworkTransferEntry, ServiceMetrics } from './networkMetricsModel';
+import type { ReadonlyDeep } from '../../util/object/readonlyType';
+import type { Maybe } from '../../util/type';
+import type { Timestamp } from '../../util/date/date';
+export interface NetworkMetricsControllerImplOptions {
+    /**
+     * The smoothing factor for EWMA (Exponential Moving Weighted Average), used in
+     * bandwidth and response time moving averages.
+     *
+     * The purpose is to give more weight to recent events than old events, while keeping
+     * calculations simple and avoiding the need to keep histories as a rolling average would.
+     *
+     * This value should be between 0 and 1.
+     * The closer to 1 this value is, the more weight new values have.
+     * A value of 0.2 for example would mean that after 10 updates, the current average after
+     * ten new data points would influence the new average by (1-0.2)^10 ≈ 10% and the latest
+     * update would influence the average by 20%.
+     */
+    readonly ewmaSmoothing: number;
+    /**
+     * For biased values such as ewmaHigh/ewmaLow, when the value is in the direction of the
+     * bias, this smoothing will be used.
+     * This should be a value between 0 and 1 and be more than bias negative smoothing.
+     */
+    readonly ewmaBiasPositiveSmoothing: number;
+    /**
+     * For biased values such as ewmaHigh/ewmaLow, when the value is not in the direction of the
+     * bias, this smoothing will be used.
+     * This should be a value between 0 and 1 and be less than bias positive smoothing.
+     */
+    readonly ewmaBiasNegativeSmoothing: number;
+    /**
+     * When the user's bandwidth cannot be determined due to lack of NetworkInformation support
+     * and no reported downlink history, then this value will be used.
+     * This should be in bits per second.
+     */
+    readonly unknownDownlinkBandwidthEstimate: number;
+    /**
+     * Maximum bandwidth in bps we will attribute to any single measurement.
+     * Transfers measured above this are clamped; zero-duration transfers are
+     * treated as this speed rather than discarded.
+     * Default: 30_000_000
+     */
+    readonly maxMeasuredBandwidthBps: number;
+    /**
+     * Time window (in seconds) for amortizing network transfer entries in bandwidth estimation.
+     *
+     * This window enables accurate bandwidth calculation across multiple concurrent streams
+     * (audio, video, etc.) by aggregating transfer data over time.
+     *
+     * - Too low: Streams won't be properly combined, leading to inaccurate estimates
+     * - Too high: Bandwidth estimation becomes slow to adapt to network changes
+     *
+     * @default 4
+     */
+    readonly bandwidthEstimationWindow: number;
+}
+/**
+ * Default configuration for NetworkMetricsControllerImpl
+ */
+export declare const defaultNetworkMetricsControllerImplOptions: {
+    readonly ewmaSmoothing: 0.2;
+    readonly ewmaBiasNegativeSmoothing: 0.1;
+    readonly ewmaBiasPositiveSmoothing: 0.5;
+    readonly unknownDownlinkBandwidthEstimate: 2200000;
+    readonly maxMeasuredBandwidthBps: 30000000;
+    readonly bandwidthEstimationWindow: 4;
+};
+export interface NetworkMetricsControllerImplDependencies {
+    readonly networkInformation?: Maybe<NetworkInformation>;
+}
+export declare class NetworkMetricsControllerImpl extends EventHostImpl<NetworkMetricsEventMap> implements NetworkMetricsController {
+    private readonly deps;
+    private _metrics;
+    /**
+     * A clone of _metrics, copied on read after a change.
+     * @private
+     */
+    private _metricsSnapshot;
+    private hasChanged;
+    private readonly options;
+    private readonly transferEntries;
+    private readonly refreshEstimatedBandwidthThrottled;
+    private readonly disposer;
+    constructor(deps: NetworkMetricsControllerImplDependencies, options?: Partial<NetworkMetricsControllerImplOptions>);
+    get [Symbol.toStringTag](): string;
+    get metrics(): NetworkMetrics;
+    getServiceMetrics(serviceId: Maybe<string>): ReadonlyDeep<ServiceMetrics>;
+    addMetricsEntry(entry: NetworkMetricsEntry): void;
+    private readonly refreshEstimatedBandwidth;
+    addDownlinkTransferEntry(entry: NetworkTransferEntry): void;
+    private onDownloadSpeedChange;
+    private notifyMetricsChange;
+    dispose(): void;
+}
+/**
+ * Estimates the timestamp when the first response byte was received for a network transfer.
+ *
+ * When the browser's Resource Timing API provides `responseStart`, that value is used directly.
+ * Otherwise, a logistic model estimates the latency fraction (the proportion of total
+ * request time spent waiting for the first byte) from the transfer size and total duration.
+ *
+ * The model uses a sigmoid function parameterized on a feature combining `log(bytes)` and
+ * `log(totalTime)`. Larger transfers relative to their duration are assumed to have a smaller
+ * latency fraction (most time is spent downloading), while small or slow transfers are assumed
+ * to be latency-dominated.
+ *
+ * `responseEnd` represents when the fetch promise settled (approximately when HTTP headers
+ * arrived). This provides an upper bound on when the first byte was received — the actual
+ * responseStart is at or before this point.
+ *
+ * @param entry - A completed network transfer entry with timing information.
+ * @returns The estimated timestamp (ms since epoch) when the first response byte arrived.
+ */
+export declare function estimateResponseStart(entry: NetworkTransferEntry): Timestamp;
+//# sourceMappingURL=NetworkMetricsControllerImpl.d.ts.map