@pnpm/network.fetch 1000.2.6 → 1100.0.0

package/lib/dispatcher.d.ts

@@ -0,0 +1,25 @@
+import type { TlsConfig } from '@pnpm/types';
+import { type Dispatcher } from 'undici';
+export type ClientCertificates = Record<string, TlsConfig>;
+export interface DispatcherOptions {
+    ca?: string | string[] | Buffer;
+    cert?: string | string[] | Buffer;
+    key?: string | Buffer;
+    localAddress?: string;
+    maxSockets?: number;
+    strictSsl?: boolean;
+    timeout?: number;
+    httpProxy?: string;
+    httpsProxy?: string;
+    noProxy?: boolean | string;
+    clientCertificates?: ClientCertificates;
+}
+/**
+ * Clear the dispatcher cache. Useful for testing.
+ */
+export declare function clearDispatcherCache(): void;
+/**
+ * Get a dispatcher for the given URI and options.
+ * Returns undefined if no special configuration is needed (to use global dispatcher).
+ */
+export declare function getDispatcher(uri: string, opts: DispatcherOptions): Dispatcher | undefined;

package/lib/dispatcher.js

@@ -0,0 +1,323 @@
+import net from 'node:net';
+import tls from 'node:tls';
+import { URL } from 'node:url';
+import { nerfDart } from '@pnpm/config.nerf-dart';
+import { PnpmError } from '@pnpm/error';
+import { LRUCache } from 'lru-cache';
+import { SocksClient } from 'socks';
+import { Agent, ProxyAgent, setGlobalDispatcher } from 'undici';
+const DEFAULT_MAX_SOCKETS = 50;
+const KEEP_ALIVE_TIMEOUT = 30_000; // 30 seconds
+const KEEP_ALIVE_MAX_TIMEOUT = 600_000; // 10 minutes
+// Set an optimized global dispatcher so that requests without custom options
+// (no proxy, no custom certs) still benefit from better keep-alive and Happy Eyeballs.
+//
+// Note: we intentionally do NOT enable HTTP/2 (allowH2) or HTTP/1.1 pipelining here.
+// With HTTP/2, undici multiplexes many streams over 1-2 TCP connections sharing a single
+// congestion window. In benchmarks this was slower than opening ~50 independent HTTP/1.1
+// connections that each get their own congestion window and can saturate bandwidth in parallel.
+setGlobalDispatcher(new Agent({
+    connections: DEFAULT_MAX_SOCKETS,
+    keepAliveTimeout: KEEP_ALIVE_TIMEOUT,
+    keepAliveMaxTimeout: KEEP_ALIVE_MAX_TIMEOUT,
+    connect: {
+        autoSelectFamily: true,
+    },
+}));
+const DISPATCHER_CACHE = new LRUCache({
+    max: 50,
+    dispose: (dispatcher) => {
+        if (typeof dispatcher.close === 'function') {
+            void dispatcher.close();
+        }
+    },
+});
+/**
+ * Clear the dispatcher cache. Useful for testing.
+ */
+export function clearDispatcherCache() {
+    DISPATCHER_CACHE.clear();
+}
+/**
+ * Get a dispatcher for the given URI and options.
+ * Returns undefined if no special configuration is needed (to use global dispatcher).
+ */
+export function getDispatcher(uri, opts) {
+    // If no special options are set, use the global dispatcher
+    if (!needsCustomDispatcher(opts)) {
+        return undefined;
+    }
+    const parsedUri = new URL(uri);
+    if ((opts.httpProxy || opts.httpsProxy) && !checkNoProxy(parsedUri, opts)) {
+        const proxyDispatcher = getProxyDispatcher(parsedUri, opts);
+        if (proxyDispatcher)
+            return proxyDispatcher;
+    }
+    return getNonProxyDispatcher(parsedUri, opts);
+}
+function hasClientCertificates(certs) {
+    if (!certs)
+        return false;
+    for (const uri in certs) {
+        const entry = certs[uri];
+        if (entry.cert || entry.key || entry.ca)
+            return true;
+    }
+    return false;
+}
+function needsCustomDispatcher(opts) {
+    return Boolean(opts.httpProxy ||
+        opts.httpsProxy ||
+        opts.ca ||
+        opts.cert ||
+        opts.key ||
+        opts.localAddress ||
+        opts.strictSsl === false ||
+        hasClientCertificates(opts.clientCertificates) ||
+        opts.maxSockets);
+}
+function parseProxyUrl(proxy, protocol) {
+    let proxyUrl = proxy;
+    if (!proxyUrl.includes('://')) {
+        proxyUrl = `${protocol}//${proxyUrl}`;
+    }
+    try {
+        return new URL(proxyUrl);
+    }
+    catch {
+        throw new PnpmError('INVALID_PROXY', "Couldn't parse proxy URL", {
+            hint: 'If your proxy URL contains a username and password, make sure to URL-encode them ' +
+                '(you may use the encodeURIComponent function). For instance, ' +
+                'https-proxy=https://use%21r:pas%2As@my.proxy:1234/foo. ' +
+                'Do not encode the colon (:) between the username and password.',
+        });
+    }
+}
+function getSocksProxyType(protocol) {
+    switch (protocol.replace(':', '')) {
+        case 'socks4':
+        case 'socks4a':
+            return 4;
+        default:
+            return 5;
+    }
+}
+function getProxyDispatcher(parsedUri, opts) {
+    const isHttps = parsedUri.protocol === 'https:';
+    const proxy = isHttps ? opts.httpsProxy : opts.httpProxy;
+    if (!proxy)
+        return null;
+    const proxyUrl = parseProxyUrl(proxy, parsedUri.protocol);
+    const sslConfig = pickSettingByUrl(opts.clientCertificates, parsedUri.href);
+    const { ca, cert, key: certKey } = { ...opts, ...sslConfig };
+    const key = [
+        `proxy:${proxyUrl.protocol}//${proxyUrl.username}:${proxyUrl.password}@${proxyUrl.host}:${proxyUrl.port}`,
+        `https:${isHttps.toString()}`,
+        `local-address:${opts.localAddress ?? '>no-local-address<'}`,
+        `max-sockets:${(opts.maxSockets ?? DEFAULT_MAX_SOCKETS).toString()}`,
+        `strict-ssl:${isHttps ? Boolean(opts.strictSsl).toString() : '>no-strict-ssl<'}`,
+        `ca:${(isHttps && ca?.toString()) || '-'}`,
+        `cert:${(isHttps && cert?.toString()) || '-'}`,
+        `key:${(isHttps && certKey?.toString()) || '-'}`,
+    ].join(':');
+    if (DISPATCHER_CACHE.has(key)) {
+        return DISPATCHER_CACHE.get(key);
+    }
+    let dispatcher;
+    if (proxyUrl.protocol.startsWith('socks')) {
+        dispatcher = createSocksDispatcher(proxyUrl, parsedUri, opts, { ca, cert, key: certKey });
+    }
+    else {
+        dispatcher = createHttpProxyDispatcher(proxyUrl, isHttps, opts, { ca, cert, key: certKey });
+    }
+    DISPATCHER_CACHE.set(key, dispatcher);
+    return dispatcher;
+}
+function createHttpProxyDispatcher(proxyUrl, isHttps, opts, tlsConfig) {
+    return new ProxyAgent({
+        uri: proxyUrl.href,
+        token: proxyUrl.username
+            ? `Basic ${Buffer.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString('base64')}`
+            : undefined,
+        connections: opts.maxSockets ?? DEFAULT_MAX_SOCKETS,
+        keepAliveTimeout: KEEP_ALIVE_TIMEOUT,
+        keepAliveMaxTimeout: KEEP_ALIVE_MAX_TIMEOUT,
+        requestTls: isHttps
+            ? {
+                ca: tlsConfig.ca,
+                cert: tlsConfig.cert,
+                key: tlsConfig.key,
+                rejectUnauthorized: opts.strictSsl ?? true,
+                localAddress: opts.localAddress,
+            }
+            : undefined,
+        proxyTls: {
+            ca: opts.ca,
+            rejectUnauthorized: opts.strictSsl ?? true,
+        },
+    });
+}
+function createSocksDispatcher(proxyUrl, targetUri, opts, tlsConfig) {
+    const isHttps = targetUri.protocol === 'https:';
+    const socksType = getSocksProxyType(proxyUrl.protocol);
+    const proxyHost = proxyUrl.hostname;
+    const proxyPort = parseInt(proxyUrl.port, 10) || (socksType === 4 ? 1080 : 1080);
+    return new Agent({
+        connections: opts.maxSockets ?? DEFAULT_MAX_SOCKETS,
+        keepAliveTimeout: KEEP_ALIVE_TIMEOUT,
+        keepAliveMaxTimeout: KEEP_ALIVE_MAX_TIMEOUT,
+        connect: async (connectOpts, callback) => {
+            try {
+                const { socket } = await SocksClient.createConnection({
+                    proxy: {
+                        host: proxyHost,
+                        port: proxyPort,
+                        type: socksType,
+                        userId: proxyUrl.username ? decodeURIComponent(proxyUrl.username) : undefined,
+                        password: proxyUrl.password ? decodeURIComponent(proxyUrl.password) : undefined,
+                    },
+                    command: 'connect',
+                    destination: {
+                        host: connectOpts.hostname,
+                        port: parseInt(String(connectOpts.port), 10),
+                    },
+                });
+                if (isHttps) {
+                    const tlsOpts = {
+                        socket: socket,
+                        servername: connectOpts.hostname,
+                        ca: tlsConfig.ca,
+                        cert: tlsConfig.cert,
+                        key: tlsConfig.key,
+                        rejectUnauthorized: opts.strictSsl ?? true,
+                    };
+                    const tlsSocket = tls.connect(tlsOpts);
+                    tlsSocket.on('secureConnect', () => {
+                        callback(null, tlsSocket);
+                    });
+                    tlsSocket.on('error', (err) => {
+                        callback(err, null);
+                    });
+                }
+                else {
+                    callback(null, socket);
+                }
+            }
+            catch (err) {
+                callback(err, null);
+            }
+        },
+    });
+}
+function getNonProxyDispatcher(parsedUri, opts) {
+    const isHttps = parsedUri.protocol === 'https:';
+    const sslConfig = pickSettingByUrl(opts.clientCertificates, parsedUri.href);
+    const { ca, cert, key: certKey } = { ...opts, ...sslConfig };
+    const key = [
+        `https:${isHttps.toString()}`,
+        `local-address:${opts.localAddress ?? '>no-local-address<'}`,
+        `max-sockets:${(opts.maxSockets ?? DEFAULT_MAX_SOCKETS).toString()}`,
+        `strict-ssl:${isHttps ? Boolean(opts.strictSsl).toString() : '>no-strict-ssl<'}`,
+        `ca:${(isHttps && ca?.toString()) || '-'}`,
+        `cert:${(isHttps && cert?.toString()) || '-'}`,
+        `key:${(isHttps && certKey?.toString()) || '-'}`,
+    ].join(':');
+    if (DISPATCHER_CACHE.has(key)) {
+        return DISPATCHER_CACHE.get(key);
+    }
+    const connectTimeout = typeof opts.timeout !== 'number' || opts.timeout === 0
+        ? 0
+        : opts.timeout + 1;
+    const agent = new Agent({
+        connections: opts.maxSockets ?? DEFAULT_MAX_SOCKETS,
+        connectTimeout,
+        keepAliveTimeout: KEEP_ALIVE_TIMEOUT,
+        keepAliveMaxTimeout: KEEP_ALIVE_MAX_TIMEOUT,
+        connect: isHttps
+            ? {
+                autoSelectFamily: true,
+                ca,
+                cert,
+                key: certKey,
+                rejectUnauthorized: opts.strictSsl ?? true,
+                localAddress: opts.localAddress,
+            }
+            : {
+                autoSelectFamily: true,
+                localAddress: opts.localAddress,
+            },
+    });
+    DISPATCHER_CACHE.set(key, agent);
+    return agent;
+}
+function checkNoProxy(parsedUri, opts) {
+    const host = parsedUri.hostname
+        .split('.')
+        .filter(x => x)
+        .reverse();
+    if (typeof opts.noProxy === 'string') {
+        const noproxyArr = opts.noProxy.split(',').map(s => s.trim());
+        return noproxyArr.some(no => {
+            const noParts = no
+                .split('.')
+                .filter(x => x)
+                .reverse();
+            if (noParts.length === 0) {
+                return false;
+            }
+            for (let i = 0; i < noParts.length; i++) {
+                if (host[i] !== noParts[i]) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    return opts.noProxy === true;
+}
+/**
+ * Pick SSL/TLS configuration by URL using nerf-dart matching.
+ * This matches the behavior of @pnpm/network.config's pickSettingByUrl.
+ */
+function pickSettingByUrl(settings, uri) {
+    if (!settings)
+        return undefined;
+    // Try exact match first
+    if (settings[uri])
+        return settings[uri];
+    // Use nerf-dart format for matching (e.g., //registry.npmjs.org/)
+    const nerf = nerfDart(uri);
+    if (settings[nerf])
+        return settings[nerf];
+    // Try without port
+    const parsedUrl = new URL(uri);
+    const withoutPort = removePort(parsedUrl);
+    if (settings[withoutPort])
+        return settings[withoutPort];
+    // Try progressively shorter nerf-dart paths
+    const maxParts = Object.keys(settings).reduce((max, key) => {
+        const parts = key.split('/').length;
+        return parts > max ? parts : max;
+    }, 0);
+    const parts = nerf.split('/');
+    for (let i = Math.min(parts.length, maxParts) - 1; i >= 3; i--) {
+        const key = `${parts.slice(0, i).join('/')}/`;
+        if (settings[key]) {
+            return settings[key];
+        }
+    }
+    // If the URL had a port, try again without it
+    if (withoutPort !== uri) {
+        return pickSettingByUrl(settings, withoutPort);
+    }
+    return undefined;
+}
+function removePort(parsedUrl) {
+    if (parsedUrl.port === '')
+        return parsedUrl.href;
+    const copy = new URL(parsedUrl.href);
+    copy.port = '';
+    const res = copy.toString();
+    return res.endsWith('/') ? res : `${res}/`;
+}
+//# sourceMappingURL=dispatcher.js.map

package/lib/fetch.d.ts

@@ -1,14 +1,15 @@
 import { type RetryTimeoutOptions } from '@zkochan/retry';
-import { type Request, type RequestInit as NodeRequestInit, Response } from 'node-fetch';
-export { isRedirect } from 'node-fetch';
-export { Response, type RetryTimeoutOptions };
+import { type Dispatcher } from 'undici';
+export { type RetryTimeoutOptions };
 interface URLLike {
     href: string;
 }
-export type RequestInfo = string | URLLike | Request;
-export interface RequestInit extends NodeRequestInit {
+export declare function isRedirect(statusCode: number): boolean;
+export type RequestInfo = string | URLLike | URL;
+export interface RequestInit extends globalThis.RequestInit {
     retry?: RetryTimeoutOptions;
     timeout?: number;
+    dispatcher?: Dispatcher;
 }
 export declare function fetch(url: RequestInfo, opts?: RequestInit): Promise<Response>;
 export declare class ResponseError extends Error {

package/lib/fetch.js

@@ -1,14 +1,15 @@
-import assert from 'node:assert';
-import util from 'node:util';
 import { requestRetryLogger } from '@pnpm/core-loggers';
 import { operation } from '@zkochan/retry';
-import nodeFetch, { Response } from 'node-fetch';
-export { isRedirect } from 'node-fetch';
-export { Response };
+import { fetch as undiciFetch } from 'undici';
+export {};
 const NO_RETRY_ERROR_CODES = new Set([
     'SELF_SIGNED_CERT_IN_CHAIN',
     'ERR_OSSL_PEM_NO_START_LINE',
 ]);
+const REDIRECT_CODES = new Set([301, 302, 303, 307, 308]);
+export function isRedirect(statusCode) {
+    return REDIRECT_CODES.has(statusCode);
+}
 export async function fetch(url, opts = {}) {
     const retryOpts = opts.retry ?? {};
     const maxRetries = retryOpts.retries ?? 2;
@@ -22,9 +23,13 @@ export async function fetch(url, opts = {}) {
     try {
         return await new Promise((resolve, reject) => {
             op.attempt(async (attempt) => {
+                const urlString = typeof url === 'string' ? url : url.href ?? url.toString();
+                const { retry: _retry, timeout, dispatcher, ...fetchOpts } = opts;
+                const signal = timeout ? AbortSignal.timeout(timeout) : undefined;
                 try {
-                    // this will be retried
-                    const res = await nodeFetch(url, opts); // eslint-disable-line
+                    // undici's Response type differs slightly from globalThis.Response (iterator types),
+                    // requiring the double cast. This is a known TypeScript/undici compatibility issue.
+                    const res = await undiciFetch(urlString, { ...fetchOpts, signal, dispatcher });
                     // A retry on 409 sometimes helps when making requests to the Bit registry.
                     if ((res.status >= 500 && res.status < 600) || [408, 409, 420, 429].includes(res.status)) {
                         throw new ResponseError(res);
@@ -34,24 +39,42 @@ export async function fetch(url, opts = {}) {
                     }
                 }
                 catch (error) {
-                    assert(util.types.isNativeError(error));
-                    if ('code' in error &&
-                        typeof error.code === 'string' &&
-                        NO_RETRY_ERROR_CODES.has(error.code)) {
+                    // Undici errors may not pass isNativeError check, so we handle them more carefully
+                    const err = error;
+                    // Check error code in both error.code and error.cause.code (undici wraps errors)
+                    const errorCode = err?.code ?? err?.cause?.code;
+                    if (typeof errorCode === 'string' &&
+                        NO_RETRY_ERROR_CODES.has(errorCode)) {
                         throw error;
                     }
-                    const timeout = op.retry(error);
-                    if (timeout === false) {
+                    const retryTimeout = op.retry(err);
+                    if (retryTimeout === false) {
                         reject(op.mainError());
                         return;
                     }
+                    // Extract error properties into a plain object because Error properties
+                    // are non-enumerable and don't serialize well through the logging system
+                    const errorInfo = {
+                        name: err.name,
+                        message: err.message,
+                        code: err.code,
+                        errno: err.errno,
+                        // For HTTP errors from ResponseError class
+                        status: err.status,
+                        statusCode: err.statusCode,
+                        // undici wraps the actual network error in a cause property
+                        cause: err.cause ? {
+                            code: err.cause.code,
+                            errno: err.cause.errno,
+                        } : undefined,
+                    };
                     requestRetryLogger.debug({
                         attempt,
-                        error,
+                        error: errorInfo,
                         maxRetries,
                         method: opts.method ?? 'GET',
-                        timeout,
-                        url: url.toString(),
+                        timeout: retryTimeout,
+                        url: urlString,
                     });
                 }
             });

package/lib/fetchFromRegistry.d.ts

@@ -1,14 +1,15 @@
+import { URL } from 'node:url';
 import type { FetchFromRegistry } from '@pnpm/fetching.types';
-import { type AgentOptions } from '@pnpm/network.agent';
-import type { SslConfig } from '@pnpm/types';
-import { type RequestInfo, type RequestInit, type Response } from './fetch.js';
-export interface FetchWithAgentOptions extends RequestInit {
-    agentOptions: AgentOptions;
+import type { RegistryConfig } from '@pnpm/types';
+import { type DispatcherOptions } from './dispatcher.js';
+import { type RequestInit } from './fetch.js';
+export interface FetchWithDispatcherOptions extends RequestInit {
+    dispatcherOptions: DispatcherOptions;
 }
-export declare function fetchWithAgent(url: RequestInfo, opts: FetchWithAgentOptions): Promise<Response>;
-export type { AgentOptions };
-export interface CreateFetchFromRegistryOptions extends AgentOptions {
+export declare function fetchWithDispatcher(url: string | URL, opts: FetchWithDispatcherOptions): Promise<Response>;
+export type { DispatcherOptions };
+export interface CreateFetchFromRegistryOptions extends DispatcherOptions {
     userAgent?: string;
-    sslConfigs?: Record<string, SslConfig>;
+    configByUri?: Record<string, RegistryConfig>;
 }
 export declare function createFetchFromRegistry(defaultOpts: CreateFetchFromRegistryOptions): FetchFromRegistry;

package/lib/fetchFromRegistry.js

@@ -1,5 +1,5 @@
 import { URL } from 'node:url';
-import { getAgent } from '@pnpm/network.agent';
+import { getDispatcher } from './dispatcher.js';
 import { fetch, isRedirect } from './fetch.js';
 const USER_AGENT = 'pnpm'; // or maybe make it `${pkg.name}/${pkg.version} (+https://npm.im/${pkg.name})`
 const FULL_DOC = 'application/json';
@@ -7,17 +7,14 @@ const ACCEPT_FULL_DOC = `${FULL_DOC}; q=1.0, */*`;
 const ABBREVIATED_DOC = 'application/vnd.npm.install-v1+json';
 const ACCEPT_ABBREVIATED_DOC = `${ABBREVIATED_DOC}; q=1.0, ${FULL_DOC}; q=0.8, */*`;
 const MAX_FOLLOWED_REDIRECTS = 20;
-export function fetchWithAgent(url, opts) {
-    const agent = getAgent(url.toString(), {
-        ...opts.agentOptions,
-        strictSsl: opts.agentOptions.strictSsl ?? true,
-    }); // eslint-disable-line
-    const headers = opts.headers ?? {};
-    // @ts-expect-error
-    headers['connection'] = agent ? 'keep-alive' : 'close';
+export function fetchWithDispatcher(url, opts) {
+    const dispatcher = getDispatcher(url.toString(), {
+        ...opts.dispatcherOptions,
+        strictSsl: opts.dispatcherOptions.strictSsl ?? true,
+    });
     return fetch(url, {
         ...opts,
-        agent,
+        dispatcher,
     });
 }
 export function createFetchFromRegistry(defaultOpts) {
@@ -30,27 +27,38 @@ export function createFetchFromRegistry(defaultOpts) {
                 userAgent: defaultOpts.userAgent,
             }),
         };
+        if (opts?.ifNoneMatch) {
+            headers['if-none-match'] = opts.ifNoneMatch;
+        }
+        if (opts?.ifModifiedSince) {
+            headers['if-modified-since'] = opts.ifModifiedSince;
+        }
+        // Merge caller-provided headers (e.g. content-type, npm-otp) on top
+        if (opts?.headers) {
+            const optsHeaders = opts.headers instanceof Headers
+                ? Object.fromEntries(opts.headers.entries())
+                : Array.isArray(opts.headers)
+                    ? Object.fromEntries(opts.headers)
+                    : opts.headers;
+            Object.assign(headers, optsHeaders);
+        }
         let redirects = 0;
         let urlObject = new URL(url);
         const originalHost = urlObject.host;
         /* eslint-disable no-await-in-loop */
         while (true) {
-            const agentOptions = {
+            const dispatcherOptions = {
                 ...defaultOpts,
                 ...opts,
                 strictSsl: defaultOpts.strictSsl ?? true,
-            }; // eslint-disable-line
-            // We should pass a URL object to node-fetch till this is not resolved:
-            // https://github.com/bitinn/node-fetch/issues/245
-            const response = await fetchWithAgent(urlObject, {
-                agentOptions: {
-                    ...agentOptions,
-                    clientCertificates: defaultOpts.sslConfigs,
-                },
-                // if verifying integrity, node-fetch must not decompress
-                compress: opts?.compress ?? false,
-                method: opts?.method,
+                clientCertificates: extractTlsConfigs(defaultOpts.configByUri),
+            };
+            const response = await fetchWithDispatcher(urlObject, {
+                dispatcherOptions,
+                body: opts?.body,
+                // if verifying integrity, native fetch must not decompress
                 headers,
+                method: opts?.method,
                 redirect: 'manual',
                 retry: opts?.retry,
                 timeout: opts?.timeout ?? 60000,
@@ -81,6 +89,18 @@ function getHeaders(opts) {
     }
     return headers;
 }
+function extractTlsConfigs(configByUri) {
+    if (!configByUri)
+        return undefined;
+    let result;
+    for (const [uri, config] of Object.entries(configByUri)) {
+        if (config.tls) {
+            result ??= {};
+            result[uri] = config.tls;
+        }
+    }
+    return result;
+}
 function resolveRedirectUrl(response, currentUrl) {
     const location = response.headers.get('location');
     if (!location) {

package/lib/index.d.ts

@@ -1,3 +1,4 @@
-export { fetch, type RetryTimeoutOptions } from './fetch.js';
-export { type AgentOptions, createFetchFromRegistry, type CreateFetchFromRegistryOptions, fetchWithAgent } from './fetchFromRegistry.js';
+export { clearDispatcherCache, getDispatcher } from './dispatcher.js';
+export { fetch, isRedirect, type RetryTimeoutOptions } from './fetch.js';
+export { createFetchFromRegistry, type CreateFetchFromRegistryOptions, type DispatcherOptions, fetchWithDispatcher } from './fetchFromRegistry.js';
 export type { FetchFromRegistry } from '@pnpm/fetching.types';

package/lib/index.js

@@ -1,3 +1,4 @@
-export { fetch } from './fetch.js';
-export { createFetchFromRegistry, fetchWithAgent } from './fetchFromRegistry.js';
+export { clearDispatcherCache, getDispatcher } from './dispatcher.js';
+export { fetch, isRedirect } from './fetch.js';
+export { createFetchFromRegistry, fetchWithDispatcher } from './fetchFromRegistry.js';
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pnpm/network.fetch",
-  "version": "1000.2.6",
-  "description": "node-fetch with retries",
+  "version": "1100.0.0",
+  "description": "Native fetch with retries",
   "keywords": [
     "pnpm",
     "pnpm11",
@@ -26,21 +26,23 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/network.agent": "^2.0.3",
+    "@pnpm/config.nerf-dart": "^1.0.0",
     "@zkochan/retry": "^0.2.0",
-    "node-fetch": "^3.3.2",
-    "@pnpm/core-loggers": "1001.0.4",
-    "@pnpm/fetching.types": "1000.2.0",
-    "@pnpm/types": "1000.9.0"
+    "lru-cache": "^11.2.7",
+    "socks": "^2.8.1",
+    "undici": "^7.2.0",
+    "@pnpm/core-loggers": "1100.0.0",
+    "@pnpm/error": "1100.0.0",
+    "@pnpm/fetching.types": "1100.0.0",
+    "@pnpm/types": "1100.0.0"
   },
   "peerDependencies": {
     "@pnpm/logger": ">=1001.0.0 <1002.0.0"
   },
   "devDependencies": {
     "https-proxy-server-express": "0.1.2",
-    "nock": "13.3.4",
-    "@pnpm/logger": "1001.0.1",
-    "@pnpm/network.fetch": "1000.2.6"
+    "@pnpm/network.fetch": "1100.0.0",
+    "@pnpm/logger": "1100.0.0"
   },
   "engines": {
     "node": ">=22.13"
@@ -50,8 +52,8 @@
   },
   "scripts": {
     "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
-    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
-    "test": "pnpm run compile && pnpm run _test",
-    "compile": "tsgo --build && pnpm run lint --fix"
+    "test": "pn compile && pn .test",
+    "compile": "tsgo --build && pn lint --fix",
+    ".test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
   }
 }