recker 1.0.2-0 → 1.0.4

package/dist/plugins/http2-push.d.ts

@@ -0,0 +1,64 @@
+import type { Client } from '../core/client.js';
+import * as http2 from 'node:http2';
+import { EventEmitter } from 'node:events';
+export interface PushPromise {
+    path: string;
+    method: string;
+    headers: Record<string, string | string[]>;
+    authority: string;
+    scheme: string;
+}
+export interface PushedResource {
+    promise: PushPromise;
+    status: number;
+    headers: Record<string, string | string[]>;
+    body: Buffer;
+    receivedAt: Date;
+}
+export interface Http2PushOptions {
+    enabled?: boolean;
+    maxConcurrentPushes?: number;
+    pushTimeout?: number;
+    cachePushes?: boolean;
+    maxCacheSize?: number;
+    cacheTtl?: number;
+    filter?: (promise: PushPromise) => boolean;
+    onPush?: (resource: PushedResource) => void;
+}
+export declare class Http2PushManager extends EventEmitter {
+    private options;
+    private sessions;
+    private pushCache;
+    private pendingPushes;
+    constructor(options?: Http2PushOptions);
+    connect(url: string): Promise<http2.ClientHttp2Session>;
+    request(url: string, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: Buffer | string;
+    }): Promise<{
+        status: number;
+        headers: Record<string, string | string[]>;
+        body: Buffer;
+    }>;
+    getCachedPush(url: string): PushedResource | null;
+    waitForPush(url: string, timeout?: number): Promise<PushedResource | null>;
+    getCachedPushes(): Map<string, PushedResource>;
+    clearCache(): void;
+    close(): Promise<void>;
+    getSession(origin: string): http2.ClientHttp2Session | undefined;
+    private setupPushHandling;
+    private handlePushStream;
+    private cacheResource;
+    private getCacheKey;
+}
+export declare function http2Push(options: {
+    manager: Http2PushManager;
+}): (client: Client) => void;
+declare module '../core/client.js' {
+    interface Client {
+        getPushManager(): Http2PushManager;
+    }
+}
+export { http2 };
+//# sourceMappingURL=http2-push.d.ts.map

package/dist/plugins/http2-push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http2-push.d.ts","sourceRoot":"","sources":["../../src/plugins/http2-push.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,WAAW;IAE1B,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAE3C,SAAS,EAAE,MAAM,CAAC;IAElB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAE7B,OAAO,EAAE,WAAW,CAAC;IAErB,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAE3C,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAE/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;IAE3C,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAC;CAC7C;AAgCD,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,QAAQ,CAAoD;IACpE,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,aAAa,CAAmD;gBAE5D,OAAO,GAAE,gBAAqB;IAiBpC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,kBAAkB,CAAC;IAuCvD,OAAO,CACX,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;QACP,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACnB,GACL,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IA8DxF,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAkB3C,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAqChF,eAAe,IAAI,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;IAgB9C,UAAU,IAAI,IAAI;IAOZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5B,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,kBAAkB,GAAG,SAAS;IAIhE,OAAO,CAAC,iBAAiB;IA4CzB,OAAO,CAAC,gBAAgB;IA0CxB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,WAAW;CAQpB;AAuBD,wBAAgB,SAAS,CAAC,OAAO,EAAE;IAAE,OAAO,EAAE,gBAAgB,CAAA;CAAE,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAoC1F;AAGD,OAAO,QAAQ,mBAAmB,CAAC;IACjC,UAAU,MAAM;QACd,cAAc,IAAI,gBAAgB,CAAC;KACpC;CACF;AAED,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/plugins/http2-push.js

