got 14.6.2 → 14.6.3

package/dist/source/core/diagnostics-channel.d.ts

@@ -1,4 +1,4 @@
-import type { Timings } from '@szmarczak/http-timer';
+import type { Timings } from './utils/timer.js';
 import type { RequestError } from './errors.js';
 export type RequestId = string;
 /**

package/dist/source/core/errors.d.ts

@@ -1,4 +1,4 @@
-import type { Timings } from '@szmarczak/http-timer';
+import type { Timings } from './utils/timer.js';
 import type Options from './options.js';
 import type { TimeoutError as TimedOutTimeoutError } from './timed-out.js';
 import type { PlainResponse, Response } from './response.js';

package/dist/source/core/index.d.ts

@@ -1,7 +1,7 @@
 import { Duplex } from 'node:stream';
 import { type ClientRequest } from 'node:http';
 import type { Socket } from 'node:net';
-import { type Timings } from '@szmarczak/http-timer';
+import { type Timings } from './utils/timer.js';
 import Options, { type OptionsInit } from './options.js';
 import { type PlainResponse, type Response } from './response.js';
 import { RequestError } from './errors.js';

package/dist/source/core/index.js

@@ -3,11 +3,11 @@ import { Buffer } from 'node:buffer';
 import { Duplex } from 'node:stream';
 import http, { ServerResponse } from 'node:http';
 import { byteLength } from 'byte-counter';
-import timer from '@szmarczak/http-timer';
 import CacheableRequest, { CacheError as CacheableCacheError, } from 'cacheable-request';
 import decompressResponse from 'decompress-response';
 import is, { isBuffer } from '@sindresorhus/is';
 import { FormDataEncoder, isFormData as isFormDataLike } from 'form-data-encoder';
+import timer from './utils/timer.js';
 import getBodySize from './utils/get-body-size.js';
 import isFormData from './utils/is-form-data.js';
 import proxyEvents from './utils/proxy-events.js';
@@ -596,27 +596,6 @@ export default class Request extends Duplex {
             headers: response.headers,
             isFromCache: typedResponse.isFromCache,
         });
-        // Workaround for http-timer bug: when connecting to an IP address (no DNS lookup),
-        // http-timer sets lookup = connect instead of lookup = socket, resulting in
-        // dns = lookup - socket being a small positive number instead of 0.
-        // See https://github.com/sindresorhus/got/issues/2279
-        const { timings } = response;
-        if (timings?.lookup !== undefined && timings.socket !== undefined && timings.connect !== undefined && timings.lookup === timings.connect && timings.phases.dns !== 0) {
-            // Fix the DNS phase to be 0 and set lookup to socket time
-            timings.phases.dns = 0;
-            timings.lookup = timings.socket;
-            // Recalculate TCP time to be the full time from socket to connect
-            timings.phases.tcp = timings.connect - timings.socket;
-        }
-        // Workaround for http-timer limitation with HTTP/2:
-        // When using HTTP/2, the socket is a proxy that http-timer discards,
-        // so lookup, connect, and secureConnect events are never captured.
-        // This results in phases.request being NaN (undefined - undefined).
-        // Set it to undefined to be consistent with other unavailable timings.
-        // See https://github.com/sindresorhus/got/issues/1958
-        if (timings && Number.isNaN(timings.phases.request)) {
-            timings.phases.request = undefined;
-        }
         response.once('error', (error) => {
             this._aborted = true;
             // Force clean-up, because some packages don't do this.

package/dist/source/core/options.d.ts

@@ -10,8 +10,8 @@ import { type FormDataLike } from 'form-data-encoder';
 import type { KeyvStoreAdapter } from 'keyv';
 import type KeyvType from 'keyv';
 import type ResponseLike from 'responselike';
-import type { IncomingMessageWithTimings } from '@szmarczak/http-timer';
 import type { CancelableRequest } from '../as-promise/types.js';
+import type { IncomingMessageWithTimings } from './utils/timer.js';
 import type { PlainResponse, Response } from './response.js';
 import type { RequestError } from './errors.js';
 import type { Delays } from './timed-out.js';
@@ -1435,8 +1435,8 @@ export default class Options {
     get strictContentLength(): boolean;
     set strictContentLength(value: boolean);
     toJSON(): {
-        headers: Headers;
         timeout: Delays;
+        headers: Headers;
         request: RequestFunction | undefined;
         username: string;
         password: string;

package/dist/source/core/response.d.ts

@@ -1,5 +1,5 @@
 import type { Buffer } from 'node:buffer';
-import type { IncomingMessageWithTimings, Timings } from '@szmarczak/http-timer';
+import type { IncomingMessageWithTimings, Timings } from './utils/timer.js';
 import { RequestError } from './errors.js';
 import type { ParseJsonFunction, ResponseType } from './options.js';
 import type Request from './index.js';

package/dist/source/core/utils/defer-to-connect.d.ts

@@ -0,0 +1,9 @@
+import type { Socket } from 'node:net';
+import type { TLSSocket } from 'node:tls';
+type Listeners = {
+    connect?: () => void;
+    secureConnect?: () => void;
+    close?: (hadError: boolean) => void;
+};
+declare const deferToConnect: (socket: TLSSocket | Socket, fn: Listeners | (() => void)) => void;
+export default deferToConnect;

package/dist/source/core/utils/defer-to-connect.js

@@ -0,0 +1,44 @@
+function isTlsSocket(socket) {
+    return 'encrypted' in socket;
+}
+const deferToConnect = (socket, fn) => {
+    let listeners;
+    if (typeof fn === 'function') {
+        const connect = fn;
+        listeners = { connect };
+    }
+    else {
+        listeners = fn;
+    }
+    const hasConnectListener = typeof listeners.connect === 'function';
+    const hasSecureConnectListener = typeof listeners.secureConnect === 'function';
+    const hasCloseListener = typeof listeners.close === 'function';
+    const onConnect = () => {
+        if (hasConnectListener) {
+            listeners.connect();
+        }
+        if (isTlsSocket(socket) && hasSecureConnectListener) {
+            if (socket.authorized) {
+                listeners.secureConnect();
+            }
+            else {
+                // Wait for secureConnect event (even if authorization fails, we need the timing)
+                socket.once('secureConnect', listeners.secureConnect);
+            }
+        }
+        if (hasCloseListener) {
+            socket.once('close', listeners.close);
+        }
+    };
+    if (socket.writable && !socket.connecting) {
+        onConnect();
+    }
+    else if (socket.connecting) {
+        socket.once('connect', onConnect);
+    }
+    else if (socket.destroyed && hasCloseListener) {
+        const hadError = '_hadError' in socket ? Boolean(socket._hadError) : false;
+        listeners.close(hadError);
+    }
+};
+export default deferToConnect;

package/dist/source/core/utils/timer.d.ts

@@ -0,0 +1,31 @@
+import type { ClientRequest, IncomingMessage } from 'node:http';
+export type Timings = {
+    start: number;
+    socket?: number;
+    lookup?: number;
+    connect?: number;
+    secureConnect?: number;
+    upload?: number;
+    response?: number;
+    end?: number;
+    error?: number;
+    abort?: number;
+    phases: {
+        wait?: number;
+        dns?: number;
+        tcp?: number;
+        tls?: number;
+        request?: number;
+        firstByte?: number;
+        download?: number;
+        total?: number;
+    };
+};
+export type ClientRequestWithTimings = ClientRequest & {
+    timings?: Timings;
+};
+export type IncomingMessageWithTimings = IncomingMessage & {
+    timings?: Timings;
+};
+declare const timer: (request: ClientRequestWithTimings) => Timings;
+export default timer;

package/dist/source/core/utils/timer.js

@@ -0,0 +1,162 @@
+import { errorMonitor } from 'node:events';
+import { types } from 'node:util';
+import deferToConnect from './defer-to-connect.js';
+const timer = (request) => {
+    if (request.timings) {
+        return request.timings;
+    }
+    const timings = {
+        start: Date.now(),
+        socket: undefined,
+        lookup: undefined,
+        connect: undefined,
+        secureConnect: undefined,
+        upload: undefined,
+        response: undefined,
+        end: undefined,
+        error: undefined,
+        abort: undefined,
+        phases: {
+            wait: undefined,
+            dns: undefined,
+            tcp: undefined,
+            tls: undefined,
+            request: undefined,
+            firstByte: undefined,
+            download: undefined,
+            total: undefined,
+        },
+    };
+    request.timings = timings;
+    const handleError = (origin) => {
+        origin.once(errorMonitor, () => {
+            timings.error = Date.now();
+            timings.phases.total = timings.error - timings.start;
+        });
+    };
+    handleError(request);
+    const onAbort = () => {
+        timings.abort = Date.now();
+        timings.phases.total = timings.abort - timings.start;
+    };
+    request.prependOnceListener('abort', onAbort);
+    const onSocket = (socket) => {
+        timings.socket = Date.now();
+        timings.phases.wait = timings.socket - timings.start;
+        if (types.isProxy(socket)) {
+            // HTTP/2: The socket is a proxy, so connection events won't fire.
+            // We can't measure connection timings, so leave them undefined.
+            // This prevents NaN in phases.request calculation.
+            return;
+        }
+        // Check if socket is already connected (reused from connection pool)
+        const socketAlreadyConnected = socket.writable && !socket.connecting;
+        if (socketAlreadyConnected) {
+            // Socket reuse detected: the socket was already connected from a previous request.
+            // For reused sockets, set all connection timestamps to socket time since no new
+            // connection was made for THIS request. But preserve phase durations from the
+            // original connection so they're not lost.
+            timings.lookup = timings.socket;
+            timings.connect = timings.socket;
+            if (socket.__initial_connection_timings__) {
+                // Restore the phase timings from the initial connection
+                timings.phases.dns = socket.__initial_connection_timings__.dnsPhase;
+                timings.phases.tcp = socket.__initial_connection_timings__.tcpPhase;
+                timings.phases.tls = socket.__initial_connection_timings__.tlsPhase;
+                // Set secureConnect timestamp if there was TLS
+                if (timings.phases.tls !== undefined) {
+                    timings.secureConnect = timings.socket;
+                }
+            }
+            else {
+                // Socket reused but no initial timings stored (e.g., from external code)
+                // Set phases to 0
+                timings.phases.dns = 0;
+                timings.phases.tcp = 0;
+            }
+            return;
+        }
+        const lookupListener = () => {
+            timings.lookup = Date.now();
+            timings.phases.dns = timings.lookup - timings.socket;
+        };
+        socket.prependOnceListener('lookup', lookupListener);
+        deferToConnect(socket, {
+            connect() {
+                timings.connect = Date.now();
+                if (timings.lookup === undefined) {
+                    // No DNS lookup occurred (e.g., connecting to an IP address directly)
+                    // Set lookup to socket time (no time elapsed for DNS)
+                    socket.removeListener('lookup', lookupListener);
+                    timings.lookup = timings.socket;
+                    timings.phases.dns = 0;
+                }
+                timings.phases.tcp = timings.connect - timings.lookup;
+                // If lookup and connect happen at the EXACT same time (tcp = 0),
+                // DNS was served from cache and the dns value is just event loop overhead.
+                // Set dns to 0 to indicate no actual DNS resolution occurred.
+                // Fixes https://github.com/szmarczak/http-timer/issues/35
+                if (timings.phases.tcp === 0 && timings.phases.dns && timings.phases.dns > 0) {
+                    timings.phases.dns = 0;
+                }
+                // Store connection phase timings on socket for potential reuse
+                if (!socket.__initial_connection_timings__) {
+                    socket.__initial_connection_timings__ = {
+                        dnsPhase: timings.phases.dns,
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript can't prove this is defined due to callback structure
+                        tcpPhase: timings.phases.tcp,
+                    };
+                }
+            },
+            secureConnect() {
+                timings.secureConnect = Date.now();
+                timings.phases.tls = timings.secureConnect - timings.connect;
+                // Update stored timings with TLS phase timing
+                if (socket.__initial_connection_timings__) {
+                    socket.__initial_connection_timings__.tlsPhase = timings.phases.tls;
+                }
+            },
+        });
+    };
+    if (request.socket) {
+        onSocket(request.socket);
+    }
+    else {
+        request.prependOnceListener('socket', onSocket);
+    }
+    const onUpload = () => {
+        timings.upload = Date.now();
+        // Calculate request phase if we have connection timings
+        const secureOrConnect = timings.secureConnect ?? timings.connect;
+        if (secureOrConnect !== undefined) {
+            timings.phases.request = timings.upload - secureOrConnect;
+        }
+        // If both are undefined (HTTP/2), phases.request stays undefined (not NaN)
+    };
+    if (request.writableFinished) {
+        onUpload();
+    }
+    else {
+        request.prependOnceListener('finish', onUpload);
+    }
+    request.prependOnceListener('response', (response) => {
+        timings.response = Date.now();
+        timings.phases.firstByte = timings.response - timings.upload;
+        response.timings = timings;
+        handleError(response);
+        response.prependOnceListener('end', () => {
+            request.off('abort', onAbort);
+            response.off('aborted', onAbort);
+            if (timings.phases.total !== undefined) {
+                // Aborted or errored
+                return;
+            }
+            timings.end = Date.now();
+            timings.phases.download = timings.end - timings.response;
+            timings.phases.total = timings.end - timings.start;
+        });
+        response.prependOnceListener('aborted', onAbort);
+    });
+    return timings;
+};
+export default timer;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "14.6.2",
+	"version": "14.6.3",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -52,7 +52,6 @@
 	],
 	"dependencies": {
 		"@sindresorhus/is": "^7.0.1",
-		"@szmarczak/http-timer": "^5.0.1",
 		"byte-counter": "^0.1.0",
 		"cacheable-lookup": "^7.0.0",
 		"cacheable-request": "^13.0.12",