@@ -0,0 +1,274 @@
+import * as http2 from 'node:http2';
+import { EventEmitter } from 'node:events';
+export class Http2PushManager extends EventEmitter {
+    options;
+    sessions = new Map();
+    pushCache = new Map();
+    pendingPushes = new Map();
+    constructor(options = {}) {
+        super();
+        this.options = {
+            enabled: options.enabled ?? true,
+            maxConcurrentPushes: options.maxConcurrentPushes ?? 100,
+            pushTimeout: options.pushTimeout ?? 30000,
+            cachePushes: options.cachePushes ?? true,
+            maxCacheSize: options.maxCacheSize ?? 100,
+            cacheTtl: options.cacheTtl ?? 60000,
+            filter: options.filter ?? (() => true),
+            onPush: options.onPush ?? (() => { }),
+        };
+    }
+    async connect(url) {
+        const parsedUrl = new URL(url);
+        const origin = parsedUrl.origin;
+        const existingSession = this.sessions.get(origin);
+        if (existingSession && !existingSession.closed && !existingSession.destroyed) {
+            return existingSession;
+        }
+        return new Promise((resolve, reject) => {
+            const session = http2.connect(origin, {
+                settings: {
+                    enablePush: this.options.enabled,
+                    maxConcurrentStreams: this.options.maxConcurrentPushes,
+                },
+            });
+            session.on('error', (err) => {
+                this.emit('error', err);
+                reject(err);
+            });
+            session.on('connect', () => {
+                this.sessions.set(origin, session);
+                this.setupPushHandling(session, origin);
+                resolve(session);
+            });
+            session.on('close', () => {
+                this.sessions.delete(origin);
+                this.emit('sessionClosed', origin);
+            });
+        });
+    }
+    async request(url, options = {}) {
+        const parsedUrl = new URL(url);
+        const origin = parsedUrl.origin;
+        const path = parsedUrl.pathname + parsedUrl.search;
+        const cached = this.getCachedPush(url);
+        if (cached) {
+            this.emit('cacheHit', url, cached);
+            return {
+                status: cached.status,
+                headers: cached.headers,
+                body: cached.body,
+            };
+        }
+        const session = await this.connect(origin);
+        return new Promise((resolve, reject) => {
+            const reqHeaders = {
+                ':method': options.method ?? 'GET',
+                ':path': path,
+                ':scheme': parsedUrl.protocol.replace(':', ''),
+                ':authority': parsedUrl.host,
+                ...options.headers,
+            };
+            const stream = session.request(reqHeaders);
+            const chunks = [];
+            let responseHeaders = {};
+            let status = 0;
+            stream.on('response', (headers) => {
+                status = headers[':status'];
+                responseHeaders = { ...headers };
+                delete responseHeaders[':status'];
+            });
+            stream.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            stream.on('end', () => {
+                resolve({
+                    status,
+                    headers: responseHeaders,
+                    body: Buffer.concat(chunks),
+                });
+            });
+            stream.on('error', reject);
+            if (options.body) {
+                stream.write(options.body);
+            }
+            stream.end();
+        });
+    }
+    getCachedPush(url) {
+        const cacheKey = this.getCacheKey(url);
+        const entry = this.pushCache.get(cacheKey);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt) {
+            this.pushCache.delete(cacheKey);
+            return null;
+        }
+        return entry.resource;
+    }
+    async waitForPush(url, timeout) {
+        const cacheKey = this.getCacheKey(url);
+        const cached = this.getCachedPush(url);
+        if (cached)
+            return cached;
+        const pending = this.pendingPushes.get(cacheKey);
+        if (pending)
+            return pending;
+        return new Promise((resolve) => {
+            const timeoutMs = timeout ?? this.options.pushTimeout;
+            const timer = setTimeout(() => {
+                this.removeListener('push', handler);
+                resolve(null);
+            }, timeoutMs);
+            const handler = (resource) => {
+                const resourceKey = this.getCacheKey(`${resource.promise.scheme}://${resource.promise.authority}${resource.promise.path}`);
+                if (resourceKey === cacheKey) {
+                    clearTimeout(timer);
+                    this.removeListener('push', handler);
+                    resolve(resource);
+                }
+            };
+            this.on('push', handler);
+        });
+    }
+    getCachedPushes() {
+        const result = new Map();
+        const now = Date.now();
+        for (const [key, entry] of this.pushCache.entries()) {
+            if (now <= entry.expiresAt) {
+                result.set(key, entry.resource);
+            }
+        }
+        return result;
+    }
+    clearCache() {
+        this.pushCache.clear();
+    }
+    async close() {
+        const closePromises = [];
+        for (const session of this.sessions.values()) {
+            closePromises.push(new Promise((resolve) => {
+                session.close(() => resolve());
+            }));
+        }
+        await Promise.all(closePromises);
+        this.sessions.clear();
+    }
+    getSession(origin) {
+        return this.sessions.get(origin);
+    }
+    setupPushHandling(session, origin) {
+        session.on('stream', (pushedStream, requestHeaders) => {
+            const promise = {
+                path: requestHeaders[':path'],
+                method: requestHeaders[':method'] ?? 'GET',
+                authority: requestHeaders[':authority'] ?? new URL(origin).host,
+                scheme: requestHeaders[':scheme'] ?? 'https',
+                headers: { ...requestHeaders },
+            };
+            if (!this.options.filter(promise)) {
+                pushedStream.close(http2.constants.NGHTTP2_CANCEL);
+                this.emit('pushRejected', promise);
+                return;
+            }
+            this.emit('pushPromise', promise);
+            const cacheKey = this.getCacheKey(`${promise.scheme}://${promise.authority}${promise.path}`);
+            const pushPromise = this.handlePushStream(pushedStream, promise);
+            this.pendingPushes.set(cacheKey, pushPromise);
+            pushPromise
+                .then((resource) => {
+                this.pendingPushes.delete(cacheKey);
+                if (this.options.cachePushes) {
+                    this.cacheResource(cacheKey, resource);
+                }
+                this.options.onPush(resource);
+                this.emit('push', resource);
+            })
+                .catch((err) => {
+                this.pendingPushes.delete(cacheKey);
+                this.emit('pushError', err, promise);
+            });
+        });
+    }
+    handlePushStream(stream, promise) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let responseHeaders = {};
+            let status = 0;
+            const timeout = setTimeout(() => {
+                stream.close(http2.constants.NGHTTP2_CANCEL);
+                reject(new Error(`Push stream timeout for ${promise.path}`));
+            }, this.options.pushTimeout);
+            stream.on('response', (headers) => {
+                status = headers[':status'];
+                responseHeaders = { ...headers };
+                delete responseHeaders[':status'];
+            });
+            stream.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            stream.on('end', () => {
+                clearTimeout(timeout);
+                resolve({
+                    promise,
+                    status,
+                    headers: responseHeaders,
+                    body: Buffer.concat(chunks),
+                    receivedAt: new Date(),
+                });
+            });
+            stream.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    cacheResource(key, resource) {
+        if (this.pushCache.size >= this.options.maxCacheSize) {
+            const oldestKey = this.pushCache.keys().next().value;
+            if (oldestKey) {
+                this.pushCache.delete(oldestKey);
+            }
+        }
+        this.pushCache.set(key, {
+            resource,
+            expiresAt: Date.now() + this.options.cacheTtl,
+        });
+    }
+    getCacheKey(url) {
+        try {
+            const parsed = new URL(url);
+            return `${parsed.origin}${parsed.pathname}${parsed.search}`;
+        }
+        catch {
+            return url;
+        }
+    }
+}
+export function http2Push(options) {
+    const { manager } = options;
+    const middleware = async (req, next) => {
+        const cached = manager.getCachedPush(req.url);
+        if (cached && req.method === 'GET') {
+            const headers = new Headers();
+            for (const [key, value] of Object.entries(cached.headers)) {
+                if (!key.startsWith(':')) {
+                    headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+                }
+            }
+            headers.set('X-Push-Cache', 'hit');
+            const response = new Response(new Uint8Array(cached.body), {
+                status: cached.status,
+                headers,
+            });
+            const { HttpResponse } = await import('../core/response.js');
+            return new HttpResponse(response);
+        }
+        return next(req);
+    };
+    return (client) => {
+        client.use(middleware);
+        client.getPushManager = () => manager;
+    };
+}
+export { http2 };

package/dist/plugins/http3.d.ts

@@ -0,0 +1,76 @@
+import type { Client } from '../core/client.js';
+import { EventEmitter } from 'node:events';
+export interface Http3Options {
+    enabled?: boolean;
+    preferHttp3?: boolean;
+    fallback?: boolean;
+    connectTimeout?: number;
+    cacheAltSvc?: boolean;
+    altSvcCacheTtl?: number;
+    enable0RTT?: boolean;
+    alpnProtocols?: string[];
+    onHttp3?: (url: string) => void;
+    onFallback?: (url: string, reason: string) => void;
+}
+interface AltSvcEntry {
+    protocol: string;
+    host: string;
+    port: number;
+    maxAge: number;
+    expiresAt: number;
+}
+export declare class Http3Manager extends EventEmitter {
+    private options;
+    private altSvcCache;
+    private http3Supported;
+    private quicAvailable;
+    constructor(options?: Http3Options);
+    checkQuicSupport(): Promise<boolean>;
+    recordAltSvc(origin: string, altSvcHeader: string): void;
+    isHttp3Available(url: string): boolean;
+    getHttp3Endpoint(url: string): {
+        host: string;
+        port: number;
+        protocol: string;
+    } | null;
+    getKnownEndpoints(): Map<string, AltSvcEntry[]>;
+    clearCache(): void;
+    markUnsupported(origin: string): void;
+    getConnectionInfo(url: string): {
+        supportsHttp3: boolean;
+        endpoint: {
+            host: string;
+            port: number;
+            protocol: string;
+        } | null;
+        nativeQuicAvailable: boolean;
+    };
+}
+export declare function http3(options: {
+    manager: Http3Manager;
+}): (client: Client) => void;
+export declare function detectHttp3Support(client: Client, url: string): Promise<{
+    supported: boolean;
+    protocols: string[];
+    endpoint: {
+        host: string;
+        port: number;
+    } | null;
+    altSvcHeader: string | null;
+}>;
+declare module '../core/client.js' {
+    interface Client {
+        getHttp3Manager(): Http3Manager;
+        http3Info(url: string): {
+            supportsHttp3: boolean;
+            endpoint: {
+                host: string;
+                port: number;
+                protocol: string;
+            } | null;
+            nativeQuicAvailable: boolean;
+        };
+    }
+}
+export {};
+//# sourceMappingURL=http3.d.ts.map

package/dist/plugins/http3.d.ts.map

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

package/dist/plugins/http3.js

@@ -0,0 +1,231 @@
+import { EventEmitter } from 'node:events';
+function parseAltSvc(header, origin) {
+    const entries = [];
+    const parts = header.split(',').map((p) => p.trim());
+    const originUrl = new URL(origin);
+    for (const part of parts) {
+        const match = part.match(/^([\w-]+)="?([^";\s]*)"?(?:;\s*ma=(\d+))?/);
+        if (!match)
+            continue;
+        const [, protocol, hostPort, maxAgeStr] = match;
+        const maxAge = maxAgeStr ? parseInt(maxAgeStr, 10) : 86400;
+        let host = originUrl.hostname;
+        let port = parseInt(originUrl.port || '443', 10);
+        if (hostPort) {
+            if (hostPort.startsWith(':')) {
+                port = parseInt(hostPort.slice(1), 10);
+            }
+            else {
+                const [h, p] = hostPort.split(':');
+                if (h)
+                    host = h;
+                if (p)
+                    port = parseInt(p, 10);
+            }
+        }
+        entries.push({
+            protocol,
+            host,
+            port,
+            maxAge,
+            expiresAt: Date.now() + maxAge * 1000,
+        });
+    }
+    return entries;
+}
+export class Http3Manager extends EventEmitter {
+    options;
+    altSvcCache = new Map();
+    http3Supported = new Map();
+    quicAvailable = null;
+    constructor(options = {}) {
+        super();
+        this.options = {
+            enabled: options.enabled ?? true,
+            preferHttp3: options.preferHttp3 ?? true,
+            fallback: options.fallback ?? true,
+            connectTimeout: options.connectTimeout ?? 5000,
+            cacheAltSvc: options.cacheAltSvc ?? true,
+            altSvcCacheTtl: options.altSvcCacheTtl ?? 86400000,
+            enable0RTT: options.enable0RTT ?? false,
+            alpnProtocols: options.alpnProtocols ?? ['h3', 'h3-29', 'h2', 'http/1.1'],
+            onHttp3: options.onHttp3 ?? (() => { }),
+            onFallback: options.onFallback ?? (() => { }),
+        };
+    }
+    async checkQuicSupport() {
+        if (this.quicAvailable !== null) {
+            return this.quicAvailable;
+        }
+        try {
+            const [major] = process.versions.node.split('.').map(Number);
+            if (major < 23) {
+                this.quicAvailable = false;
+                return false;
+            }
+            await import('node:quic').catch(() => null);
+            this.quicAvailable = true;
+            this.emit('quicAvailable');
+            return true;
+        }
+        catch {
+            this.quicAvailable = false;
+            return false;
+        }
+    }
+    recordAltSvc(origin, altSvcHeader) {
+        if (!this.options.cacheAltSvc)
+            return;
+        const entries = parseAltSvc(altSvcHeader, origin);
+        const http3Entries = entries.filter((e) => e.protocol.startsWith('h3') || e.protocol === 'quic');
+        if (http3Entries.length > 0) {
+            const maxExpiresAt = Date.now() + this.options.altSvcCacheTtl;
+            const cappedEntries = http3Entries.map((e) => ({
+                ...e,
+                expiresAt: Math.min(e.expiresAt, maxExpiresAt),
+            }));
+            this.altSvcCache.set(origin, cappedEntries);
+            this.http3Supported.set(origin, true);
+            this.emit('http3Discovered', origin, cappedEntries);
+        }
+    }
+    isHttp3Available(url) {
+        if (!this.options.enabled)
+            return false;
+        try {
+            const origin = new URL(url).origin;
+            const cached = this.altSvcCache.get(origin);
+            if (!cached)
+                return false;
+            const now = Date.now();
+            const valid = cached.filter((e) => e.expiresAt > now);
+            if (valid.length === 0) {
+                this.altSvcCache.delete(origin);
+                this.http3Supported.delete(origin);
+                return false;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getHttp3Endpoint(url) {
+        try {
+            const origin = new URL(url).origin;
+            const cached = this.altSvcCache.get(origin);
+            if (!cached)
+                return null;
+            const now = Date.now();
+            const valid = cached.filter((e) => e.expiresAt > now);
+            const sorted = valid.sort((a, b) => {
+                if (a.protocol === 'h3' && b.protocol !== 'h3')
+                    return -1;
+                if (a.protocol !== 'h3' && b.protocol === 'h3')
+                    return 1;
+                return 0;
+            });
+            const entry = sorted[0];
+            if (!entry)
+                return null;
+            return {
+                host: entry.host,
+                port: entry.port,
+                protocol: entry.protocol,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    getKnownEndpoints() {
+        const now = Date.now();
+        const result = new Map();
+        for (const [origin, entries] of this.altSvcCache) {
+            const valid = entries.filter((e) => e.expiresAt > now);
+            if (valid.length > 0) {
+                result.set(origin, valid);
+            }
+        }
+        return result;
+    }
+    clearCache() {
+        this.altSvcCache.clear();
+        this.http3Supported.clear();
+    }
+    markUnsupported(origin) {
+        this.altSvcCache.delete(origin);
+        this.http3Supported.set(origin, false);
+        this.emit('http3Unsupported', origin);
+    }
+    getConnectionInfo(url) {
+        return {
+            supportsHttp3: this.isHttp3Available(url),
+            endpoint: this.getHttp3Endpoint(url),
+            nativeQuicAvailable: this.quicAvailable ?? false,
+        };
+    }
+}
+export function http3(options) {
+    const { manager } = options;
+    const middleware = async (req, next) => {
+        const response = await next(req);
+        const altSvc = response.headers.get('alt-svc');
+        if (altSvc) {
+            try {
+                const origin = new URL(req.url).origin;
+                manager.recordAltSvc(origin, altSvc);
+            }
+            catch {
+            }
+        }
+        return response;
+    };
+    return (client) => {
+        client.use(middleware);
+        client.getHttp3Manager = () => manager;
+        client.http3Info = (url) => {
+            return manager.getConnectionInfo(url);
+        };
+    };
+}
+export async function detectHttp3Support(client, url) {
+    try {
+        const response = await client.head(url);
+        const altSvc = response.headers.get('alt-svc');
+        if (!altSvc) {
+            return {
+                supported: false,
+                protocols: [],
+                endpoint: null,
+                altSvcHeader: null,
+            };
+        }
+        const entries = parseAltSvc(altSvc, url);
+        const http3Entries = entries.filter((e) => e.protocol.startsWith('h3') || e.protocol === 'quic');
+        if (http3Entries.length === 0) {
+            return {
+                supported: false,
+                protocols: [],
+                endpoint: null,
+                altSvcHeader: altSvc,
+            };
+        }
+        const protocols = [...new Set(http3Entries.map((e) => e.protocol))];
+        const primary = http3Entries[0];
+        return {
+            supported: true,
+            protocols,
+            endpoint: primary ? { host: primary.host, port: primary.port } : null,
+            altSvcHeader: altSvc,
+        };
+    }
+    catch {
+        return {
+            supported: false,
+            protocols: [],
+            endpoint: null,
+            altSvcHeader: null,
+        };
+    }
+}

package/dist/plugins/interface-rotator.d.ts

@@ -0,0 +1,10 @@
+import { Plugin } from '../types/index.js';
+export interface InterfaceRotatorOptions {
+    strategy?: 'round-robin' | 'random';
+    interface?: string | RegExp;
+    family?: 'IPv4' | 'IPv6' | 'both';
+    excludeInternal?: boolean;
+    ips?: string[];
+}
+export declare function interfaceRotator(options?: InterfaceRotatorOptions): Plugin;
+//# sourceMappingURL=interface-rotator.d.ts.map

package/dist/plugins/interface-rotator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface-rotator.d.ts","sourceRoot":"","sources":["../../src/plugins/interface-rotator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,mBAAmB,CAAC;AAI1D,MAAM,WAAW,uBAAuB;IAKtC,QAAQ,CAAC,EAAE,aAAa,GAAG,QAAQ,CAAC;IAMpC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAM5B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAMlC,eAAe,CAAC,EAAE,OAAO,CAAC;IAM1B,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,MAAM,CAyE9E"}